total_width:\n newxmax = total_width\n newxmin = newxmax - newwidth\n\n assert newxmin >= 0 and newxmin <= total_width\n\n #print \"**** Zoom: %s, pan: %s, total_width: %s, newwidth: %s, newmid: %s, newxmin: %s, newxmax: %s\" \\\n # %(self.GetParent().zoom,self.GetParent().pan,total_width,newwidth,newmid,newxmin,newxmax)\n\n left = 0\n width_so_far = 0\n self.figure.clear()\n braggsmax = max(flex.max(r.culled_braggs) for r in runs)\n braggsmin = min(flex.min(r.culled_braggs) for r in runs)\n distsmax = max(flex.max(r.culled_distances) for r in runs)\n distsmin = min(flex.min(r.culled_distances) for r in runs)\n sifomax = max(flex.max(r.culled_sifoils) for r in runs)\n sifomin = min(flex.min(r.culled_sifoils) for r in runs)\n wavemax = max(flex.max(r.culled_wavelengths) for r in runs)\n wavemin = min(flex.min(r.culled_wavelengths) for r in runs)\n\n #above tricks don't work for hit rates as they can be empty if the run is new\n goodruns = []\n for run in runs:\n if len(run.hit_rates) > 0: goodruns.append(run)\n if len(goodruns) > 0:\n hitsmax = max(flex.max(r.hit_rates) for r in goodruns)\n hitsmin = min(flex.min(r.hit_rates) for r in goodruns)\n else:\n hitsmax = hitsmin = 0\n\n first_run = True\n for run in runs:\n right = left + run.width()\n\n if right < newxmin or left > newxmax:\n left += run.width()\n #print \"Not showing run %s\"%run.runId\n continue\n\n if left < newxmin:\n xmin = run.min() + (newxmin - left)\n else:\n xmin = run.min()\n\n if right > newxmax:\n xmax = run.min() + (newxmax - left)\n else:\n xmax = run.max()\n\n #print \"Run: %s, run.width(): %s, left: %s, right: %s, run.min(): %s, run.max(): %s, xmin: %s, xmax: %s, width_so_far: %s, xmax-xmin: %s\" \\\n #%(run.runId,run.width(),left,right,run.min(),run.max(),xmin,xmax,width_so_far,xmax-xmin)\n\n ax1 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.05, 0.9*(xmax-xmin)/newwidth, 0.4])\n ax2 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.45, 0.9*(xmax-xmin)/newwidth, 0.2], sharex=ax1)\n ax3 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.65, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\n ax4 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.75, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\n ax5 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.85, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\n left += run.width()\n width_so_far += (xmax-xmin)\n\n ax1.grid(True, color=\"0.75\")\n ax2.grid(True, color=\"0.75\")\n ax3.grid(True, color=\"0.75\")\n ax4.grid(True, color=\"0.75\")\n ax5.grid(True, color=\"0.75\")\n ax1.plot(run.culled_bragg_times.select(run.culled_indexed),\n run.culled_braggs.select(run.culled_indexed), 'd', color=[0.0,1.0,0.0])\n ax1.plot(run.culled_bragg_times.select(~run.culled_indexed),\n run.culled_braggs.select(~run.culled_indexed), 'd', color=[0.0,0.5,1.0])\n ax2.plot(run.hit_rates_times, run.hit_rates, 'o-', color=[0.0,1.0,0.0])\n ax3.plot(run.culled_bragg_times, run.culled_wavelengths, '^', color=[0.8,0.0,0.2])\n ax4.plot(run.culled_bragg_times, run.culled_sifoils, '<', color=[0.8,0.0,0.2])\n ax5.plot(run.culled_bragg_times, run.culled_distances, '>', color=[0.8,0.0,0.2])\n ax1.set_ylabel(\"# of Bragg spots\")\n ax2.set_ylabel(\"Hit rate (%)\")\n ax3.set_ylabel(\"WaveL\")\n ax4.set_ylabel(\"SiFoils(mm)\")\n ax5.set_ylabel(\"Dist (mm)\")\n ax1.set_xlim(xmin, xmax)\n ax1.set_ylim(braggsmin, braggsmax)\n ax2.set_ylim(hitsmin, hitsmax)\n ax3.set_ylim(wavemin, wavemax)\n ax4.set_ylim(sifomin-10, sifomax+10)\n ax5.set_ylim(distsmin-3, distsmax+3)\n ax1.set_xlabel(\"Time\")\n for ax in ax1, ax2, ax3, ax4, ax5:\n if (ax is not ax1) :\n for label in ax.get_xticklabels():\n label.set_visible(False)\n ax.get_yticklabels()[0].set_visible(False)\n if not first_run:\n ax.get_yaxis().set_visible(False)\n\n ax1.xaxis.set_major_formatter(ticker.FuncFormatter(status_plot.format_time))\n ax3.yaxis.set_major_formatter(ticker.FormatStrFormatter(\"%.3f\"))\n ax5.yaxis.set_major_formatter(ticker.FormatStrFormatter(\"%.0f\"))\n ax5.set_title(\"%d:%d/%d:%.1f%% I:%d\"%(run.runId, run.hits_count, len(run.braggs), 100*run.hits_count/len(run.braggs),run.indexed.count(True)))\n\n labels = ax1.get_xticklabels()\n for label in labels:\n label.set_rotation(30)\n\n first_run = False\n\n self.figure.autofmt_xdate()\n self.canvas.draw()\n self.parent.Refresh()\n\n t2 = time.time()\n print(\"Plotted in %.2fs\" % (t2 - t1))"],"string":"[\n \"def compute_visuals(self):\\n pass\",\n \"def visualize(self):\\n # TODO\\n #pyLDAvis.enable_notebook()\\n #vis = pyLDAvis.gensim.prepare(self.lda_model, self.stemmed_corpus)\\n return\",\n \"def visualise(self):\\n\\n scores, education = self.get_data()\\n self.write_data(scores, education)\\n\\n return True\",\n \"def visualize(self):\\n\\n self.check_model()\\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))\",\n \"def visualize(self):\\r\\n self.aggregator.plot_loss()\\r\\n self.save_figure()\",\n \"def visualize(self, U, **kwargs):\\n raise NotImplementedError\",\n \"def test_visualize():\\n # Instantiate three particles for testing\\n particles = [Particle(0.3, 0.5, 1), \\n Particle(0.0, -0.5, -1), \\n Particle(-0.1, -0.4, 3)]\\n simulator = ParticleSimulator(particles)\\n visualize(simulator)\",\n \"def visualize(stuff, **options):\\n separate = r\\\"\\\\newpage\\\" #by default, a new tupel is put on a new page\\n name = \\\"some_text_file\\\" #by default this file is used\\n for key in options:\\n if key == \\\"separate\\\":\\n separate = options[key]\\n if key == \\\"name\\\":\\n name = options[key]\\n works = True\\n totallines = [r\\\"\\\\documentclass{article}\\\", r\\\"\\\\usepackage{xcolor}\\\", r\\\"\\\\usepackage{tikz,pgf}\\\", r\\\"\\\\usepackage[left = 0 cm, top = 0cm, bottom = 0cm, right = 2cm]{geometry}\\\", r\\\"\\\\begin{document}\\\", r\\\"\\\\pagestyle{empty}\\\"]\\n for description in stuff:\\n data = stuff[description]\\n if checkdataformat(description, data):\\n if description == \\\"config\\\":\\n lines = gentikz(data)\\n elif description == \\\"movelist\\\":\\n lines = showmoveslist(data[0], data[1], data[2])\\n elif description == \\\"movelists\\\":\\n lines = compareshowmoveslists(data[0], data[1], data[2])\\n elif description == \\\"list\\\":\\n lines = showlist(data)\\n elif description == \\\"configurations\\\":\\n lines = showconfigurations(data)\\n elif description == \\\"movetable\\\":\\n lines = nktable(data[0], data[1], sort = 'value')\\n elif description == \\\"incrementtable\\\":\\n lines = nktable(data[0], data[1], sort = 'increment')\\n elif description == \\\"totalptable\\\":\\n lines = nktable(data[0], data[1], sort = 'totalpossibilities')\\n elif description == \\\"ptable\\\":\\n lines = nktable(data[0], data[1], sort = 'adjustedpossibilities')\\n elif description == \\\"bfptable\\\":\\n lines = nktable(data[0], data[1], sort = 'bfadjustedpossibilities')\\n else:\\n print(\\\"unknown description\\\")\\n lines = []\\n for line in lines:\\n totallines.append(line)\\n totallines.append(separate)\\n else:\\n print(description, \\\":\\\", data, \\\"don't match, please read help(visualization)\\\")\\n works = False\\n totallines.append(r\\\"\\\\end{document}\\\")\\n if works:\\n compile(totallines, name)\",\n \"def visualize(self):\\n colors = {'outline': (220, 220, 220),\\n 'inlier': (0, 255, 0),\\n 'outlier': (0, 0, 255),\\n 'lines': (128, 220, 128)}\\n # Create output image for visualization\\n gap = 5\\n h1, w1 = self.target.image.shape[:2]\\n h2, w2 = self.image.shape[:2]\\n vis = np.zeros((max(h1, h2), w1 + w2 + gap, 3), np.uint8)\\n vis[:h1, :w1, :] = self.target.image\\n w1 += gap\\n vis[:h2, w1:w1+w2, :] = self.image\\n \\n # Draw the located object \\n quad = np.float32(self.quad) + np.float32([w1, 0])\\n self.draw(vis, colors['outline'], 2, quad)\\n \\n # draw point details\\n inliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.inliers]\\n outliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.outliers]\\n if colors['outlier'] is not None: # draw x on each point\\n r = 2 # radius\\n thickness = 2\\n for x0, y0, x1, y1 in outliers:\\n cv2.line(vis, (x0 - r, y0 - r), (x0 + r, y0 + r), colors['outlier'], thickness)\\n cv2.line(vis, (x0 + r, y0 - r), (x0 - r, y0 + r), colors['outlier'], thickness)\\n cv2.line(vis, (x1 - r, y1 - r), (x1 + r, y1 + r), colors['outlier'], thickness)\\n cv2.line(vis, (x1 + r, y1 - r), (x1 - r, y1 + r), colors['outlier'], thickness)\\n if colors['lines'] is not None:\\n for x0, y0, x1, y1 in inliers:\\n cv2.line(vis, (x0, y0), (x1, y1), colors['lines'], 1)\\n if colors['inlier'] is not None:\\n for x0, y0, x1, y1 in inliers:\\n cv2.circle(vis, (x0, y0), 2, colors['inlier'], -1)\\n cv2.circle(vis, (x1, y1), 2, colors['inlier'], -1)\\n return vis\",\n \"def visualise(self, obj):\\n self.clear()\\n self.draw(obj)\\n self.show()\",\n \"def visualize(original, s, m, l, s_pred, m_pred, l_pred):\\n\\tfig = plt.figure(figsize=(20, 10))\\n\\tplt.subplot(1,7,1)\\n\\tplt.title('Original image')\\n\\tplt.imshow(original)\\n\\n\\tplt.subplot(1,7,2)\\n\\tplt.title('S image')\\n\\tplt.imshow(s)\\n\\tplt.subplot(1,7,3)\\n\\tplt.title('S Pred image')\\n\\tplt.imshow(s_pred)\\n\\n\\tplt.subplot(1,7,4)\\n\\tplt.title('M image')\\n\\tplt.imshow(m)\\n\\tplt.subplot(1,7,5)\\n\\tplt.title('M Pred image')\\n\\tplt.imshow(m_pred)\\n\\n\\tplt.subplot(1,7,6)\\n\\tplt.title('L image')\\n\\tplt.imshow(l)\\n\\tplt.subplot(1,7,7)\\n\\tplt.title('L Pred image')\\n\\tplt.imshow(l_pred)\",\n \"def base_visualization(self, filename, save_format='jpg', cfg=None):\\n # TODO and detailed mode for the visualization function\\n # in which the graph will also contain all the weights/bias\\n # information.\\n # if not cfg:\\n # cfg = {}\\n # graph = graphviz.Digraph(format=save_format)\\n # self.visited.clear()\\n # for _input in self.graph.inputs():\\n # if _input.type().kind() == CLASSTYPE_KIND:\\n # continue\\n # self.visual_traverse(_input, graph, None, cfg)\\n # graph.render(filename)\\n pass\",\n \"def test_vggmini_visualize(self):\\n\\t\\tpass\",\n \"def visualize(self, filename, options = {'showHead'}):\\n\\t\\tVisualizer.useGraphViz(self, filename, options)\",\n \"def main(image_path):\\n temp_dir = tempfile.mkdtemp()\\n print('Saving output to {}'.format(temp_dir))\\n estimator = run_image(image_path)\\n visualize(estimator, image_path, temp_dir)\",\n \"def display(self):\\n options = {\\\"ent_only_plot\\\": True,\\n \\\"rel_only_plot\\\": not self.config.plot_entity_only,\\n \\\"ent_and_rel_plot\\\": not self.config.plot_entity_only}\\n\\n if self.config.plot_embedding:\\n viz = Visualization(model=self.model, vis_opts = options)\\n\\n viz.plot_embedding(resultpath=self.config.figures, algos=self.model.model_name, show_label=False)\\n\\n if self.config.plot_training_result:\\n viz = Visualization(model=self.model)\\n viz.plot_train_result()\\n\\n if self.config.plot_testing_result:\\n viz = Visualization(model=self.model)\\n viz.plot_test_result()\",\n \"def visualize(self, outfn):\\n if self.has_viz_data:\\n pyLDAvis.save_html(self.vis_data, outfn)\\n return\\n assert(self.has_vocab and self.has_corpus)\\n assert(self.is_trained)\\n # this might crash. I think because corpus, vocab, and _lda_model are all big. \\n self.vis_data = prepare(self._lda_model, self.corpus, self.vocab)\\n self.has_viz_data = True\\n pyLDAvis.save_html(self.vis_data, outfn)\",\n \"def visualize_svd():\",\n \"def visualize(self, background, num_labeled=10, magnification=1.0, viz=True, cutoff=100):\\n \\n assert magnification >= 1.0\\n lst_x, lst_y, keys = self.create_xy_table(background, cutoff=cutoff)\\n fig, ax = plt.subplots()\\n low, high = 0.0, round(float(1)/magnification, 1)\\n ax.set_xlim(low, high)\\n ax.set_ylim(low, high)\\n ax.set_aspect('equal')\\n ax.scatter(lst_x, lst_y)\\n\\n for idx, key in enumerate(keys):\\n if idx > num_labeled: txt = ''\\n ax.annotate(key, (lst_x[idx],lst_y[idx]))\\n\\n if viz:\\n plt.show()\\n else:\\n name = self.name if self.name else 'anon'\\n plt.savefig(name)\",\n \"def visualize():\\n model.eval()\\n with torch.no_grad():\\n alpha = model.mu_q_alpha\\n beta = model.get_beta(alpha) \\n \\n print('\\\\n')\\n print('#'*100)\\n print('Visualize topics...') \\n \\n topics_words = []\\n for k in range(args.num_topics):\\n gamma = beta[k, :]\\n top_words = list(gamma.cpu().numpy().argsort()[-args.num_words+1:][::-1]) \\n topic_words = [vocab[a] for a in top_words]\\n topics_words.append(' '.join(topic_words))\\n print('Topic {} .. ===> {}'.format(k, topic_words)) \\n\\n print('\\\\n')\\n print('Visualize word embeddings ...')\\n # queries = ['economic', 'assembly', 'security', 'management', 'debt', 'rights', 'africa']\\n # queries = ['economic', 'assembly', 'security', 'management', 'rights', 'africa']\\n queries = ['border', 'vaccines', 'coronaviruses', 'masks']\\n queries = set(queries).intersection(vocab)\\n try:\\n embeddings = model.rho.weight # Vocab_size x E\\n except:\\n embeddings = model.rho # Vocab_size x E\\n # neighbors = []\\n for word in queries:\\n print('word: {} .. neighbors: {}'.format(\\n word, nearest_neighbors(word, embeddings, vocab, args.num_words)))\\n print('#'*100)\",\n \"def define_visualizations():\\n\\n norm = HtmlVisualizationFormat()\\n norm.slug = \\\"norm\\\"\\n norm.button_title = \\\"normalized\\\"\\n norm.title = \\\"Normalized Text\\\"\\n\\n analytic = HtmlVisualizationFormat()\\n analytic.slug = \\\"analytic\\\"\\n analytic.button_title = \\\"analytic\\\"\\n analytic.title = \\\"Analytic Visualization\\\"\\n\\n dipl = HtmlVisualizationFormat()\\n dipl.slug = \\\"dipl\\\"\\n dipl.button_title = \\\"diplomatic\\\"\\n dipl.title = \\\"Diplomatic Edition\\\"\\n\\n sahidica = HtmlVisualizationFormat()\\n sahidica.slug = \\\"sahidica\\\"\\n sahidica.button_title = \\\"chapter\\\"\\n sahidica.title = \\\"Sahidica Chapter View\\\"\\n\\n for vis in [norm, analytic, dipl, sahidica]:\\n try:\\n HtmlVisualizationFormat.objects.get(slug__exact=vis.slug)\\n except HtmlVisualizationFormat.DoesNotExist:\\n vis.save()\",\n \"def visualize(self):\\n dot = Graph()\\n \\n for k, v in self.vs.items():\\n if v.observed:\\n dot.node(v.word, style=\\\"filled\\\")\\n else:\\n dot.node(v.word)\\n\\n for i, (k, v) in enumerate(self.fs.items()):\\n dot.node(str(i), shape=\\\"square\\\", style=\\\"bold\\\")\\n s, t = k[1], k[3]\\n dot.edge(s, str(i))\\n dot.edge(t, str(i))\\n \\n print dot.source\\n #src.render('test-output/holy-grenade.gv', view=True)\",\n \"def visualize(self, features, targets, my_title=\\\"untitled\\\"):\\n try:\\n import matplotlib.pyplot as plt\\n except:\\n import matplotlib\\n matplotlib.use('Agg')\\n import matplotlib.pyplot as plt\\n\\n plt.figure(figsize=(6,4))\\n #plt.contourf(self.out, cmap=plt.cm.Paired)\\n plt.axis('off')\\n plt.scatter(features[:, 0], features[:, 1], c=self.out)\\n plt.title(my_title)\\n plt.savefig(f'{my_title}.png')\",\n \"def visualize(model: Model, structural_part=True, measurement_part=False,\\n view=True, filename=None, title=''):\\n g = gv.Digraph(format='jpg', graph_attr={'label': title})\\n if structural_part:\\n g.node_attr.update(color='red', shape='box')\\n for i, j in model.parameters['Beta']:\\n lval, rval = model.beta_names[0][i], model.beta_names[0][j]\\n g.edge(rval, lval)\\n if measurement_part:\\n g.node_attr.update(color='black', shape='circle')\\n for i, j in model.parameters['Lambda']:\\n lval, rval = model.lambda_names[0][i], model.lambda_names[0][j]\\n g.edge(lval, rval)\\n g.render(filename, view=view)\",\n \"def _visualize(self, unnorm_image, class_ids, scores, bounding_boxes):\\n ax = utils.viz.plot_bbox(unnorm_image,\\n bounding_boxes[0],\\n scores[0],\\n class_ids[0],\\n class_names=self._network.classes)\\n fig = plt.gcf()\\n fig.set_size_inches(14, 14)\\n plt.show()\",\n \"def viz_samples(data, trace, num_sweeps, K, viz_interval=3, figure_size=3, title_fontsize=20, marker_size=1.0, opacity=0.3, bound=20, colors=['#AA3377','#0077BB', '#EE7733', '#009988', '#BBBBBB', '#EE3377', '#DDCC77'], save_name=None):\\n E_tau, E_mu, E_z = trace['E_tau'].cpu(), trace['E_mu'].cpu(), trace['E_z'].cpu()\\n num_rows = len(data)\\n num_cols = 2 + int((num_sweeps-1) / viz_interval)\\n gs = gridspec.GridSpec(num_rows, num_cols)\\n gs.update(left=0.0 , bottom=0.0, right=1.0, top=1.0, wspace=0, hspace=0)\\n fig = plt.figure(figsize=(figure_size * num_cols, figure_size * num_rows))\\n for row_ind in range(num_rows):\\n ax = fig.add_subplot(gs[row_ind, 0])\\n viz_gmm(ax, data[row_ind], K, marker_size, opacity, bound, colors, latents=None) ## visualize raw dataset in the 1st column\\n if row_ind == 0:\\n ax.set_title('Data', fontsize=title_fontsize)\\n# col_ind = 1\\n for col_ind in range(num_cols-1):\\n sweep = col_ind * viz_interval\\n ax = fig.add_subplot(gs[row_ind, col_ind+1])\\n viz_gmm(ax, data[row_ind], K, marker_size, opacity, bound, colors, latents=(E_tau[sweep, row_ind], E_mu[sweep, row_ind], E_z[sweep, row_ind]))\\n if row_ind == 0:\\n if sweep == 0:\\n ax.set_title('RWS', fontsize=title_fontsize)\\n else:\\n ax.set_title('sweep %d' % sweep, fontsize=title_fontsize)\\n if save_name is not None:\\n plt.savefig(save_name + '.svg', dpi=300)\",\n \"def visualize(self):\\n print('{0} is {1} time steps old'.format(self.name, self.timestep))\\n\\n self.amygdala.visualize(self.timestep, self.name, self.log_dir)\\n self.cerebellum.visualize(self.name, self.log_dir)\\n self.cingulate.visualize(self.name, self.log_dir)\\n self.hippocampus.visualize(self.name, self.log_dir)\\n #self.ganglia.visualize(self.name, self.log_dir)\\n #self.cortex.visualize(self.name, self.log_dir)\",\n \"def visualize(self) -> None:\\n # Record all the user input for visualization\\n self.visualization = self._inner_string.get()\\n self.att_1 = self._inner_string_att1.get()\\n self.att_2 = self._inner_string_att2.get()\\n self.att_3 = self._inner_string_att3.get()\\n self.graph_int = self._graph_int_entry.get()\\n\\n # .get() returns a string thus there occurs this case below ->\\n # This is the case where we did not select Graph Visualization, in this case I am doing this\\n # in order not to receive type error when checking if self.graph > 100\\n if self.graph_int == '':\\n self.graph_int = 0\\n elif int(self.graph_int) > 100:\\n # If the input is higher than 100, automatically set to the highest (100)\\n self.graph_int = 100\\n else:\\n # graph_int is valid\\n self.graph_int = int(self.graph_int)\\n\\n first = self.visualization != 'Choose Visualization' and self.visualization != ''\\n second = self.att_1 != '' and self.att_1 != 'Attribute 1'\\n third = self.att_2 != '' and self.att_2 != 'Attribute 2'\\n fourth = self.att_3 != '' and self.att_3 != 'Attribute 3'\\n\\n if first and second and third and fourth:\\n\\n tk.Label(self.root, text='YOUR *VISUALIZATION* INFORMATION HAS BEEN RECORDED.'\\n ' \\\\n THANK YOU!',\\n font=(\\\"Proxima nova\\\", \\\"9\\\", \\\"bold\\\"), fg='yellow', bg='black').grid()\\n\\n if self.visualization == 'K-means':\\n clusters_file = open('Cluster_Final.pickle', 'rb')\\n centroid_to_clusters = pickle.load(file=clusters_file)\\n k_means = KMeansAlgo(path=\\\"Data/normalized_data_final.csv\\\", k=1)\\n k_means.clusters = centroid_to_clusters\\n k_means.centroids = list(k_means.clusters)\\n k_means.graph_3d(self.att_1, self.att_2, self.att_3, n=5)\\n\\n else: # self.visualization == 'Individual Graph'\\n centroid = self.ordered_centroids[self.graph_int - 1]\\n graph = self.centroid_to_graph[centroid]\\n graph.draw_with_matplotlib_3d(self.att_1, self.att_2, self.att_3)\\n else:\\n print('Invalid visualization options input.\\\\nPlease select all options.')\\n\\n print('Visualization over, you enter another playlist or quit the program.')\",\n \"def setup_visualizer(self, name = 'Lidar', width=960, height=540):\\n\\n self.frame_count = 0\\n self.visualizer = o3d.visualization.Visualizer()\\n\\n self.visualizer.create_window(\\n window_name=name,\\n width=width,\\n height=height,\\n left=int(width/2),\\n top=int(height/2))\\n self.visualizer.get_render_option().background_color = [0.05, 0.05, 0.05]\\n self.visualizer.get_render_option().point_size = 1\\n self.visualizer.get_render_option().show_coordinate_frame = True\",\n \"def displayVisuals(self,visibility):\\n # TODO\\n import warnings\\n warnings.warn(\\\"Visual meshes are always plotted for MeshcatVisualizer\\\", category=UserWarning, stacklevel=2)\\n pass\",\n \"def visualization(data):\\n\\t# preview top 5 row of data\\n\\tprint(\\\"\\\\n--------Data preview--------\\\\n{0}\\\"\\n\\t\\t .format(data.head()))\\n\\tprint(\\\"\\\\nNull value status as follow:\\\\n{0}\\\".format(data.isnull().sum()))\\n\\tcols = [col for col in data.columns]\\n\\tprint(\\\"\\\\nNumber of original features: {0}\\\".format(len(cols)))\\n\\tprint(\\\"\\\\nFeatures types:\\\\n{0}\\\".format(data[cols].dtypes.value_counts()))\\n\\n\\tcounts = [[], [], []]\\n\\tfor col in cols:\\n\\t\\t# the data type of each feature\\n\\t\\ttyp = data[col].dtype\\n\\t\\t# the number of differents value in each feature\\n\\t\\tuniq = len(np.unique(data[col]))\\n\\t\\t# constant value feature\\n\\t\\tif uniq == 1:\\n\\t\\t\\tcounts[0].append(col)\\n\\t\\t# binary value feature\\n\\t\\telif uniq == 2 and typ == np.int64:\\n\\t\\t\\tcounts[1].append(col)\\n\\t\\t# multiple value feature\\n\\t\\telse:\\n\\t\\t\\tcounts[2].append(col)\\n\\n\\tprint('\\\\nConstant features: {}\\\\nBinary features: {} \\\\nCategorical features: {}\\\\n'.format(*[len(c) for c in counts]))\\n\\tprint('Constant features:', counts[0])\\n\\tprint('Binary features:', counts[1])\\n\\tprint('Categorical features:', counts[2])\\n\\n\\tfig, axes = plt.subplots(2,2)\\n\\tfig.set_size_inches(12, 10)\\n\\tsn.boxplot(data=data,y=\\\"count\\\",orient=\\\"v\\\",ax=axes[0][0])\\n\\tsn.boxplot(data=data,y=\\\"count\\\",x=\\\"season\\\",orient=\\\"v\\\",ax=axes[0][1])\\n\\tsn.boxplot(data=data,y=\\\"count\\\",x=\\\"hour\\\",orient=\\\"v\\\",ax=axes[1][0])\\n\\tsn.boxplot(data=data,y=\\\"count\\\",x=\\\"workingday\\\",orient=\\\"v\\\",ax=axes[1][1])\\n\\n\\taxes[0][0].set(ylabel='Count',title=\\\"Box Plot On Count\\\")\\n\\taxes[0][1].set(xlabel='Season', ylabel='Count',title=\\\"Box Plot On Count Across Season\\\")\\n\\taxes[1][0].set(xlabel='Hour Of The Day', ylabel='Count',title=\\\"Box Plot On Count Across Hour Of The Day\\\")\\n\\taxes[1][1].set(xlabel='Working Day', ylabel='Count',title=\\\"Box Plot On Count Across Working Day\\\")\\n\\tplt.show()\\n\\n\\tfig,(ax1,ax2,ax3,ax4)= plt.subplots(nrows=4)\\n\\tfig.set_size_inches(12,20)\\n\\tsortOrder = [1,2,3,4,5,6,7,8,9,10,11,12]\\n\\thueOrder = [\\\"Sunday\\\",\\\"Monday\\\",\\\"Tuesday\\\",\\\"Wednesday\\\",\\\"Thursday\\\",\\\"Friday\\\",\\\"Saturday\\\"]\\n\\n\\tmonthAggregated = pd.DataFrame(data.groupby(\\\"month\\\")[\\\"count\\\"].mean()).reset_index()\\n\\tmonthSorted = monthAggregated.sort_values(by=\\\"count\\\",ascending=False)\\n\\tsn.barplot(data=monthSorted,x=\\\"month\\\",y=\\\"count\\\",ax=ax1,order=sortOrder)\\n\\tax1.set(xlabel='Month', ylabel='Avearage Count',title=\\\"Average Count By Month\\\")\\n\\n\\thourAggregated = pd.DataFrame(data.groupby([\\\"hour\\\",\\\"season\\\"],sort=True)[\\\"count\\\"].mean()).reset_index()\\n\\tsn.pointplot(x=hourAggregated[\\\"hour\\\"], y=hourAggregated[\\\"count\\\"],hue=hourAggregated[\\\"season\\\"],\\n\\t data=hourAggregated, join=True,ax=ax2)\\n\\tax2.set(xlabel='Hour Of The Day', ylabel='Users Count',\\n\\t title=\\\"Average Users Count By Hour Of The Day Across Season\\\",label='big')\\n\\n\\thourAggregated = pd.DataFrame(data.groupby([\\\"hour\\\",\\\"weekday\\\"],sort=True)[\\\"count\\\"].mean()).reset_index()\\n\\tsn.pointplot(x=hourAggregated[\\\"hour\\\"], y=hourAggregated[\\\"count\\\"],hue=hourAggregated[\\\"weekday\\\"],hue_order=hueOrder,\\n\\t data=hourAggregated, join=True,ax=ax3)\\n\\tax3.set(xlabel='Hour Of The Day', ylabel='Users Count',\\n\\t title=\\\"Average Users Count By Hour Of The Day Across Weekdays\\\",label='big')\\n\\n\\thourTransformed = pd.melt(data[[\\\"hour\\\",\\\"casual\\\",\\\"registered\\\"]], id_vars=['hour'], value_vars=['casual', 'registered'])\\n\\thourAggregated = pd.DataFrame(hourTransformed.groupby([\\\"hour\\\",\\\"variable\\\"],sort=True)[\\\"value\\\"].mean()).reset_index()\\n\\tsn.pointplot(x=hourAggregated[\\\"hour\\\"], y=hourAggregated[\\\"value\\\"],hue=hourAggregated[\\\"variable\\\"],\\n\\t hue_order=[\\\"casual\\\",\\\"registered\\\"], data=hourAggregated, join=True,ax=ax4)\\n\\tax4.set(xlabel='Hour Of The Day', ylabel='Users Count',\\n\\t title=\\\"Average Users Count By Hour Of The Day Across User Type\\\",label='big')\\n\\tplt.show()\",\n \"def visualiseSet(dataSet, batchSz=4, objType=ObjType.SingleImgDblr):\\r\\n setLoader = torch.utils.data.DataLoader(dataSet, batch_size=batchSz, shuffle=True, num_workers=0)\\r\\n inputs, targets = next(iter(setLoader))\\r\\n if objType == ObjType.SingleImgDblr:\\r\\n fig, ax = plt.subplots(2, batchSz)\\r\\n else:\\r\\n fig, ax = plt.subplots(2, (targets.shape[1] + 1) // 2, figsize=(19.2, 9.77))\\r\\n rows = ax.shape[0]\\r\\n cols = ax.shape[1]\\r\\n for i in range(rows):\\r\\n for j in range(cols):\\r\\n curAx = ax[i, j]\\r\\n if j == i == 0:\\r\\n showTensorImg(curAx, inputs.squeeze())\\r\\n curAx.set_title('Blurry')\\r\\n else:\\r\\n idx = i * cols + j - 1\\r\\n showTensorImg(curAx, targets.squeeze()[idx])\\r\\n curAx.set_title(f'Sharp {idx + 1}')\\r\\n # plt.tight_layout()\\r\",\n \"def visualize_model():\\n dictionary_vis = gensim.corpora.Dictionary.load('dictionary.gensim')\\n corpus_vis = pickle.load(open('corpus.pkl', 'rb'))\\n lda = gensim.models.ldamodel.LdaModel.load('model5.gensim')\\n lda_display = pyLDAvis.gensim.prepare(lda, corpus_vis, dictionary_vis,\\n sort_topics=False)\\n pyLDAvis.display(lda_display)\",\n \"def visualise(self) -> None:\\n nx_graph = nx.DiGraph()\\n\\n for v in self._vertices:\\n if not v.predicate:\\n name = v.name.split(\\\"/\\\")[-1]\\n nx_graph.add_node(name, name=name, pred=v.predicate)\\n\\n for v in self._vertices:\\n if not v.predicate:\\n v_name = v.name.split(\\\"/\\\")[-1]\\n # Neighbors are predicates\\n for pred in self.get_neighbors(v):\\n pred_name = pred.name.split(\\\"/\\\")[-1]\\n for obj in self.get_neighbors(pred):\\n obj_name = obj.name.split(\\\"/\\\")[-1]\\n nx_graph.add_edge(v_name, obj_name, name=pred_name)\\n\\n plt.figure(figsize=(10, 10))\\n _pos = nx.circular_layout(nx_graph)\\n nx.draw_networkx_nodes(nx_graph, pos=_pos)\\n nx.draw_networkx_edges(nx_graph, pos=_pos)\\n nx.draw_networkx_labels(nx_graph, pos=_pos)\\n names = nx.get_edge_attributes(nx_graph, \\\"name\\\")\\n nx.draw_networkx_edge_labels(nx_graph, pos=_pos, edge_labels=names)\",\n \"def visualization(tv_summary, speech_summary, start, stop, mode='interactive'):\\n\\n # There was a problem with unicode to ascii errors cropping up again in matplotlib\\n # TODO fix encoding errors for the following years\\n skip_years = [1941, 1942, 1945, 1995, 2005, 2006, 2010, 2011]\\n for start_year in [year for year in range(start, stop) if year not in skip_years]:\\n print \\\"Creating figure for \\\" + str(start_year)\\n heat_map, keywords = create_heat_map(source=tv_summary,\\n response=speech_summary,\\n max_keywords=45,\\n start_year=start_year,\\n interval=50)\\n\\n fig = plot_heat_map(heat_map, keywords, start_year)\\n\\n if mode == 'save':\\n # Save fig to file\\n fig.set_size_inches(11, 7.5)\\n fig.savefig('output/output' + str(start_year) + '.png', dpi=100)\\n else:\\n plt.draw()\\n if mode != 'save':\\n plt.show()\",\n \"def visualize(z_in, azimuth=25., elevation=30.,\\n thresholds=[0.95, .9, .75, .5, .25, .125], opacities=[1, .9, .7, .5, .2, .1],\\n# thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1],\\n# thresholds=[0.94, .89, .75], opacities=[.99, .7, .2],\\n# thresholds=[0.7, .5, .2], opacities=[.95, .5, .2],\\n fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'},\\n filename=None, do_axis=True, do_grids=False, draw_projections=True,\\n colorbar=False, f_N=2., f_tN=2., figsize=figsize, dpi=300, figpath=figpath, **kwargs):\\n z = z_in.copy()\\n N_X, N_Y, N_frame = z.shape\\n fx, fy, ft = get_grids(N_X, N_Y, N_frame)\\n\\n # Normalize the amplitude.\\n z /= z.max()\\n\\n from vispy import app, scene, use\\n try:\\n AffineTransform = scene.transforms.AffineTransform\\n except:\\n AffineTransform = scene.transforms.MatrixTransform\\n\\n use(app='pyglet', gl='pyopengl2')\\n #from vispy.util.transforms import perspective, translate, rotate\\n from vispy.color import Color\\n transparent = Color(color='black', alpha=0.)\\n import colorsys\\n canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=dpi)\\n view = canvas.central_widget.add_view()\\n\\n vol_data = np.rollaxis(np.rollaxis(z, 1), 2)\\n# volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame)\\n center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2))\\n# volume.transform = center\\n# volume.cmap = 'blues'\\n\\n if draw_projections:\\n from vispy.color import Colormap\\n cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k'])\\n opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)}\\n\\n energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)#[:, ::-1]\\n fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts)\\n tr_xy = AffineTransform()\\n tr_xy.rotate(90, (0, 0, 1))\\n tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2))\\n fourier_xy.transform = tr_xy\\n\\n energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)[::-1, ::-1]\\n fourier_xt = scene.visuals.Image(energy_xt, **opts)\\n tr_xt = AffineTransform()\\n tr_xt.rotate(90, (1, 0, 0))\\n tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2))\\n fourier_xt.transform = tr_xt\\n\\n energy_yt = np.max(z, axis=0)[:, ::-1]\\n fourier_yt = scene.visuals.Image(energy_yt, **opts)\\n tr_yt = AffineTransform()\\n tr_yt.rotate(90, (0, 1, 0))\\n tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2))\\n fourier_yt.transform = tr_yt\\n\\n # Generate iso-surfaces at different energy levels\\n surfaces = []\\n for i_, (threshold, opacity) in enumerate(zip(thresholds, opacities)):\\n surfaces.append(scene.visuals.Isosurface(z, level=threshold,\\n# color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity),\\n color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity),\\n shading='smooth', parent=view.scene)\\n )\\n surfaces[-1].transform = center\\n\\n # Draw a sphere at the origin\\n axis = scene.visuals.XYZAxis(parent=view.scene)\\n for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],\\n [1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],\\n [1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):\\n line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene)\\n\\n axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene)\\n axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene)\\n axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene)\\n\\n if do_axis:\\n t = {}\\n for text in ['f_x', 'f_y', 'f_t']:\\n t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black')\\n t[text].font_size = 8\\n t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8\\n t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6\\n t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2\\n\\n cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z')\\n cam.fov = 48\\n cam.scale_factor = N_X * 1.8\\n if do_axis: margin = 1.35\\n else: margin = 1\\n cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin))\\n view.camera = cam\\n\\n render_im = canvas.render()\\n app.quit()\\n if not(filename is None):\\n import vispy.io as io\\n io.write_png(filename, render_im)\\n else:\\n return render_im\",\n \"def test_visualisations_get_visualisation(self):\\n pass\",\n \"def visualize_model(self):\\n if self.model is None:\\n print(\\\"%s.visualize: implement me\\\" % (self.__class__.__name__))\",\n \"def make_visual(self,\\r\\n ruler = None,\\r\\n options: list = ['rows',\\r\\n 'centers',\\r\\n 'distances']\\r\\n ) -> 'Image':\\r\\n \\r\\n original = self.get_picture().get_photo()\\r\\n\\r\\n # Copy the original image for drawing\\r\\n img = original.copy()\\r\\n draw = ImageDraw.Draw(img)\\r\\n\\r\\n # check all the choices provided by the user\\r\\n for i in options:\\r\\n \\r\\n if i == 'clusters':\\r\\n # Color all cluster pixels red\\r\\n \\r\\n for j in self.get_clusters():\\r\\n for k in j:\\r\\n img.putpixel(k, (25,275,25))\\r\\n\\r\\n elif i == 'row_ids':\\r\\n # Make row id numbers\\r\\n\\r\\n # Font specifications\\r\\n size = 75\\r\\n font = ImageFont.truetype('ariblk.ttf', size)\\r\\n color = (88, 214, 216)\\r\\n num = 1\\r\\n\\r\\n # Draw the ids\\r\\n for j in self.rows:\\r\\n draw.text((j[0].get_center()[0],\\r\\n j[0].get_center()[1] - 0.25 * size),\\r\\n str(num),\\r\\n fill = color,\\r\\n font = font)\\r\\n num += 1\\r\\n\\r\\n elif i == 'boxes':\\r\\n # Show all bounding boxes\\r\\n \\r\\n for i in self.get_boxes():\\r\\n draw.rectangle(i, outline=(255, 0, 255))\\r\\n\\r\\n elif i == 'dirt':\\r\\n # Remove Background\\r\\n \\r\\n img = Image.new('RGB', img.size, (130, 90, 50))\\r\\n draw = ImageDraw.Draw(img)\\r\\n\\r\\n elif i == 'centers':\\r\\n # Show all centers\\r\\n \\r\\n rad = 9\\r\\n for i in self.get_centers():\\r\\n draw.arc([(i[0] - rad, i[1] - rad),\\r\\n (i[0] + rad, i[1] + rad)],\\r\\n 0, 360, (0, 0, 255))\\r\\n\\r\\n elif i == 'ditches':\\r\\n # Show ditches between plants\\r\\n\\r\\n # Line attribute settings\\r\\n width = 10\\r\\n color = (55,65,65)\\r\\n\\r\\n # Iterate over all ditches\\r\\n for line in self.ditches:\\r\\n line = [line[0], line[1]]\\r\\n\\r\\n # Point in ditch on left border of picture\\r\\n start_point = (0, line[1])\\r\\n\\r\\n # Point in ditch on right border of picture\\r\\n end_point = (self.picture.get_size()[0] - 1,\\r\\n line[0]\\r\\n * (self.picture.get_size()[0] - 1)\\r\\n + line[1])\\r\\n\\r\\n ## Check if the end point is within the picture\\r\\n if end_point[1] < 0:\\r\\n if start_point[1] < 0:\\r\\n continue\\r\\n \\r\\n # Point in ditch on top border of picture\\r\\n end_point = (-1 * line[1] / line[0], 0)\\r\\n\\r\\n elif end_point[1] > self.picture.get_size()[1] - 1:\\r\\n if start_point[1] > self.picture.get_size()[1] - 1:\\r\\n continue\\r\\n \\r\\n # Point in ditch on bottom border of picture\\r\\n end_point = (-1\\r\\n * (self.picture.get_size()[1] - 1)\\r\\n / line[0],\\r\\n self.picture.get_size()[1] - 1)\\r\\n\\r\\n # Draw the ditches\\r\\n for i in self.get_rows():\\r\\n draw.line((start_point, end_point), color, width)\\r\\n\\r\\n elif i == 'lines':\\r\\n # Show row line approximations\\r\\n\\r\\n # Line attribute settings\\r\\n width = 1\\r\\n color = (255, 255, 75)\\r\\n\\r\\n # Iterate over all the lines\\r\\n for line in self.lines:\\r\\n line = [line[0], line[1]]\\r\\n\\r\\n # Point on line on left border of picture\\r\\n start_point = (0, line[1])\\r\\n\\r\\n # Point on line on right border of picture\\r\\n end_point = (self.picture.get_size()[0] - 1,\\r\\n line[0]\\r\\n * (self.picture.get_size()[0] - 1)\\r\\n + line[1])\\r\\n\\r\\n\\r\\n ## Check if the end point is within the picture\\r\\n if end_point[1] < 0:\\r\\n if start_point[1] < 0:\\r\\n continue\\r\\n\\r\\n # Point on line on top border of picture\\r\\n end_point = (-1 * line[1] / line[0], 0)\\r\\n \\r\\n\\r\\n elif end_point[1] > self.picture.get_size()[1] - 1:\\r\\n if start_point[1] > self.picture.get_size()[1] - 1:\\r\\n continue\\r\\n\\r\\n # Point on line on bottom border of picture\\r\\n end_point = (-1\\r\\n * (self.picture.get_size()[1] - 1)\\r\\n / line[0],\\r\\n self.picture.get_size()[1] - 1)\\r\\n\\r\\n # Draw the lines\\r\\n for i in self.get_rows():\\r\\n draw.line((start_point, end_point), color, width)\\r\\n\\r\\n elif i == 'rows':\\r\\n if self.get_rows():\\r\\n # Show lines between rows\\r\\n \\r\\n width = 3\\r\\n color = (255,0,0)\\r\\n\\r\\n for i in self.get_rows():\\r\\n draw.line([j.get_center() for j in i], color, width)\\r\\n else:\\r\\n print('Rows have not been made for this field')\\r\\n\\r\\n elif i == 'numbers':\\r\\n # Display numbers between plants\\r\\n\\r\\n # Find where to put the numbers\\r\\n midpoints = [(int(round((row[c].get_center()[0]\\r\\n + row[c + 1].get_center()[0]) / 2)),\\r\\n int(round((row[c].get_center()[1]\\r\\n + row[c + 1].get_center()[1]) / 2)))\\r\\n \\r\\n for row in self.get_rows()\\r\\n for c in range(len(row) - 1)]\\r\\n\\r\\n # Font specifications\\r\\n size = 10\\r\\n font = ImageFont.truetype('ariblk.ttf', size)\\r\\n num = 1\\r\\n\\r\\n # Write numbers\\r\\n for i in midpoints:\\r\\n draw.text((i[0] - 3 * len(str(round(num, 1))),\\r\\n i[1]),\\r\\n str(round(num,1)), font = font)\\r\\n \\r\\n num += 1\\r\\n\\r\\n elif i == 'tight':\\r\\n # Display tight boxes\\r\\n\\r\\n for i in self.get_tight_boxes():\\r\\n draw.rectangle(i, outline=(100, 255, 255))\\r\\n\\r\\n elif i == 'distances':\\r\\n # display distances between plants\\r\\n\\r\\n # find where to put the distances\\r\\n midpoints = [(int(round((row[c].get_center()[0]\\r\\n + row[c + 1].get_center()[0]) / 2)),\\r\\n int(round((row[c].get_center()[1]\\r\\n + row[c + 1].get_center()[1]) / 2)))\\r\\n for row in self.get_rows()\\r\\n for c in range(len(row) - 1)]\\r\\n\\r\\n # Font specifications\\r\\n size = 10\\r\\n font = ImageFont.truetype('arial.ttf', size)\\r\\n num = 1\\r\\n\\r\\n # Write numbers\\r\\n for i in midpoints:\\r\\n draw.text((i[0] - 3 * len(str(ruler.get_distances()[num])),\\r\\n i[1]),\\r\\n str(ruler.get_distances()[num]) + '\\\"',\\r\\n font = font)\\r\\n \\r\\n num += 1\\r\\n\\r\\n # If the user inputs something that isn't an option \\r\\n else:\\r\\n raise Exception(i + ' is not a valid option.\\\\n')\\r\\n\\r\\n return img\",\n \"def visualisation(self):\\n plt.plot(self.x, self.y, 'o', label = 'Example data')\\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\\n plt.xlim([-1,1])\\n plt.ylim([-1,1])\",\n \"def visualizeW1(images, vis_patch_side, hid_patch_side, iter, file_name=\\\"trained_\\\"):\\n\\n figure, axes = matplotlib.pyplot.subplots(nrows=hid_patch_side, ncols=hid_patch_side)\\n index = 0\\n\\n for axis in axes.flat:\\n \\\"\\\"\\\" Add row of weights as an image to the plot \\\"\\\"\\\"\\n\\n image = axis.imshow(images[index, :].reshape(vis_patch_side, vis_patch_side),\\n cmap=matplotlib.pyplot.cm.gray, interpolation='nearest')\\n axis.set_frame_on(False)\\n axis.set_axis_off()\\n index += 1\\n\\n \\\"\\\"\\\" Show the obtained plot \\\"\\\"\\\"\\n file=file_name+str(iter)+\\\".png\\\"\\n matplotlib.pyplot.savefig(file)\\n print(\\\"Written into \\\"+ file)\\n matplotlib.pyplot.close()\",\n \"def visualize(self):\\n app = QtGui.QApplication([''])\\n SceneGUI(self)\\n app.exec_()\",\n \"def plot_visual_abstract():\\n # Which generations to plot\\n GENERATIONS = [100, 230, 350]\\n\\n # LunarLander CMA-ES\\n experiment_path = glob(\\\"experiments/wann_LunarLander-v2_CMAES*\\\")\\n assert len(experiment_path) == 1, \\\"There should be only one CMA-ES experiment with LunarLander-v2\\\"\\n experiment_path = experiment_path[0]\\n\\n pivector_paths = glob(os.path.join(experiment_path, \\\"pivectors\\\", \\\"*\\\"))\\n\\n tsnes = []\\n rewards = []\\n for generation in GENERATIONS:\\n # Find pivector files for specific generation, load them and store points\\n generation_paths = [path for path in pivector_paths if \\\"gen_{}_\\\".format(generation) in path]\\n\\n population = [np.load(path) for path in generation_paths]\\n population_tsnes = np.array([x[\\\"tsne\\\"] for x in population])\\n population_rewards = np.array([x[\\\"average_episodic_reward\\\"] for x in population])\\n tsnes.append(population_tsnes)\\n rewards.append(population_rewards)\\n\\n figure, axs = pyplot.subplots(\\n figsize=[2.5 * 3, 2.5],\\n nrows=1,\\n ncols=len(GENERATIONS),\\n sharex=\\\"all\\\",\\n sharey=\\\"all\\\"\\n )\\n\\n min_reward = min(x.min() for x in rewards)\\n max_reward = max(x.max() for x in rewards)\\n scatter = None\\n\\n for idx in range(len(GENERATIONS)):\\n population_tsne = tsnes[idx]\\n population_rewards = rewards[idx]\\n generation = GENERATIONS[idx]\\n ax = axs[idx]\\n\\n scatter = ax.scatter(\\n population_tsne[:, 0],\\n population_tsne[:, 1],\\n c=population_rewards,\\n vmin=min_reward,\\n vmax=max_reward,\\n cmap=\\\"plasma\\\"\\n )\\n ax.set_title(\\\"Generation {}\\\".format(generation))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n ax.axis(\\\"off\\\")\\n\\n # Making room for colorbar\\n # Stackoverflow #13784201\\n figure.subplots_adjust(right=1.0)\\n cbar = figure.colorbar(scatter)\\n cbar.set_ticks([])\\n cbar.ax.set_ylabel(\\\"Reward $\\\\\\\\rightarrow$\\\", rotation=90, fontsize=\\\"large\\\")\\n\\n figure.tight_layout()\\n figure.savefig(\\\"figures/visual_abstract.pdf\\\", bbox_inches=\\\"tight\\\", pad_inches=0.05)\",\n \"def test_visualisations_get_visualisation_render_data(self):\\n pass\",\n \"def show_visual(self, ruler: 'Ruler') -> None:\\r\\n\\r\\n # Mainloop of the program\\r\\n show = True\\r\\n \\r\\n while show: \\r\\n imgshow = True\\r\\n imgsave = False\\r\\n\\r\\n # Get the user's choice\\r\\n choice = input(\\r\\n 'Which layer to display? (Type \\\"help\\\" for options)\\\\n'\\r\\n )\\r\\n \\r\\n print()\\r\\n \\r\\n options = parse_options(choice)\\r\\n\\r\\n # Check if the user inputted a special option\\r\\n for i in options:\\r\\n\\r\\n if i == 'quit':\\r\\n # quit\\r\\n \\r\\n show = False\\r\\n break\\r\\n\\r\\n elif i == 'help':\\r\\n # print help, and restart\\r\\n \\r\\n print('''The options are:\\r\\n default\\r\\n digital\\r\\n ----------\\r\\n boxes\\r\\n clusters\\r\\n centers\\r\\n dirt\\r\\n distances\\r\\n ditches\\r\\n lines\\r\\n numbers\\r\\n row_ids\\r\\n rows\\r\\n tight\\r\\n ----------\\r\\n save\\r\\n\\r\\n Separate multiple options with commas.\\r\\n Enter \\\"quit\\\" to exit.\\\\n''')\\r\\n \\r\\n choice = []\\r\\n break\\r\\n\\r\\n elif i == 'save':\\r\\n # Save analysed image\\r\\n \\r\\n imgsave = True\\r\\n \\r\\n \\r\\n elif i in ['boxes',\\r\\n 'clusters',\\r\\n 'centers',\\r\\n 'distances',\\r\\n 'numbers',\\r\\n 'rows',\\r\\n 'ditches',\\r\\n 'lines',\\r\\n 'tight',\\r\\n 'dirt',\\r\\n 'row_ids',\\r\\n 'default',\\r\\n 'digital']:\\r\\n \\r\\n options.append(i)\\r\\n\\r\\n else:\\r\\n print('{} is not a vaild option!\\\\n'.format(i))\\r\\n break\\r\\n \\r\\n else: \\r\\n\\r\\n # Make analysed image\\r\\n img = self.make_visual(ruler, options)\\r\\n if img is None:\\r\\n continue\\r\\n\\r\\n # Show the image if appropriate\\r\\n if imgshow:\\r\\n img.show()\\r\\n\\r\\n # Save the image if appropriate\\r\\n if imgsave:\\r\\n img.save('LastSave.png')\",\n \"def _visualize_input(self, input):\\n self.writer.add_image('input', make_grid(input[0, 0, :, :], nrow=8, normalize=True))\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')\",\n \"def visualize(self, name):\\n size = self.experiments[name]['size']\\n matrix = [[self.experiments[name]['hi-c'][0][i+size*j] \\\\\\n for i in xrange(size)] \\\\\\n for j in xrange(size)]\\n plt.imshow(log2(matrix), origin='lower')\\n plt.show()\",\n \"def show():\\n setup()\\n plt.show()\",\n \"def visualize_training(features, labels, pl):\\n print(\\\"Visualizing training\\\")\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n\\n # Take out each feature type, one at a time\\n label_map = get_label_map(labels)\\n\\n for key in label_map.keys():\\n like_ind = label_map[key]\\n like_data = np.array([features[i] for i in like_ind])\\n\\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\\n\\n # get limits\\n xmin = features.column_min(0) - .5\\n xmax = features.column_max(0) + .5\\n ymin = features.column_min(1) - .5\\n ymax = features.column_max(1) + .5\\n\\n plt.xlim(xmin,xmax)\\n plt.ylim(ymin,ymax)\\n\\n # Track the current dividing line, as well as the number of epochs passed\\n divider, = plt.plot([],[])\\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\\n\\n def update(i):\\n \\\"\\\"\\\"\\n 1.) Get the next set of weights from the tracker\\n 2.) Calculate and draw the new divider line\\n 3.) Update the epoch counter\\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\\n \\\"\\\"\\\"\\n epoch = i//features.instance_count\\n w = pl.weights_tracker[i]\\n a = pl.accuracy_tracker[epoch]\\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\\n epoch_tracker.set_text(\\\"{} {}\\\".format(epoch + 1, a))\\n\\n # Keep a shadow of the hyperplane at the end of each epoch\\n if i % features.instance_count == 0:\\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\\n\\n return divider\\n\\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\\n plt.legend()\\n\\n # optional save file\\n if len(sys.argv) >= 3 :\\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\\n\\n plt.show()\",\n \"def visualize(self):\\n self.dataFrame.hist()\\n plt.show()\",\n \"def visualise(self):\\n\\n # Initialise figure\\n params = {\\\"figure.figsize\\\": (5, 5)}\\n pylab.rcParams.update(params)\\n self.fig = plt.figure()\\n self.ax = self.fig.add_subplot(111)\\n\\n # Add particles if selected\\n print(self.crds)\\n cmap=cm.get_cmap('coolwarm')\\n norm=Normalize(0,20)\\n print(np.max(self.radii))\\n print(np.max(self.weights))\\n if self.vis_particles:\\n if self.vis_vortype==-2:\\n radii=self.weights\\n if self.param>10:\\n self.param=(self.param-10)/2+10\\n colour=cmap(norm(self.param))\\n else:\\n radii=self.radii\\n radii=self.weights\\n colour='orange'\\n colour=(0.8,0.687,0.287,1)\\n colour='gold'\\n patches = []\\n patches_pnts = []\\n patches_absent = []\\n for i,c in enumerate(self.crds):\\n patches.append(Circle(c,radius=radii[i]))\\n if radii[i]>0:\\n patches_pnts.append(Circle(c,radius=0.1))\\n else:\\n patches_absent.append(Circle(c,radius=0.1))\\n self.ax.add_collection(PatchCollection(patches, facecolor=colour, edgecolor='k', alpha=0.5))\\n self.ax.add_collection(PatchCollection(patches_pnts, facecolor='k', alpha=1,zorder=1))\\n if self.vis_vortype==2:\\n self.ax.add_collection(PatchCollection(patches_absent, facecolor='k', alpha=0.5,zorder=1))\\n else:\\n self.ax.add_collection(PatchCollection(patches_absent, facecolor='k', alpha=1,zorder=1))\\n\\n # Add voronoi\\n if self.vis_vortype!=0:\\n patches = []\\n colours = []\\n if self.vis_cellcolour==1:\\n cell_colours = self.init_cell_colours()\\n else:\\n cell_colours = [(0,0,0,0)]*100\\n for i in range(self.m):\\n patches.append(Polygon(self.rings[i],True))\\n colours.append(cell_colours[self.rings[i][:,0].size])\\n self.ax.add_collection(PatchCollection(patches, facecolor=colours, edgecolor='k', linewidth=1, zorder=0))\\n\\n # Sandbox\\n # print(np.max(self.radii))\\n # cmap=cm.get_cmap('coolwarm')\\n # norm=Normalize(0,np.max(20))\\n sandbox=False\\n if sandbox:\\n # z=16\\n # w=np.zeros_like(self.radii)\\n # mask=2*self.radii>z\\n # w[mask]=z**0.5*np.sqrt(2*self.radii[mask]-z)\\n # patches = []\\n # for i,c in enumerate(self.crds):\\n # patches.append(Circle(c,radius=w[i]))\\n # self.ax.add_collection(PatchCollection(patches, facecolor=cmap(norm(z)), edgecolor='k'))\\n with open('./phi.dat','w') as f:\\n for z in np.arange(0,np.max(self.radii)*2+0.5,0.01):\\n w=np.zeros_like(self.radii)\\n mask=2*self.radii>z\\n w[mask]=z**0.5*np.sqrt(2*self.radii[mask]-z)\\n phi=np.sum(np.pi*w**2)/52359.9\\n # phi=np.sum(np.pi*w**2)/1309\\n f.write('{:.6f} {:.6f}\\\\n'.format(z,phi))\\n\\n\\n\\n # Set axes\\n buffer = 1.6\\n lim = buffer*np.max(np.abs(self.crds))\\n self.ax.set_xlim((-lim,lim))\\n self.ax.set_ylim((-lim,lim))\\n self.ax.set_axis_off()\\n\\n # Show figure\\n if self.vis_save:\\n plt.savefig('{}_{}_{}.png'.format(self.prefix,self.frame,self.vis_vortype),dpi=400)\\n plt.show()\",\n \"def show_visuals(self, objects_in_scene, image, axe_pred):\\n image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB)\\n\\n # draw grid (slow)\\n #image = self.draw_grid(image)\\n\\n # add axe bounding box\\n #image = self.return_bbox_image(image, objects_in_scene.axes, \\\"Axe\\\", AXE_COLOR)\\n\\n # add mundo bounding box\\n #image = self.return_bbox_image(image, objects_in_scene.mundos, \\\"Mundo\\\", MUNDO_COLOR)\\n\\n # add a circle/dot at the centre of the axe bbox\\n image = self.show_centre_of_bbox(image, objects_in_scene.axes)\\n\\n # if there is a prediction made in the current frame, draw an arrow graphic to highlight\\n # where the program predicts the axe will go\\n if axe_pred:\\n image = self.draw_pred_arrows(image, axe_pred, 1)\\n\\n\\n\\n\\n # open live capture window with new shapes\\n try:\\n image = cv2.resize(image, (960, 540)) \\n cv2.imshow(\\\"visualisation\\\", image)\\n\\n if cv2.waitKey(25) & 0xFF == ord('q'):\\n cv2.destroyAllWindows()\\n exit()\\n\\n except:\\n pass\",\n \"def visualize(self):\\n import matplotlib.pyplot as plt\\n import numpy as np\\n\\n plt.figure()\\n sw_ = np.linspace(0.0, 1.0, 50)\\n plt.plot(sw_, self.krw(sw_), label=\\\"Water\\\")\\n plt.plot(sw_, self.kro(sw_), label=\\\"Oil\\\")\\n plt.xlabel(\\\"Water saturation\\\")\\n plt.ylabel(\\\"Relative permeability\\\")\\n plt.legend()\",\n \"def visualizeImg(img):\\n plt.figure(figsize=(10,4))\\n plt.imshow(img)\\n plt.show()\",\n \"def visualize(self, path=None, names=True, details=True):\\n return visualization.visualize(self, path, names=names, details=details)\",\n \"def create_img(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled, IMG_OUTPUT_FILEPATH):\\n viz = Visualizer(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled=upsampled)\\n viz.evaluate()\\n if upsampled == True:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '_upsampled.png'\\n else:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '.png'\\n viz.visualizer.show(outpath=outpath_, clear_figure=True)\",\n \"def visualize(model, # type: thelper.typedefs.ModelType\\n task, # type: thelper.typedefs.TaskType\\n loader, # type: thelper.typedefs.LoaderType\\n viz_type, # type: AnyStr\\n **kwargs\\n ): # type: (...) -> Any\\n assert viz_type in supported_types, f\\\"unsupported visualization type '{viz_type}'\\\"\\n if viz_type == \\\"tsne\\\":\\n return thelper.viz.tsne.visualize(model, task, loader, **kwargs)\\n elif viz_type == \\\"umap\\\":\\n return thelper.viz.umap.visualize(model, task, loader, **kwargs)\",\n \"def visualize(self):\\n # activity_threshold the level at which we can ignore\\n # an element's activity in order to simplify display.\\n activity_threshold = .01\\n print(self.name)\\n\\n print(\\\"Input activities\\\")\\n for i_input, activity in enumerate(self.input_activities):\\n if activity > activity_threshold:\\n print(\\\" \\\".join([\\\"input\\\", str(i_input), \\\":\\\",\\n \\\"activity \\\", str(activity)]))\\n # TODO visualize feature activities\\n\\n self.ziptie.visualize()\",\n \"def _visualize(self, labels, ticks, overlay, draw, annotate, height=4):\\n n = len(labels)\\n colors = list(itertools.islice(itertools.cycle(('b', 'y', 'g', 'r')), n))\\n if overlay:\\n _, axis = plt.subplots(figsize=(6, height))\\n for label, color in zip(labels, colors):\\n draw(axis, label, color)\\n if ticks is not None:\\n annotate(axis, ticks)\\n axis.legend(labels, bbox_to_anchor=(1.5, 1.0))\\n else:\\n _, axes = plt.subplots(n, 1, figsize=(6, height * n))\\n if not isinstance(axes, collections.Iterable):\\n axes=[axes]\\n for axis, label, color in zip(axes, labels, colors):\\n draw(axis, label, color)\\n axis.set_xlabel(label, fontsize=16)\\n if ticks is not None:\\n annotate(axis, ticks)\",\n \"def visualize(vis, features, label):\\n if vis == 'PCA':\\n #n_components = st.sidebar.slider(\\\"n_components\\\", 2, 10)\\n #alpha = st.sidebar.slider(\\\"alpha\\\", 0.8, 2.0)\\n #pca = PCA(n_components)\\n pca = PCA(2)\\n\\n X_projected = pca.fit_transform(features)\\n \\n x1 = X_projected[:, 0]\\n x2 = X_projected[:, 1]\\n\\n\\n fig = plt.figure()\\n plt.scatter(x1, x2, c=label, alpha=0.8, cmap='viridis')\\n plt.xlabel(\\\"Principal Component 1\\\")\\n plt.ylabel(\\\"Principal Component 2\\\")\\n plt.colorbar()\\n\\n st.pyplot()\",\n \"def _repr_html_(self):\\n\\n import numpy as np\\n import matplotlib.pyplot as plt\\n from .._tier9 import imshow\\n\\n\\n size_in_pixels = np.prod(self.shape)\\n size_in_bytes = size_in_pixels * self.dtype.itemsize\\n\\n labels = (self.dtype == np.uint32)\\n\\n # In case the image is 2D, 3D and larger than 100 pixels, turn on fancy view\\n if len(self.shape) in (2, 3) and size_in_pixels >= 100:\\n import matplotlib.pyplot as plt\\n imshow(self,\\n labels=labels,\\n continue_drawing=True,\\n colorbar=not labels)\\n image = self._png_to_html(self._plt_to_png())\\n else:\\n return \\\"<pre>cle.array(\\\" + str(np.asarray(self)) + \\\", dtype=\\\" + str(self.dtype) + \\\")</pre>\\\"\\n\\n\\n if size_in_bytes > 1024:\\n size_in_bytes = size_in_bytes / 1024\\n if size_in_bytes > 1024:\\n size_in_bytes = size_in_bytes / 1024\\n if size_in_bytes > 1024:\\n size_in_bytes = size_in_bytes / 1024\\n size = \\\"{:.1f}\\\".format(size_in_bytes) + \\\" GB\\\"\\n else:\\n size = \\\"{:.1f}\\\".format(size_in_bytes) + \\\" MB\\\"\\n else:\\n size = \\\"{:.1f}\\\".format(size_in_bytes) + \\\" kB\\\"\\n else:\\n size = \\\"{:.1f}\\\".format(size_in_bytes) + \\\" B\\\"\\n\\n histogram = \\\"\\\"\\n\\n if size_in_bytes < 100 * 1024 * 1024:\\n if not labels:\\n\\n import numpy as np\\n from .._tier2 import minimum_of_all_pixels, maximum_of_all_pixels\\n from .._tier3 import histogram\\n\\n num_bins = 32\\n\\n h = np.asarray(histogram(self, num_bins=num_bins))\\n\\n plt.figure(figsize=(1.8, 1.2))\\n plt.bar(range(0, len(h)), h)\\n\\n # hide axis text\\n # https://stackoverflow.com/questions/2176424/hiding-axis-text-in-matplotlib-plots\\n # https://pythonguides.com/matplotlib-remove-tick-labels\\n frame1 = plt.gca()\\n frame1.axes.xaxis.set_ticklabels([])\\n frame1.axes.yaxis.set_ticklabels([])\\n plt.tick_params(left=False, bottom=False)\\n\\n histogram = self._png_to_html(self._plt_to_png())\\n\\n min_max = \\\"<tr><td>min</td><td>\\\" + str(self.min()) + \\\"</td></tr>\\\" + \\\\\\n \\\"<tr><td>max</td><td>\\\" + str(self.max()) + \\\"</td></tr>\\\"\\n\\n else:\\n\\n min_max = \\\"\\\"\\n\\n all = [\\n \\\"<table>\\\",\\n \\\"<tr>\\\",\\n \\\"<td>\\\",\\n image,\\n \\\"</td>\\\",\\n \\\"<td style=\\\\\\\"text-align: center; vertical-align: top;\\\\\\\">\\\",\\n \\\"<b><a href=\\\\\\\"https://github.com/clEsperanto/pyclesperanto_prototype\\\\\\\" target=\\\\\\\"_blank\\\\\\\">cle._</a> image</b><br/>\\\",\\n \\\"<table>\\\",\\n \\\"<tr><td>shape</td><td>\\\" + str(self.shape).replace(\\\" \\\", \\\" \\\") + \\\"</td></tr>\\\",\\n \\\"<tr><td>dtype</td><td>\\\" + str(self.dtype) + \\\"</td></tr>\\\",\\n \\\"<tr><td>size</td><td>\\\" + size + \\\"</td></tr>\\\",\\n min_max,\\n \\\"</table>\\\",\\n histogram,\\n \\\"</td>\\\",\\n \\\"</tr>\\\",\\n \\\"</table>\\\",\\n ]\\n\\n return \\\"\\\\n\\\".join(all)\",\n \"def learning_viz(self) :\\n self.train\\n history = self.history\\n plot_loss(history)\",\n \"def visualize(self, file_name=None, simple=False):\\r\\n\\r\\n # Instantiate figure and axes objects\\r\\n fig, ax = plt.subplots()\\r\\n\\r\\n # Plot the upper and bottom boundaries\\r\\n ax.plot(self.x_vector, self.y_vector_top,\\r\\n label='Top', color='r', lw=3)\\r\\n\\r\\n ax.plot(self.x_vector, self.y_vector_top_reverse,\\r\\n label='Top - Reverse', color='r', lw=3)\\r\\n\\r\\n # Plot vertical lines at the begining & end of the domain\\r\\n plt.vlines(x=self.x_min,\\r\\n ymin=self.y_vector_top_reverse[0], ymax=self.y_vector_top[0],\\r\\n color='r', lw=3)\\r\\n plt.vlines(x=self.x_max,\\r\\n ymin=self.y_vector_top_reverse[-1], ymax=self.y_vector_top[-1],\\r\\n color='r', lw=3)\\r\\n\\r\\n if simple:\\r\\n # Plot the upper and bottom boundaries\\r\\n ax.plot(self.x_vector, self.y_vector_bottom,\\r\\n label='Top', color='r', lw=3)\\r\\n\\r\\n ax.plot(self.x_vector, self.y_vector_bottom_reverse,\\r\\n label='Top - Reverse', color='r', lw=3)\\r\\n else:\\r\\n # Color in the space surrounding the geometry\\r\\n ax.fill_between(self.x_vector,\\r\\n self.y_vector_top_reverse, self.y_vector_bottom_reverse,\\r\\n facecolor='black')\\r\\n ax.fill_between(self.x_vector, self.y_vector_top, self.y_vector_bottom,\\r\\n facecolor='black')\\r\\n\\r\\n # Turn off axes\\r\\n plt.axis('off')\\r\\n\\r\\n # Save figure to file\\r\\n file_name = file_name or 'geometry.png'\\r\\n plt.savefig(file_name, bbox_inches='tight', pad_inches=0)\\r\\n\\r\\n return\",\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 show2(self):\\n #zfactor = 4\\n xb, yb = self.bary.T\\n sol0 = self.dat[0]['sol'][:,0]\\n triangles = self.tri_pnts_b\\n import mayavi.mlab as mlab\\n fig = mlab.figure(bgcolor = (0.1, 0.1, 0.1),\\n size = (1280, 800))\\n @mlab.animate()\\n def showdat():\\n \\\"\\\"\\\"Example from:\\n http://github.enthought.com/mayavi/mayavi/tips.html#animating-a-visualization\\n \\\"\\\"\\\"\\n # triangular_mesh see:\\n # http://github.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html?highlight=triangular_mesh#mayavi.mlab.triangular_mesh\\n img = mlab.triangular_mesh(xb, yb, sol0, triangles, scalars=sol0)\\n #fig = mlab.gcf()\\n ms = img.mlab_source\\n for t, s in self.dat:\\n # see: http://github.enthought.com/mayavi/mayavi/mlab_animating.html?highlight=animating\\n ms.set(scalars=s[:,0])\\n yield\\n a = showdat()\",\n \"def showEntireDataset(wl_listG, wl_listV, tsvd_graphlet_vectors, kpca_graphlet_gram, tsvd_shortestpath_vectors,\\n kpca_shortestpath_gram, classes):\\n for i in range(1, 8):\\n if (i == 6):\\n data_tsvd = tsvd_graphlet_vectors\\n data_kpca = kpca_graphlet_gram\\n elif (i == 7):\\n data_tsvd = tsvd_shortestpath_vectors\\n data_kpca = kpca_shortestpath_gram\\n else:\\n data_tsvd = wl_listV[i - 1]\\n data_kpca = wl_listG[i - 1]\\n fig = plt.figure(figsize=(15, 15))\\n if (i == 6):\\n fig.suptitle('Graphlet', fontsize=25)\\n elif (i == 7):\\n fig.suptitle('Shortest Path', fontsize=25)\\n else:\\n fig.suptitle(f'Weisfeiler-Lehman {i}', fontsize=25)\\n ax1 = fig.add_subplot(221)\\n ax2 = fig.add_subplot(222)\\n ax3 = fig.add_subplot(223, projection='3d')\\n ax4 = fig.add_subplot(224, projection='3d')\\n ax1.title.set_text('2D TruncatedSVD')\\n ax2.title.set_text('2D KernelPCA')\\n ax3.title.set_text('3D TruncatedSVD')\\n ax4.title.set_text('3D KernelPCA')\\n ax1.scatter(data_tsvd[:, 0], data_tsvd[:, 1], c=classes)\\n ax2.scatter(data_kpca[:, 0], data_kpca[:, 1], c=classes)\\n ax3.scatter3D(data_tsvd[:, 0], data_tsvd[:, 1], data_tsvd[:, 2], c=classes)\\n ax4.scatter3D(data_kpca[:, 0], data_kpca[:, 1], data_kpca[:, 2], c=classes)\\n plt.show()\\n print(\\\"________________________________________________________________________________________\\\")\\n print()\",\n \"def generate(self, diagram):\",\n \"def _show(self, a):\\n fig = plt.figure()\\n fig.set_size_inches((2, 2))\\n ax = plt.Axes(fig, [0., 0., 1., 1.])\\n ax.set_axis_off()\\n fig.add_axes(ax)\\n plt.set_cmap('hot')\\n ax.imshow(a, aspect='equal')\\n plt.show()\",\n \"def show(self):\\n \\n \\n \\n \\n \\n \\n r = 4\\n f, axarr = plt.subplots(r, r, figsize=(8,8))\\n counter = 0\\n for i in range(r):\\n for j in range(r):\\n temp = self.x[counter,:]\\n counter += 1\\n img = self.x[counter,:]\\n axarr[i][j].imshow(img)\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\",\n \"def viz_pipeline(self, img):\\n y_fit, x_fit_left, x_fit_right = self.find_lines(img, ['all'])\\n dynamic_subplot = DynamicSubplot(3, 4)\\n dynamic_subplot.imshow(self.visuals['dash_undistorted'], \\\"Undistorted Road\\\")\\n dynamic_subplot.imshow(self.visuals['overhead'], \\\"Overhead\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['lightness'], \\\"Lightness\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['lightness_binary'], \\\"Binary Lightness\\\", cmap='gray')\\n dynamic_subplot.skip_plot()\\n dynamic_subplot.skip_plot()\\n dynamic_subplot.imshow(self.visuals['value'], \\\"Value\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['value_binary'], \\\"Binary Value\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['pixel_scores'], \\\"Scores\\\", cmap='gray')\\n dynamic_subplot.imshow(self.visuals['windows_raw'], \\\"Selected Windows\\\")\\n dynamic_subplot.imshow(self.visuals['windows_raw'], \\\"Fitted Lines\\\", cmap='gray')\\n dynamic_subplot.modify_plot('plot', x_fit_left, y_fit)\\n dynamic_subplot.modify_plot('plot', x_fit_right, y_fit)\\n dynamic_subplot.modify_plot('set_xlim', 0, camera.img_width)\\n dynamic_subplot.modify_plot('set_ylim', camera.img_height, 0)\\n dynamic_subplot.imshow(self.visuals['highlighted_lane'], \\\"Highlighted Lane\\\")\",\n \"def visualization_one(target_var = None, input_vars= None, output_image_name=None):\\n ###\\n # Main chunk of code here\\n ###\\n\\n # Starter code for labeling the image\\n plt.xlabel(None, figure = fig)\\n plt.ylabel(None, figure = fig)\\n plt.title(None, figure= fig)\\n plt.legend()\\n\\n # exporting the image to the img folder\\n plt.savefig(f'img/{output_image_name}.png', transparent = True, figure = fig)\\n return fig\",\n \"def show_visualizations(self, number = -1):\\n instance = self.instance\\n if number > instance.view_num:\\n print(\\\"In function show_visualizations: Error, input number greater than the view numbers.\\\")\\n return Page()\\n if self.rank_method == methods_of_ranking[3]: # diversified_ranking\\n G = myGraph(instance.view_num)\\n for i in range(instance.view_num):\\n view = instance.tables[instance.views[i].table_pos].views[instance.views[i].view_pos]\\n G.addNode(view)\\n G.getSim()\\n result = G.getTopK(instance.view_num)\\n if number != -1:\\n begin = number - 1\\n end = number\\n else:\\n begin = 0\\n end = instance.view_num\\n page = Page()\\n for order in range(begin, end):\\n if self.rank_method == methods_of_ranking[3]: # diversified_ranking\\n view = G.nodes[result[order]]\\n else:\\n view = instance.tables[instance.views[order].table_pos].views[instance.views[order].view_pos]\\n data = {}\\n data['order'] = order\\n data['chartname'] = instance.table_name\\n data['describe'] = view.table.describe\\n data['x_name'] = view.fx.name\\n data['y_name'] = view.fy.name\\n data['chart'] = Chart.chart[view.chart]\\n data['classify'] = [v[0] for v in view.table.classes]\\n data['x_data'] = view.X\\n data['y_data'] = view.Y\\n data['title_top'] = 5\\n \\n # 以下代码与html_handle相似\\n margin = str(data['title_top']) + '%'\\n \\n if data['chart'] == 'bar':\\n chart = (Bar().set_series_opts(label_opts=opts.LabelOpts(is_show=False))\\n .set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin),\\n xaxis_opts=opts.AxisOpts(name=data['x_name']),\\n yaxis_opts=opts.AxisOpts(name=data['y_name'], splitline_opts=opts.SplitLineOpts(is_show=True))))\\n elif data['chart'] == 'pie': \\n chart = (Pie().set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin)))\\n elif data['chart'] == 'line': \\n chart = (Line().set_series_opts(label_opts=opts.LabelOpts(is_show=False))\\n .set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin),\\n xaxis_opts=opts.AxisOpts(name=data['x_name']),\\n yaxis_opts=opts.AxisOpts(name=data['y_name'], splitline_opts=opts.SplitLineOpts(is_show=True))))\\n elif data['chart']== 'scatter': \\n chart = (Scatter().set_series_opts(label_opts=opts.LabelOpts(is_show=False))\\n .set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin),\\n xaxis_opts=opts.AxisOpts(type_='value', name=data['x_name'], splitline_opts=opts.SplitLineOpts(is_show=True)),\\n yaxis_opts=opts.AxisOpts(type_='value', name=data['y_name'], splitline_opts=opts.SplitLineOpts(is_show=True))))\\n else :\\n print (\\\"not valid chart\\\")\\n \\n if not data[\\\"classify\\\"] :\\n attr = data[\\\"x_data\\\"][0]\\n val = data[\\\"y_data\\\"][0]\\n if data['chart'] == 'bar': \\n chart.add_xaxis(attr).add_yaxis(\\\"\\\", val, label_opts=opts.LabelOpts(is_show=False))\\n elif data['chart'] == 'line': \\n chart.add_xaxis(attr).add_yaxis(\\\"\\\", val, label_opts=opts.LabelOpts(is_show=False))\\n elif data['chart'] == 'pie': \\n chart.add(\\\"\\\", [list(z) for z in zip(attr, val)])\\n elif data['chart'] == 'scatter': \\n if isinstance(attr[0], str):\\n attr = [x for x in attr if x != '']\\n attr = list(map(float, attr))\\n if isinstance(val[0], str):\\n val = [x for x in val if x != '']\\n val = list(map(float, val))\\n chart.add_xaxis(attr).add_yaxis(\\\"\\\", val, label_opts=opts.LabelOpts(is_show=False))\\n page.add(chart)\\n else :\\n attr = data[\\\"x_data\\\"][0]\\n for i in range(len(data[\\\"classify\\\"])) :\\n val = data[\\\"y_data\\\"][i]\\n name = (data[\\\"classify\\\"][i][0] if type(data[\\\"classify\\\"][i]) == type(('a','b')) else data[\\\"classify\\\"][i])\\n if i == 0:\\n if data['chart'] != 'pie' and data['chart'] != 'scatter':\\n chart.add_xaxis(attr)\\n if data['chart'] == 'bar': \\n chart.add_yaxis(name, val, stack=\\\"stack1\\\", label_opts=opts.LabelOpts(is_show=False))\\n elif data['chart'] == 'line': \\n chart.add_yaxis(name, val, label_opts=opts.LabelOpts(is_show=False))\\n elif data['chart'] == 'pie': \\n chart.add(\\\"\\\", [list(z) for z in zip(attr, val)])\\n elif data['chart'] == 'scatter': \\n attr_scatter = data[\\\"x_data\\\"][i]\\n if isinstance(attr_scatter[0], str):\\n attr_scatter = [x for x in attr_scatter if x != '']\\n attr_scatter = list(map(float, attr_scatter))\\n if isinstance(val[0], str):\\n val = [x for x in val if x != '']\\n val = list(map(float, val))\\n chart.add_xaxis(attr_scatter).add_yaxis(name, val, label_opts=opts.LabelOpts(is_show=False))\\n page.add(chart)\\n return page\",\n \"def visualize_dataset_example(dataset: tf.data.Dataset,\\n index_to_category: tf.lookup.StaticHashTable) -> None:\\n # Getting anchor shapes for latter use\\n anchor_shapes = tf.convert_to_tensor(utils.ANCHORS_SHAPE)\\n # Gets one observation from dataset\\n iterator = iter(dataset)\\n image, path, output = next(iterator)\\n # Creates figure/axes\\n fig, axes = plt.subplots(1, 2)\\n fig.set_tight_layout(tight=0.1)\\n fig.suptitle(path.numpy().decode('utf-8'))\\n cmap = cm.get_cmap('hsv', 80)\\n # Parses image dimensions\\n image_height, image_width, image_depth = image.shape\\n # Parses info from sparse outputs\\n steps = list(range(0, output.values.shape[0], 6))\\n bboxes = [\\n denormalize_bbox_to_image_size(\\n yolo.decode_from_yolo_format(\\n output.values[i + 1: i + 5],\\n output.indices[i][:2]\\n ).numpy(),\\n image_width,\\n image_height\\n ) for i in steps\\n ]\\n labels = [(tf.cast(output.indices[i + 5][2], dtype=tf.int32) - tf.cast(5 * tf.shape(anchor_shapes)[0],\\n dtype=tf.int32)).numpy() for i in steps]\\n objectnesses = [output.values[i].numpy() for i in steps]\\n objects = [Object(*entry) for entry in zip(bboxes, labels, objectnesses)]\\n # Plots all objects\\n axes[0].imshow(image.numpy())\\n for obj in objects:\\n add_object_to_axes(axes[0], obj, index_to_category, cmap)\\n # Randomly selects one bounding box and plots its relationship with anchor boxes\\n cells = [output.indices[i][:2].numpy() for i in steps]\\n anchors = [tf.math.floordiv(output.indices[i + 1][2], 5).numpy() for i in steps]\\n selected = random.randint(0, len(cells) - 1)\\n # Plots image on the second axes as well\\n axes[1].imshow(image.numpy())\\n # Adding corresponding grid cell center\\n add_cell_center_to_axes(\\n axes[1],\\n denormalize_cell_to_image_size(\\n cells[selected], image_width, image_height\\n )\\n )\\n # Adding anchor boxes at the corresponding grid cell\\n for index, anchor in enumerate(utils.ANCHORS_SHAPE):\\n add_anchor_to_axes(\\n axes[1],\\n denormalize_bbox_to_image_size(\\n convert_anchor_to_bbox(anchor, cells[selected]),\\n image_width,\\n image_height\\n ),\\n color='white' if index == anchors[selected] else 'grey',\\n )\\n # Adding bounding box of selected object\\n add_object_without_description_to_axes(axes[1], objects[selected], cmap)\\n # Adding bounding box center\\n add_object_center_to_axes(axes[1], objects[selected], cmap)\\n # Adding grid cell to image\\n add_grid_to_axes(axes[1], image_width, image_height)\\n # Let the magic show!\\n axes[0].axis('off')\\n axes[1].axis('off')\\n axes[1].set_xlim(axes[0].get_xlim())\\n axes[1].set_ylim(axes[0].get_ylim())\\n plt.show()\",\n \"def save_dataset_visual(lines, output_dir):\\n\\n # Ensure output directory exists\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n cols = 3\\n rows = 3\\n fig_size = (7 * cols, 4 * rows) # Figure width and height, in inches\\n # Random sample of images\\n save_name = \\\"training_data_sample.png\\\"\\n fig, ax = plt.subplots(rows, cols, figsize=fig_size)\\n for row in range(rows):\\n for col in range(cols):\\n idx = np.random.randint(0, len(lines))\\n ax[row, col].imshow(ndimage.imread(lines[idx][0]))\\n ax[row, col].set_title(\\\"Angle = \\\" + str(round(lines[idx][1], 3)))\\n plt.savefig(output_dir + save_name, bbox_inches='tight')\\n # Distribution of steering angles\\n save_name = \\\"data_histogram.png\\\"\\n fig_size = (5, 3) # Figure width and height, in inches\\n num_bins = 100\\n angles = np.array([line[1] for line in lines])\\n hist, bins = np.histogram(angles, bins=num_bins)\\n fig = plt.figure(figsize=fig_size)\\n plt.bar(bins[:-1], hist)\\n plt.xlabel(\\\"Steering Angle\\\")\\n plt.ylabel(\\\"Frequency\\\")\\n plt.title(\\\"Distribution of Steering Angles in Training Data\\\")\\n plt.savefig(output_dir + save_name, bbox_inches='tight')\",\n \"def visualize(\\n samples, predictions, pred_poses, im_ind, crop_size, output_scale,\\n model_store, renderer, vis_dir):\\n tf.logging.info('Visualization for: {}'.format(\\n samples[common.IMAGE_PATH][0].decode('utf8')))\\n\\n # Size of a visualization grid tile.\\n tile_size = (300, 225)\\n\\n # Extension of the saved visualizations ('jpg', 'png', etc.).\\n vis_ext = 'jpg'\\n\\n # Font settings.\\n font_size = 10\\n font_color = (0.8, 0.8, 0.8)\\n\\n # Intrinsics.\\n K = samples[common.K][0]\\n output_K = K * output_scale\\n output_K[2, 2] = 1.0\\n\\n # Tiles for the grid visualization.\\n tiles = []\\n\\n # Size of the output fields.\\n output_size =\\\\\\n int(output_scale * crop_size[0]), int(output_scale * crop_size[1])\\n\\n # Prefix of the visualization names.\\n vis_prefix = '{:06d}'.format(im_ind)\\n\\n # Input RGB image.\\n rgb = np.squeeze(samples[common.IMAGE][0])\\n vis_rgb = visualization.write_text_on_image(\\n misc.resize_image_py(rgb, tile_size).astype(np.uint8),\\n [{'name': '', 'val': 'input', 'fmt': ':s'}],\\n size=font_size, color=font_color)\\n tiles.append(vis_rgb)\\n\\n # Visualize the ground-truth poses.\\n if FLAGS.vis_gt_poses:\\n\\n gt_poses = []\\n for gt_id, obj_id in enumerate(samples[common.GT_OBJ_IDS][0]):\\n q = samples[common.GT_OBJ_QUATS][0][gt_id]\\n R = transform.quaternion_matrix(q)[:3, :3]\\n t = samples[common.GT_OBJ_TRANS][0][gt_id].reshape((3, 1))\\n gt_poses.append({'obj_id': obj_id, 'R': R, 't': t})\\n\\n vis_gt_poses = vis.visualize_object_poses(rgb, K, gt_poses, renderer)\\n vis_gt_poses = visualization.write_text_on_image(\\n misc.resize_image_py(vis_gt_poses, tile_size),\\n [{'name': '', 'val': 'gt poses', 'fmt': ':s'}],\\n size=font_size, color=font_color)\\n tiles.append(vis_gt_poses)\\n\\n # Visualize the estimated poses.\\n if FLAGS.vis_pred_poses:\\n vis_pred_poses = vis.visualize_object_poses(rgb, K, pred_poses, renderer)\\n vis_pred_poses = visualization.write_text_on_image(\\n misc.resize_image_py(vis_pred_poses, tile_size),\\n [{'name': '', 'val': 'pred poses', 'fmt': ':s'}],\\n size=font_size, color=font_color)\\n tiles.append(vis_pred_poses)\\n\\n # Ground-truth object labels.\\n if FLAGS.vis_gt_obj_labels and common.GT_OBJ_LABEL in samples:\\n obj_labels = np.squeeze(samples[common.GT_OBJ_LABEL][0])\\n obj_labels = obj_labels[:crop_size[1], :crop_size[0]]\\n obj_labels = vis.colorize_label_map(obj_labels)\\n obj_labels = visualization.write_text_on_image(\\n misc.resize_image_py(obj_labels.astype(np.uint8), tile_size),\\n [{'name': '', 'val': 'gt obj labels', 'fmt': ':s'}],\\n size=font_size, color=font_color)\\n tiles.append(obj_labels)\\n\\n # Predicted object labels.\\n if FLAGS.vis_pred_obj_labels:\\n obj_labels = np.squeeze(predictions[common.PRED_OBJ_LABEL][0])\\n obj_labels = obj_labels[:crop_size[1], :crop_size[0]]\\n obj_labels = vis.colorize_label_map(obj_labels)\\n obj_labels = visualization.write_text_on_image(\\n misc.resize_image_py(obj_labels.astype(np.uint8), tile_size),\\n [{'name': '', 'val': 'predicted obj labels', 'fmt': ':s'}],\\n size=font_size, color=font_color)\\n tiles.append(obj_labels)\\n\\n # Predicted object confidences.\\n if FLAGS.vis_pred_obj_confs:\\n num_obj_labels = predictions[common.PRED_OBJ_CONF].shape[-1]\\n for obj_label in range(num_obj_labels):\\n obj_confs = misc.resize_image_py(np.array(\\n predictions[common.PRED_OBJ_CONF][0, :, :, obj_label]), tile_size)\\n obj_confs = (255.0 * obj_confs).astype(np.uint8)\\n obj_confs = np.dstack([obj_confs, obj_confs, obj_confs]) # To RGB.\\n obj_confs = visualization.write_text_on_image(\\n obj_confs, [{'name': 'cls', 'val': obj_label, 'fmt': ':d'}],\\n size=font_size, color=font_color)\\n tiles.append(obj_confs)\\n\\n # Visualization of ground-truth fragment fields.\\n if FLAGS.vis_gt_frag_fields and common.GT_OBJ_IDS in samples:\\n vis.visualize_gt_frag(\\n gt_obj_ids=samples[common.GT_OBJ_IDS][0],\\n gt_obj_masks=samples[common.GT_OBJ_MASKS][0],\\n gt_frag_labels=samples[common.GT_FRAG_LABEL][0],\\n gt_frag_weights=samples[common.GT_FRAG_WEIGHT][0],\\n gt_frag_coords=samples[common.GT_FRAG_LOC][0],\\n output_size=output_size,\\n model_store=model_store,\\n vis_prefix=vis_prefix,\\n vis_dir=vis_dir)\\n\\n # Visualization of predicted fragment fields.\\n if FLAGS.vis_pred_frag_fields:\\n vis.visualize_pred_frag(\\n frag_confs=predictions[common.PRED_FRAG_CONF][0],\\n frag_coords=predictions[common.PRED_FRAG_LOC][0],\\n output_size=output_size,\\n model_store=model_store,\\n vis_prefix=vis_prefix,\\n vis_dir=vis_dir,\\n vis_ext=vis_ext)\\n\\n # Build and save a visualization grid.\\n grid = vis.build_grid(tiles, tile_size)\\n grid_vis_path = os.path.join(\\n vis_dir, '{}_grid.{}'.format(vis_prefix, vis_ext))\\n inout.save_im(grid_vis_path, grid)\",\n \"def show_custom_graph(self):\\n pass\",\n \"def visualize(self, method='nltk'):\\n if method == 'nltk':\\n self._visualize_nltk()\\n else:\\n raise ValueError(\\\"Unknown visualization method: %r\\\" % method)\",\n \"def visualize(base_path, test_dataset, plot_dir, batch_size=4, ):\\n device = torch.device('cuda')\\n dataset = HeadDataset(test_dataset,\\n base_path,\\n dataset_param={},\\n train=False)\\n batch_iterator = iter(data.DataLoader(dataset, batch_size,\\n shuffle=False,\\n num_workers=4,\\n collate_fn=coco_collate))\\n for ind, (images, targets) in enumerate(tqdm(batch_iterator)):\\n images = list(img.to(device) for img in images)\\n np_images = [(ims.cpu().numpy()*255.).astype(np.uint8) for ims in images]\\n gt_boxes = [gt['boxes'].numpy().astype(np.float64) for gt in targets]\\n for np_im, gt_box in zip(np_images, gt_boxes):\\n plot_images = plot_ims(np_im, [], gt_box)\\n imsave(osp.join(plot_dir, str(ind) + '.jpg'), plot_images)\",\n \"def __init__(self, calcGrad, calcCost, input, alpha = 0.01):\\n \\n\\tVisualizer.__init__(self, calcGrad, calcCost, input)\\n\\n\\tself.alpha = alpha\",\n \"def visualizer(FRAME_STATS, save_image=True, image_dir='images'):\\r\\n frame = FRAME_STATS['frame'].copy()\\r\\n frame_number = FRAME_STATS['frame_number']\\r\\n paths = FRAME_STATS['paths']\\r\\n exit_masks = FRAME_STATS['exit_masks']\\r\\n vehicle_count = FRAME_STATS['vehicle_count']\\r\\n capacity = FRAME_STATS['capacity']\\r\\n\\r\\n frame = draw_ui(frame, vehicle_count, capacity, exit_masks)\\r\\n frame = draw_boxes(frame, paths, exit_masks)\\r\\n \\r\\n if save_image: cv2.imwrite(image_dir + \\\"/processed_%04d.png\\\" % frame_number, np.flip(frame,2))\",\n \"def draw(self):\\n options = dict(vmax = 5)\\n self.init_fig(**options)\\n self.im.set_data(self.array)\\n return self.fig\",\n \"def visualize(**images):\\n n_images = len(images)\\n plt.figure(figsize=(20,8))\\n for idx, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n_images, idx + 1)\\n plt.xticks([]); \\n plt.yticks([])\\n # get title from the parameter names\\n plt.title(name.replace('_',' ').title(), fontsize=20)\\n plt.imshow(image)\\n plt.savefig('sample_gt_pred_2_max.jpeg')\\n plt.show()\",\n \"def visualize(self, reduced_data):\\n\\t\\t# Step size of the mesh. Decrease to increase the quality of the VQ.\\n\\t\\th = .02 # point in the mesh [x_min, m_max]x[y_min, y_max].\\n\\t\\t\\n\\t\\t# Plot the decision boundary. For that, we will assign a color to each\\n\\t\\tx_min, x_max = reduced_data[:, 0].min() + 1, reduced_data[:, 0].max() - 1\\n\\t\\ty_min, y_max = reduced_data[:, 1].min() + 1, reduced_data[:, 1].max() - 1\\n\\t\\txx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\\n\\n\\t\\t# Obtain labels for each point in mesh. Use last trained model.\\n\\t\\tZ = self.estimator.predict(np.c_[xx.ravel(), yy.ravel()])\\n\\n\\t\\t# Put the result into a color plot\\n\\t\\tZ = Z.reshape(xx.shape)\\n\\t\\t\\n\\t\\tplt.figure(1)\\n\\t\\tplt.clf()\\n\\t\\tplt.imshow(Z, interpolation='nearest',\\n\\t\\t extent=(xx.min(), xx.max(), yy.min(), yy.max()),\\n\\t\\t cmap=plt.cm.Paired,\\n\\t\\t aspect='auto', origin='lower')\\n\\n\\t\\tplt.plot(reduced_data[:, 0], reduced_data[:, 1], 'k.', markersize=4)\\n\\t\\t# Plot the centroids as a white X\\n\\t\\tcentroids = self.estimator.cluster_centers_\\n\\t\\tplt.scatter(centroids[:, 0], centroids[:, 1],\\n\\t\\t marker='x', s=169, linewidths=3,\\n\\t\\t color='w', zorder=10)\\n\\t\\tplt.title('K-means clustering with random data (PCA-reduced data)\\\\n'\\n\\t\\t 'Centroids are marked with white cross')\\n\\t\\tplt.xlim(x_min, x_max)\\n\\t\\tplt.ylim(y_min, y_max)\\n\\t\\tplt.xticks(())\\n\\t\\tplt.yticks(())\\n\\t\\tplt.show()\",\n \"def visualize(self):\\n\\n check_is_fitted(self, \\\"sm_\\\")\\n\\n fig = plt.figure(figsize=(6, 4))\\n inner = gridspec.GridSpec(2, 1, hspace=0.1, height_ratios=[6, 1])\\n ax1_main = plt.Subplot(fig, inner[0]) \\n xgrid = np.linspace(self.xmin, self.xmax, 100).reshape([-1, 1])\\n ygrid = self.decision_function(xgrid)\\n ax1_main.plot(xgrid, ygrid)\\n ax1_main.set_xticklabels([])\\n ax1_main.set_title(\\\"Shape Function\\\", fontsize=12)\\n fig.add_subplot(ax1_main)\\n \\n ax1_density = plt.Subplot(fig, inner[1]) \\n xint = ((np.array(self.bins_[1:]) + np.array(self.bins_[:-1])) / 2).reshape([-1, 1]).reshape([-1])\\n ax1_density.bar(xint, self.density_, width=xint[1] - xint[0])\\n ax1_main.get_shared_x_axes().join(ax1_main, ax1_density)\\n ax1_density.set_yticklabels([])\\n ax1_density.autoscale()\\n fig.add_subplot(ax1_density)\\n plt.show()\",\n \"def visualize(\\n self,\\n filename: str = \\\"mydask\\\",\\n format: str | None = None,\\n optimize_graph: bool = False,\\n **kwargs: Any,\\n ) -> DisplayObject | None:\\n raise NotImplementedError(\\\"Inheriting class must implement this method.\\\")\",\n \"def show_wordcloud(dictionary, title, min_font = 10):\\n wordcloud = WordCloud(min_font_size=min_font).generate_from_frequencies(dictionary)\\n plt.figure(figsize = (8, 8), facecolor = None) \\n plt.imshow(wordcloud) \\n plt.axis(\\\"off\\\")\\n if title:\\n plt.title(title)\\n else:\\n plt.title(\\\"Word Cloud\\\")\\n plt.tight_layout(pad = 0) \\n\\n plt.show()\",\n \"def viz1(img, interest_points, color='r'):\\n\\n\\tx = [a[1] for a in interest_points] #blob detection x axis\\n\\ty = [a[0] for a in interest_points] #blob detection y axis\\n\\ts = [a[2] for a in interest_points] #blob detected at sigma \\n \\n\\tplt.imshow(img, cmap='gray') #adding the input image to plot \\n\\tfor x, y, s in zip(x, y, s):\\n\\t\\tplt.scatter(x, y, alpha=1, facecolors='none', edgecolors='r', s=s**2) #plotting the input interest points\\n\\tplt.axis('off')\\n\\t#plt.show() #showing the image // can be changed to saving the image locally \\n\\n\\treturn\",\n \"def plot(self):\\n pass\",\n \"def visualize(request, slug, handle_id):\\n nh = get_object_or_404(NodeHandle, pk=handle_id)\\n node = nh.get_node()\\n return render(request, 'noclook/visualize/visualize.html', {'node_handle': nh, 'node': node, 'slug': slug})\",\n \"def visualize(self, log_dir):\\n self.features_inputter.visualize(self, log_dir)\\n if not self.unsupervised:\\n self.labels_inputter.visualize(self, log_dir)\",\n \"def test_visualize_vocab_interact():\\n import plottool as pt\\n pt.qt4ensure()\\n ibs, aid_list, vocab = testdata_vocab()\\n #aid_list = aid_list[0:1]\\n fstack = StackedFeatures(ibs, aid_list)\\n nAssign = 2\\n invassign = fstack.inverted_assignment(vocab, nAssign)\\n sortx = ut.argsort(invassign.num_list)[::-1]\\n wx_list = ut.take(invassign.wx_list, sortx)\\n wx = wx_list[0]\\n fnum = 1\\n for wx in ut.InteractiveIter(wx_list):\\n visualize_vocab_word(ibs, invassign, wx, fnum)\",\n \"def visualize_dataset(dataset, num_samples=10):\\n\\n # Get signals\\n dataloader = torch.utils.data.DataLoader(\\n dataset,\\n batch_size=num_samples,\\n )\\n signals, _ = next(iter(dataloader))\\n signals = signals[:, 0].numpy()\\n\\n # Display signals in plot\\n if num_samples == 1 or dataset.do_overfitting:\\n plt.title(\\\"Datasample to overfit on\\\")\\n plt.plot(signals[0])\\n else:\\n f, axes = plt.subplots(num_samples, figsize=(8, 2 * num_samples))\\n f.suptitle(\\\"{} Preprocessed data samples\\\".format(num_samples), fontsize=16)\\n\\n for i_plot in range(num_samples):\\n axes[i_plot].plot(signals[i_plot])\\n\\n plt.show(block=True)\",\n \"def embedding_plot(model,datapath,img_size=100,stride=10,sample_size=1,nrand=None,adjust=True,show_images=True):\\n data = set_creation(datapath,img_size,stride,sample_size,nrand=nrand,adjust=adjust)\\n model.eval()\\n z = model(data[:nrand].float())[-1]\\n z = z.data.cpu().numpy()\\n plt.style.use('seaborn')\\n fig, ax = plt.subplots(dpi=100)\\n plt.scatter(z[:,0,0], z[:,0,1])\\n if show_images:\\n for i in range(len(z)):\\n imagebox = OffsetImage(data[i,0], zoom=0.4)\\n ab = AnnotationBbox(imagebox, (z[i,0,0], z[i,0,1]),frameon=False)\\n ax.add_artist(ab)\\n plt.xlabel('Latent variable 1')\\n plt.ylabel('Latent variable 2')\\n plt.tight_layout()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def run_visualization(filepath):\\n try:\\n \\t#print(\\\"Trying to open : \\\" + sys.argv[1])\\n \\t# f = open(sys.argv[1])\\n \\tjpeg_str = open(filepath, \\\"rb\\\").read()\\n \\torignal_im = Image.open(BytesIO(jpeg_str))\\n except IOError:\\n print('Cannot retrieve image. Please check file: ' + filepath)\\n return\\n\\n #print('running deeplab on image %s...' % filepath)\\n resized_im, seg_map = MODEL.run(orignal_im)\\n\\n # vis_segmentation(resized_im, seg_map)\\n drawSegment(resized_im, seg_map)\",\n \"def show_reconstruction(dataset, model, num_samples, color='black'):\\n mpl.rcParams['text.color'] = color\\n mpl.rcParams['axes.labelcolor'] = color\\n mpl.rcParams['xtick.color'] = color\\n mpl.rcParams['ytick.color'] = color\\n\\n # Create dataloader\\n dataloader = torch.utils.data.DataLoader(\\n dataset,\\n batch_size=num_samples,\\n )\\n\\n # Get next batch\\n x, _ = next(iter(dataloader))\\n target = x\\n\\n # Compute prediction and diff\\n pred, _ = model(x)\\n pred = pred.detach()\\n diff = target - pred\\n ymax = max(target.max(), pred.max())\\n ymin = min(target.min(), pred.min())\\n\\n if len(x.shape) != 4:\\n target = target[:, :, :, None]\\n pred = pred[:, :, :, None]\\n diff = diff[:, :, :, None]\\n\\n for i_channel in range(target.shape[-1]):\\n # Create plot\\n for i_sample in range(num_samples):\\n f, axes = plt.subplots(1, 3, figsize=(20, 5))\\n # f.suptitle(\\\"Input vs reconstruction, channel: {}\\\".format(i_channel), fontsize=16)\\n\\n # Label rows\\n labels = {0: 'Ground truth',\\n 1: 'Prediction',\\n 2: 'Deviation'}\\n\\n for i in range(3):\\n plt.sca(axes[i])\\n axes[i].set_title(labels[i], rotation=0, size=16)\\n axes[i].set_ylim([ymin - .5, ymax + .5])\\n axes[i].tick_params(labelsize=12)\\n\\n # Plot ground truth\\n axes[0].plot(target[i_sample, 0, :, i_channel].numpy())\\n\\n # Plot prediction\\n axes[1].plot(pred[i_sample, 0, :, i_channel].numpy())\\n\\n # Plot deviation\\n axes[2].plot(diff[i_sample, 0, :, i_channel].numpy())\\n\\n plt.show()\",\n \"def show():\\n\\tplt.show()\",\n \"def show_plot(self):\\n runs = self.GetParent().runs\\n if len(runs) <= 0: return\\n\\n t1 = time.time()\\n total_width = self.GetParent().total_width\\n\\n newwidth = total_width * (self.GetParent().zoom / 100)\\n newmid = total_width * (self.GetParent().pan/100)\\n newxmin = newmid - (newwidth/2)\\n newxmax = newxmin + newwidth\\n\\n if newxmin < 0:\\n newxmin = 0\\n newxmax = newwidth\\n elif newxmax > total_width:\\n newxmax = total_width\\n newxmin = newxmax - newwidth\\n\\n assert newxmin >= 0 and newxmin <= total_width\\n\\n #print \\\"**** Zoom: %s, pan: %s, total_width: %s, newwidth: %s, newmid: %s, newxmin: %s, newxmax: %s\\\" \\\\\\n # %(self.GetParent().zoom,self.GetParent().pan,total_width,newwidth,newmid,newxmin,newxmax)\\n\\n left = 0\\n width_so_far = 0\\n self.figure.clear()\\n braggsmax = max(flex.max(r.culled_braggs) for r in runs)\\n braggsmin = min(flex.min(r.culled_braggs) for r in runs)\\n distsmax = max(flex.max(r.culled_distances) for r in runs)\\n distsmin = min(flex.min(r.culled_distances) for r in runs)\\n sifomax = max(flex.max(r.culled_sifoils) for r in runs)\\n sifomin = min(flex.min(r.culled_sifoils) for r in runs)\\n wavemax = max(flex.max(r.culled_wavelengths) for r in runs)\\n wavemin = min(flex.min(r.culled_wavelengths) for r in runs)\\n\\n #above tricks don't work for hit rates as they can be empty if the run is new\\n goodruns = []\\n for run in runs:\\n if len(run.hit_rates) > 0: goodruns.append(run)\\n if len(goodruns) > 0:\\n hitsmax = max(flex.max(r.hit_rates) for r in goodruns)\\n hitsmin = min(flex.min(r.hit_rates) for r in goodruns)\\n else:\\n hitsmax = hitsmin = 0\\n\\n first_run = True\\n for run in runs:\\n right = left + run.width()\\n\\n if right < newxmin or left > newxmax:\\n left += run.width()\\n #print \\\"Not showing run %s\\\"%run.runId\\n continue\\n\\n if left < newxmin:\\n xmin = run.min() + (newxmin - left)\\n else:\\n xmin = run.min()\\n\\n if right > newxmax:\\n xmax = run.min() + (newxmax - left)\\n else:\\n xmax = run.max()\\n\\n #print \\\"Run: %s, run.width(): %s, left: %s, right: %s, run.min(): %s, run.max(): %s, xmin: %s, xmax: %s, width_so_far: %s, xmax-xmin: %s\\\" \\\\\\n #%(run.runId,run.width(),left,right,run.min(),run.max(),xmin,xmax,width_so_far,xmax-xmin)\\n\\n ax1 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.05, 0.9*(xmax-xmin)/newwidth, 0.4])\\n ax2 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.45, 0.9*(xmax-xmin)/newwidth, 0.2], sharex=ax1)\\n ax3 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.65, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\\n ax4 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.75, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\\n ax5 = self.figure.add_axes([0.05+(0.9*width_so_far/newwidth), 0.85, 0.9*(xmax-xmin)/newwidth, 0.1], sharex=ax1)\\n left += run.width()\\n width_so_far += (xmax-xmin)\\n\\n ax1.grid(True, color=\\\"0.75\\\")\\n ax2.grid(True, color=\\\"0.75\\\")\\n ax3.grid(True, color=\\\"0.75\\\")\\n ax4.grid(True, color=\\\"0.75\\\")\\n ax5.grid(True, color=\\\"0.75\\\")\\n ax1.plot(run.culled_bragg_times.select(run.culled_indexed),\\n run.culled_braggs.select(run.culled_indexed), 'd', color=[0.0,1.0,0.0])\\n ax1.plot(run.culled_bragg_times.select(~run.culled_indexed),\\n run.culled_braggs.select(~run.culled_indexed), 'd', color=[0.0,0.5,1.0])\\n ax2.plot(run.hit_rates_times, run.hit_rates, 'o-', color=[0.0,1.0,0.0])\\n ax3.plot(run.culled_bragg_times, run.culled_wavelengths, '^', color=[0.8,0.0,0.2])\\n ax4.plot(run.culled_bragg_times, run.culled_sifoils, '<', color=[0.8,0.0,0.2])\\n ax5.plot(run.culled_bragg_times, run.culled_distances, '>', color=[0.8,0.0,0.2])\\n ax1.set_ylabel(\\\"# of Bragg spots\\\")\\n ax2.set_ylabel(\\\"Hit rate (%)\\\")\\n ax3.set_ylabel(\\\"WaveL\\\")\\n ax4.set_ylabel(\\\"SiFoils(mm)\\\")\\n ax5.set_ylabel(\\\"Dist (mm)\\\")\\n ax1.set_xlim(xmin, xmax)\\n ax1.set_ylim(braggsmin, braggsmax)\\n ax2.set_ylim(hitsmin, hitsmax)\\n ax3.set_ylim(wavemin, wavemax)\\n ax4.set_ylim(sifomin-10, sifomax+10)\\n ax5.set_ylim(distsmin-3, distsmax+3)\\n ax1.set_xlabel(\\\"Time\\\")\\n for ax in ax1, ax2, ax3, ax4, ax5:\\n if (ax is not ax1) :\\n for label in ax.get_xticklabels():\\n label.set_visible(False)\\n ax.get_yticklabels()[0].set_visible(False)\\n if not first_run:\\n ax.get_yaxis().set_visible(False)\\n\\n ax1.xaxis.set_major_formatter(ticker.FuncFormatter(status_plot.format_time))\\n ax3.yaxis.set_major_formatter(ticker.FormatStrFormatter(\\\"%.3f\\\"))\\n ax5.yaxis.set_major_formatter(ticker.FormatStrFormatter(\\\"%.0f\\\"))\\n ax5.set_title(\\\"%d:%d/%d:%.1f%% I:%d\\\"%(run.runId, run.hits_count, len(run.braggs), 100*run.hits_count/len(run.braggs),run.indexed.count(True)))\\n\\n labels = ax1.get_xticklabels()\\n for label in labels:\\n label.set_rotation(30)\\n\\n first_run = False\\n\\n self.figure.autofmt_xdate()\\n self.canvas.draw()\\n self.parent.Refresh()\\n\\n t2 = time.time()\\n print(\\\"Plotted in %.2fs\\\" % (t2 - t1))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7063717","0.70084274","0.6780399","0.67113185","0.6641346","0.6596172","0.634411","0.62974614","0.6267937","0.62584573","0.6230526","0.62199605","0.6215069","0.62079453","0.6161333","0.6143889","0.6129229","0.6113831","0.6110358","0.6108171","0.6070151","0.6065122","0.6037944","0.6018431","0.6018393","0.60166276","0.5994203","0.5982183","0.59817284","0.597512","0.5973793","0.59678185","0.59655446","0.5961333","0.59471875","0.5943585","0.59386516","0.5913019","0.5904275","0.5888877","0.588625","0.5885199","0.5884394","0.58805746","0.58658904","0.586496","0.58648914","0.58596176","0.5851736","0.5851712","0.58491683","0.5843014","0.582392","0.5823163","0.58137953","0.57965434","0.57916254","0.57912946","0.5791263","0.5785026","0.57597035","0.5759447","0.5757112","0.5747795","0.5744872","0.5744081","0.5733901","0.5732246","0.57292783","0.5728239","0.5712285","0.5699693","0.5696795","0.56800973","0.567704","0.56752855","0.565389","0.5653471","0.5650575","0.5650456","0.5644829","0.5634969","0.56345725","0.5625636","0.5624431","0.56208384","0.5614443","0.5611842","0.5606148","0.5605814","0.56032896","0.55941194","0.55913174","0.5589443","0.55861235","0.55861235","0.55861235","0.5584269","0.55802464","0.5579133","0.5578991"],"string":"[\n \"0.7063717\",\n \"0.70084274\",\n \"0.6780399\",\n \"0.67113185\",\n \"0.6641346\",\n \"0.6596172\",\n \"0.634411\",\n \"0.62974614\",\n \"0.6267937\",\n \"0.62584573\",\n \"0.6230526\",\n \"0.62199605\",\n \"0.6215069\",\n \"0.62079453\",\n \"0.6161333\",\n \"0.6143889\",\n \"0.6129229\",\n \"0.6113831\",\n \"0.6110358\",\n \"0.6108171\",\n \"0.6070151\",\n \"0.6065122\",\n \"0.6037944\",\n \"0.6018431\",\n \"0.6018393\",\n \"0.60166276\",\n \"0.5994203\",\n \"0.5982183\",\n \"0.59817284\",\n \"0.597512\",\n \"0.5973793\",\n \"0.59678185\",\n \"0.59655446\",\n \"0.5961333\",\n \"0.59471875\",\n \"0.5943585\",\n \"0.59386516\",\n \"0.5913019\",\n \"0.5904275\",\n \"0.5888877\",\n \"0.588625\",\n \"0.5885199\",\n \"0.5884394\",\n \"0.58805746\",\n \"0.58658904\",\n \"0.586496\",\n \"0.58648914\",\n \"0.58596176\",\n \"0.5851736\",\n \"0.5851712\",\n \"0.58491683\",\n \"0.5843014\",\n \"0.582392\",\n \"0.5823163\",\n \"0.58137953\",\n \"0.57965434\",\n \"0.57916254\",\n \"0.57912946\",\n \"0.5791263\",\n \"0.5785026\",\n \"0.57597035\",\n \"0.5759447\",\n \"0.5757112\",\n \"0.5747795\",\n \"0.5744872\",\n \"0.5744081\",\n \"0.5733901\",\n \"0.5732246\",\n \"0.57292783\",\n \"0.5728239\",\n \"0.5712285\",\n \"0.5699693\",\n \"0.5696795\",\n \"0.56800973\",\n \"0.567704\",\n \"0.56752855\",\n \"0.565389\",\n \"0.5653471\",\n \"0.5650575\",\n \"0.5650456\",\n \"0.5644829\",\n \"0.5634969\",\n \"0.56345725\",\n \"0.5625636\",\n \"0.5624431\",\n \"0.56208384\",\n \"0.5614443\",\n \"0.5611842\",\n \"0.5606148\",\n \"0.5605814\",\n \"0.56032896\",\n \"0.55941194\",\n \"0.55913174\",\n \"0.5589443\",\n \"0.55861235\",\n \"0.55861235\",\n \"0.55861235\",\n \"0.5584269\",\n \"0.55802464\",\n \"0.5579133\",\n \"0.5578991\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":25992,"cells":{"query":{"kind":"string","value":"Save files like the dataset, mask and settings as pickle files so they can be loaded in the ``Aggregator``"},"document":{"kind":"string","value":"def save_attributes_for_aggregator(self, paths):\r\n # These functions save the objects we will later access using the aggregator. They are saved via the `pickle`\r\n # module in Python, which serializes the data on to the hard-disk.\r\n\r\n with open(f\"{paths.pickle_path}/dataset.pickle\", \"wb\") as f:\r\n pickle.dump(self.dataset, f)\r\n\r\n with open(f\"{paths.pickle_path}/settings.pickle\", \"wb+\") as f:\r\n pickle.dump(self.settings, 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 pickle_data(self):\n if 'data_sets.pckl' in self.expected_pickles:\n to_file(\n self.data_sets,\n os.path.join(self.logdir, 'data_sets.pckl')\n )\n if 'all_params.pckl' in self.expected_pickles:\n to_file(\n self.all_params,\n os.path.join(self.logdir, 'all_params.pckl')\n )\n if 'labels.pckl' in self.expected_pickles:\n to_file(\n self.labels,\n os.path.join(self.logdir, 'labels.pckl')\n )\n if 'minimiser_info.pckl' in self.expected_pickles:\n to_file(\n self.minimiser_info,\n os.path.join(self.logdir, 'minimiser_info.pckl')\n )","def pickle_dump_files():\n with open('data/' + dataset_name + '_' + model_name + '_' + 'predictions', 'wb') as f:\n pickle.dump(predictions, f)\n with open('data/' + dataset_name + '_' + model_name + '_' + 'state_sentences', 'wb') as f:\n pickle.dump(final_state_sentences, f)\n with open('data/' + dataset_name + '_' + model_name + '_' + 'decoded_sentences', 'wb') as f:\n pickle.dump(final_decoded_sentences, f)\n with open('data/' + dataset_name + '_' + model_name + '_' + 'ids', 'wb') as f:\n pickle.dump(idx, f)\n with open('data/' + dataset_name + '_' + model_name + '_' + 'exemplars', 'wb') as f:\n pickle.dump(exemplars, f)\n with open('data/' + dataset_name + '_' + model_name + '_' + 'counter_exemplars', 'wb') as f:\n pickle.dump(counter_exemplars, f)\n with open('data/' + dataset_name + '_' + model_name + '_' + 'top_exemplar_words', 'wb') as f:\n pickle.dump(top_exemplar_words, f)\n with open('data/' + dataset_name + '_' + model_name + '_' + 'top_counter_exemplar_words', 'wb') as f:\n pickle.dump(top_counter_exemplar_words, f)","def save_to(self, save_path=\"./\", run_flag='', save_method=\"pickle\"):\n # TODO: Finish the save_method parameters\n time_stamp = self.time_stamp\n time_stamp = self.time_stamp + \"_\" + run_flag\n save_path = os.path.join(save_path, time_stamp)\n\n if not os.path.exists(save_path):\n os.makedirs(save_path)\n\n if self.feature_importance_pool:\n file_path = os.path.join(save_path, \"feature_importances.pkl\")\n save_file(file_path, self.feature_importance_pool)\n\n if self.feature_importance_hist:\n file_path = os.path.join(save_path, \"feature_importances_hist.png\")\n save_file(file_path, self.feature_importance_hist[0])\n\n if self.area_under_curve_pool:\n file_path = os.path.join(save_path, \"auc_fpr_tpr.pkl\")\n save_file(file_path, self.area_under_curve_pool)\n\n if self.receiver_operating_characteristic_curve:\n file_path = os.path.join(save_path, \"roc_curve.png\")\n save_file(file_path, self.receiver_operating_characteristic_curve[0])\n\n if self.training_report_pool:\n file_path = os.path.join(save_path, \"training_report.pkl\")\n save_file(file_path, self.training_report_pool)\n\n if self.learning_line:\n file_path = os.path.join(save_path, \"learning_curve.png\")\n save_file(file_path, self.learning_line[0])\n\n file_path = os.path.join(save_path, time_stamp + \"_object.pkl\")\n with open(file_path, 'wb') as opfh:\n pickle.dump(self, opfh)","def __save_datasets(self):\n self.train.to_csv('{}/{}/{}'.format(path_to_train_set, img_format, 'train.csv'))\n self.valid.to_csv('{}/{}/{}'.format(path_to_valid_set, img_format, 'valid.csv'))\n self.test.to_csv('{}/{}/{}'.format(path_to_test_set, img_format, 'test.csv'))","def saveSettings(self):\n self.genFiles.applyData()\n self.genGraph.applyData()","def save_datasets(self):\n if self.processed_extension == '.csv':\n # Save to csv\n logger.info(f'Saving sets to csv:')\n \n # TRAIN\n logger.info(f'train: {self.train_path}')\n \n # Concatenate X and y\n train_data = self.train_data[0]\n train_data['TARGET'] = self.train_data[1]\n \n # Save as csv\n train_data.to_csv(self.train_path, index = False)\n \n \n # VAL\n logger.info(f'val: {self.val_path}')\n \n # Concatenate X and y\n val_data = self.val_data[0]\n val_data['TARGET'] = self.val_data[1]\n \n # Save as csv\n val_data.to_csv(self.val_path, index = False)\n \n # TEST\n logger.info(f'test: {self.test_path}')\n \n # Concatenate X and y\n test_data = self.test_data[0]\n test_data['TARGET'] = self.test_data[1]\n \n # Save as csv\n self.test_data.to_csv(self.test_path, index = False)\n \n elif self.processed_extension == '.npz':\n # Convert y to numpy array\n if isinstance(self.train_data[1], pd.Series):\n self.train_data[1] = self.train_data[1].to_numpy()\n if isinstance(self.val_data[1], pd.Series):\n self.val_data[1] = self.val_data[1].to_numpy()\n if isinstance(self.test_data[1], pd.Series):\n self.test_data[1] = self.test_data[1].to_numpy()\n \n # Save to npz (scipy sparse)\n logger.info(f'Saving sets to npz:')\n\n logger.info(f'train: {self.train_path}')\n train_data = [self.train_data[0], np.reshape(self.train_data[1], (-1,1))]\n sparse.save_npz(self.train_path, sparse.hstack(train_data))\n \n logger.info(f'val: {self.val_path}')\n val_data = [self.val_data[0], np.reshape(self.val_data[1], (-1,1))]\n sparse.save_npz(self.val_path, sparse.hstack(val_data))\n\n logger.info(f'test: {self.test_path}')\n test_data = [self.test_data[0], np.reshape(self.test_data[1], (-1,1))]\n sparse.save_npz(self.test_path, sparse.hstack(test_data))\n\n else:\n raise AttributeError(f'Wrong extension: {self.processed_extension}')\n \n self.input_size = self.train_data[0].shape[1]\n logger.info(f'Saved datasets.')","def save(self, path, name):\n if not self._frozen:\n raise Exception(\"Dataset must be frozen\")\n # create directory\n pathlib.Path(os.path.join(path,name)).mkdir(parents=True, exist_ok=True)\n self._raw_data.to_hdf(os.path.join(path,name,\"dataset.h5\"), key=\"raw_data\")\n self._proc_data.to_hdf(os.path.join(path,name,\"dataset.h5\"), key=\"proc_data\")\n np.save(os.path.join(path,name,\"_X_train.npy\"), self._X_train)\n np.save(os.path.join(path,name,\"_X_test.npy\"), self._X_test)\n np.save(os.path.join(path,name,\"_y_train.npy\"), self._y_train)\n np.save(os.path.join(path,name,\"_y_test.npy\"), self._y_test)\n \n np.save(os.path.join(path,name,\"_X_mean.npy\"), self._X_mean)\n np.save(os.path.join(path,name,\"_X_std.npy\"), self._X_std)\n np.save(os.path.join(path,name,\"_y_mean.npy\"), self._y_mean)\n np.save(os.path.join(path,name,\"_y_std.npy\"), self._y_std)\n \n with open(os.path.join(path,name,\"_seed.pkl\"), \"wb\") as fp: #Pickling\n pickle.dump(self._seed, fp)\n with open(os.path.join(path,name,\"_train_part.pkl\"), \"wb\") as fp: #Pickling\n pickle.dump(self._train_part, fp)\n with open(os.path.join(path,name,\"_test_part.pkl\"), \"wb\") as fp: #Pickling\n pickle.dump(self._test_part, fp)\n with open(os.path.join(path,name,\"_columns.pkl\"), \"wb\") as fp: #Pickling\n pickle.dump(self._columns, fp)","def save_all(cls, dirpath=\".\"):\n for n, v in cls.__data.items():\n pickle.dump(v, open(cls.dirpath + n + '.p', 'wb'))\n print \"Data saved to: %s\" % dirpath","def save(self):\n pickle_save(self.results, 'results', self.main_dir)","def save_inst(self):\n self.sanity_check()\n self.data_loaded_check()\n\n fname_pub_auth_all = ''.join([self.config.dir_data, '/',\n self.config.fname_pub_auth_all, '_',\n self.config.experiment_id, '.pk'])\n fname_pub_auth_top = ''.join([self.config.dir_data, '/',\n self.config.fname_pub_auth_top, '_',\n self.config.experiment_id, '.pk'])\n fname_pub_inst_all = ''.join([self.config.dir_data, '/',\n self.config.fname_pub_inst_all, '_',\n self.config.experiment_id, '.pk'])\n fname_pub_inst_top = ''.join([self.config.dir_data, '/',\n self.config.fname_pub_inst_top, '_',\n self.config.experiment_id, '.pk'])\n\n pickle.dump(self.pub_auth_all, open(fname_pub_auth_all, 'wb'))\n pickle.dump(self.pub_auth_top, open(fname_pub_auth_top, 'wb'))\n pickle.dump(self.pub_inst_all, open(fname_pub_inst_all, 'wb'))\n pickle.dump(self.pub_inst_top, open(fname_pub_inst_top, 'wb'))\n\n fname_pub_history = ''.join([self.config.dir_data, '/history_',\n self.config.experiment_id, '.pk'])\n pickle.dump(self.history, open(fname_pub_history, 'wb'))\n\n fname_pub_staff = ''.join([self.config.dir_data, '/staff_',\n self.config.experiment_id, '.pk'])\n pickle.dump(self.staff, open(fname_pub_staff, 'wb'))","def save_data_pickle(self, save_full=False):\n self.train.to_pickle('../input/train_mod.pkl')\n self.test.to_pickle('../input/test_mod.pkl')\n if save_full:\n self.train_full.to_pickle('../input/train_full_mod.pkl')","def save_outputs(self):\n write_pickled(join(self.output_folder, \"results.pkl\"), self.get_results())","def save_features_to_file(self):\n if not os.path.exists(self.features_save_path):\n os.makedirs(self.features_save_path)\n for s in self.sets:\n self.save_features_to_file_by_set(s)","def save(self):\n if self.loaded:\n list_embeddingNames = [self.embeddings.vsm_name, self.synset_embeddings.vsm_name, self.imagined_embeddings.vsm_name]\n full_file_name = self.resource_manager.get_multimodal_dataset(self.corpus, list_embeddingNames)\n logging.info('Saving dataset to [%s]', full_file_name)\n with lzma.open(full_file_name, 'wb') as f:\n pickle.dump(self, f)\n else:\n logging.error('Dataset not loaded, call \"build\" method first!')","def dumpme(self) :\n fileName = \"./data/oP4_ModelBuilder.dump\"\n with open(fileName,\"wb\") as dumpedFile:\n oPickler = pickle.Pickler(dumpedFile)\n oPickler.dump(self)","def _dump_states(self, train=True):\n\t\tprefix = self.config.experiment_dir_name+\"/datastreams/\"\n\t\ttry:\n\t\t\tos.mkdir(prefix)\n\t\texcept:\n\t\t\tpass\n\n\t\tprefix += \"{}.pickle\"\n\n\t\tif train:\n\t\t\tself.train_accuracy.dump(prefix.format(\"train_accuracy\"))\n\t\t\tself.train_epochs.dump(prefix.format(\"train_epochs\"))\n\t\t\tself.train_loss.dump(prefix.format(\"train_loss\"))\n\t\t\tself.train_confusion_matrix.dump(prefix.format(\"train_confusion_matrix\"))\n\t\t\tself.learning_rate.dump(prefix.format(\"learning_rate\"))\n\t\telse:\n\t\t\tself.val_accuracy.dump(prefix.format(\"val_accuracy\"))\n\t\t\tself.val_epochs.dump(prefix.format(\"val_epochs\"))\n\t\t\tself.val_loss.dump(prefix.format(\"val_loss\"))\n\t\t\tself.val_confusion_matrix.dump(prefix.format(\"val_confusion_matrix\"))\n\t\t\"\"\"\n\t\tSave dataset specific metadata into experiment dir\n\t\t\"\"\"\n\t\t# TODO: Redo this with more information from dataset meta.json file\n\t\tmeta_path = self.config.experiment_dir_name+\"/meta.json\"\n\t\t_meta = {}\n\t\t_meta[\"classes\"] = self.classes\n\t\t_meta[\"plot_platform\"] = self.config.plot_platform\n\t\t# _meta[\"dataset_dir\"] = self.dataset.dataset_folder\n\t\tif not os.path.exists(meta_path):\n\t\t\tfp = open(meta_path, \"w\")\n\t\t\tfp.write(json.dumps(_meta))\n\t\t\tfp.close()","def _save(self, dataset, path, files, copy_files=False):\n raise NotImplementedError('Loader {} does not support saving datasets.'.format(self.type()))","def _save(self):\n\t\t\n\t\tdirectory = self.Output_path\n\n\t\t# replace with \n\t\t# file_name = hermes.mk_themis_file_name(themis_obj = self)\n\t\tfile_name = f'Themis_{self.CELL_ID[\"experiment\"]}_u{self.CELL_ID[\"unit\"]}_c{self.CELL_ID[\"cell\"]}_r{self.CELL_ID[\"run\"]}.pkl'\n\n\t\tsave_path = directory / file_name\n\n\t\t# Atomic saving (helpful?)\n\t\ttemp_path = save_path.with_suffix(save_path.suffix + '.tmp')\n\t\t\n\t\tself.SavePath = save_path\n\n\t\t\n\t\twith open(temp_path, 'wb') as f:\n\t\t\tpickle.dump(self, f)\n\n\t\ttemp_path.rename(save_path)\n\n\t\tprint(f'Saved {self.RUN_KEY} as {save_path}')","def save(self, path=None):\n data = self._collect_data()\n\n name = np.random.choice(['a', 'b', 'c', 'd', 'e', 'f']+list(map(str, range(0, 10))), size=8)\n if path is None:\n path = './logs/'+\"\".join(name)+'_'\n with open(path, \"wb\") as f:\n cloudpickle.dump(data, f)\n print(\"Saved at {}\".format(path))","def pickle(self,data,filename):\n pickle.dump(data, open(filename, 'wb'))","def save_configurations(self):\n # Get the file path\n self.data_path = self.data_path_entry.get()\n # Open the file\n with open(self.data_path, 'rb') as file:\n self.log('Opened ' + str(self.data_path))\n # Un-serialize\n info = pickle.load(file)\n # Write the new properties\n self.main_window.overwrite_properties(info)\n\n self.exit()","def save(self):\n if self.loaded:\n full_file_name = self.resource_manager.get_dataset(self.corpus, self.embeddings.vsm_name)\n logging.info('Saving dataset to [%s]', full_file_name)\n with lzma.open(full_file_name, 'wb') as f:\n pickle.dump(self, f)\n else:\n logging.error('Dataset not loaded, call \"build\" method first!')","def save(self, filename):\n with open(filename, 'w') as f:\n pickle.dump((self.components, self.mean), f)","def save_data_pickle(PATH, data, dataset, filename):\n with open(PATH + '/' + dataset + \"_\" + filename + \".pkl\",\"wb\") as f:\n pickle.dump(data,f)\n print(filename, \"created\")","def save(self):\n\n # make a clone to preserve the original in case it's still needed\n clone = {}\n\n for machine in self.activity.keys():\n data = self.activity[machine].copy()\n data[\"filtered activity\"] = np.array(data[\"filtered activity\"], dtype=np.float)\n data[\"raw activity\"] = np.array(data[\"raw activity\"], dtype=np.float)\n data[\"time\"] = np.array(data[\"time\"], dtype=np.float)\n clone[machine] = data\n\n out = open(self.filename, \"wb\")\n pickle.dump(clone, out)\n out.close()","def save(self):\n pickle.dump(self, open(self.path, \"wb\"))","def store(self):\n\t\tprint(\"Storing to\", self.storagedir)\n\n\t\tfor filename in self.FILENAMES:\n\t\t\twith open(os.path.join(self.storagedir, filename), \"wb\") as handle:\n\t\t\t\t_pickle.dump(getattr(self, filename), handle)","def save(self, filename=\"matpipe.p\"):\n temp_backend = self.learner.backend\n self.learner._backend = self.learner.backend.fitted_pipeline_\n for obj in [self, self.learner, self.reducer, self.cleaner,\n self.autofeaturizer]:\n obj._logger = None\n with open(filename, 'wb') as f:\n pickle.dump(self, f)\n self.learner._backend = temp_backend","def load_files(self):\n print('Saving numpy mask arrays in {0}'.format(self.ProcDir))\n\n if not os.path.isdir(self.ProcDir): os.mkdir(self.ProcDir)\n if not os.path.isdir(self.OutDir): os.mkdir(self.OutDir)\n\n self.Files = {}\n for ig in self.Set:\n phase = roipy.tools.load_half(ig,2)\n # convert wavelength to displacements\n # NOTE: make attributes of commonly used values in rsc: float(ig.Rsc['WAVELENGTH'])\n disp = phase * (ig.Wavelength / (4*np.pi))\n igram = ma.array(disp, mask=ma.nomask)\n name = self.save_ma(ig, igram) #Mask_ array is just zeros at this point..\n self.Files[ig.ID] = name\n\n print('load_files() complete: {0} interferograms'.format(self.Set.Nig))","def save(self, path: utils.URLPath):\n save_somclassifier_config(self.config, path / \"config.json\")\n self.model.save(str(path / \"model.h5\"))\n io_functions.save_joblib(self.binarizer, path / \"binarizer.joblib\")\n\n io_functions.save_json(self.data_ids[\"validation\"], path / \"ids_validate.json\")\n io_functions.save_json(self.data_ids[\"train\"], path / \"ids_train.json\")","def dump(self, model_path):\n pickle.dump(self.scaler, gzip.open(os.path.join(model_path, 'scaler.pkl.gz'), 'w'),\n protocol=pickle.HIGHEST_PROTOCOL)\n# pickle.dump(self.mapper, gzip.open(os.path.join(model_path, 'mapper.pkl.gz'),'w'),\n# protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(self.batcher, gzip.open(os.path.join(model_path, 'batcher.pkl.gz'), 'w'),\n protocol=pickle.HIGHEST_PROTOCOL)","def save(self, folder):\n self.generator.save_weights('%s/generator.h5'%folder)\n self.critic.save_weights('%s/critic.h5'%folder)","def save(self):\n #--Data file exists?\n filePath = self.path\n if os.path.exists(filePath):\n ins = open(filePath)\n outData = compat.uncpickle(ins)\n ins.close()\n #--Delete some data?\n for key in self.deleted:\n if key in outData:\n del outData[key]\n else:\n outData = {}\n #--Write touched data\n for key in self.changed:\n outData[key] = self.data[key]\n #--Pickle it\n tempPath = filePath+'.tmp'\n cPickle.dump(outData,open(tempPath,'w'))\n renameFile(tempPath,filePath,True)","def save(self):\n\n # TODO:Find place to save data, write logic to save images(Filter out video?)","def save(self):\n if self.hasChanged:\n filePath = self.path\n tempPath = filePath+'.tmp'\n fileDir = os.path.split(filePath)[0]\n if not os.path.exists(fileDir): os.makedirs(fileDir)\n cPickle.dump(self.data,open(tempPath,'w'))\n renameFile(tempPath,filePath,True)\n self.hasChanged = False","def save(self, path):\n torch.save(\n {\n \"input_dimension\": self.input_dimension,\n \"quantiles\": self.quantiles,\n \"width\": self.width,\n \"depth\": self.depth,\n \"activation\": self.activation,\n \"network_state\": self.state_dict(),\n \"optimizer_state\": self.optimizer.state_dict(),\n },\n path,\n )","def _save(self):\n # TODO: Use local.punny dump (when written)\n with open(filename, 'w') as f:\n pickle = Pickler(f)\n pickle.dump(self.pungen.puns)","def save_data_to_disk(self):\n Omega_M = self.theta_fid[0]\n for key in self.data.keys():\n np.save(f'./preloaded_data/{Omega_M}_{self.delta_theta[0]}_{key}.npy', self.data[key])","def __savePreProcessedData(self):\n np.savetxt(self.X_filename, self.X, delimiter=',')\n np.savetxt(self.y_filename, self.le.fit_transform(self.y), delimiter=',')\n #Need to save the label Enconder to inverse transform later\n joblib.dump(self.le, self.le_filename)\n\n print(\"Saved X and y\")","def save(self, save_dir='models'):\n with open(os.path.join(save_dir, 'model_expert_predictor.pkl'), 'wb') as f:\n pickle.dump(self.model, f)\n with open(os.path.join(save_dir, 'vectorizer_expert_predictor.pkl'), 'wb') as f:\n pickle.dump(self.vectorizer, f)\n with open(os.path.join(save_dir, 'userid2name.pkl'), 'wb') as f:\n pickle.dump(self.userid2name, f)\n with open(os.path.join(save_dir, 'name2userid.pkl'), 'wb') as f:\n pickle.dump(self.name2userid, f)","def save(self, dirpath, data=False):\n if not data:\n self.data = None\n self.graphs = None\n\n if self.annotator is not None:\n self.annotator.save(dirpath, data=data)\n self.annotator = None\n\n super().save(join(dirpath, 'batch.pkl'))","def _save_data(self, filename):\n if not os.path.isdir(os.path.dirname(filename)):\n return False\n with open(filename, 'w') as f:\n f.truncate()\n pickle.dump({\n 'user_data': self.user_data,\n 'api_data': self.api_data,\n 'profiles': self.profiles\n }, f)","def dump_data(self,filename,dump_id):\n import pickle\n from Auxiliary import tdc_Filenames\n data = [ d.get_pure_data_copy() for d in self.plotter.data ]\n dump_dict={}\n dump_dict['fft_data'] = data\n dump_dict['fitting_type'] = self.fft_fit.type \n dump_dict['nk_plot'] = self.fft_fit.nk_plot\n # full file name of the file with manipulator dump\n filename=tdc_Filenames.get_full_vis_filename(dump_id, filename+'.pickle')\n pickle.dump( dump_dict, open(filename,'w') )\n print '\\nContent dumped in \"%s\" \\n' % filename","def save_reconstructions(reconstructions, out_dir):\n if (not (os.path.exists(out_dir))):\n os.mkdir(out_dir)\n out_dir.mkdir(exist_ok=True)\n print('Saved directory is',out_dir)\n for fname, recons in reconstructions.items():\n with h5py.File(out_dir / fname, 'w') as f:\n f.create_dataset('reconstruction', data=recons)","def save(self, filepath):\n save_ckpt = {\n 'ae': self.state_dict(),\n 'optimizer': self.optimizer.state_dict()\n }\n try:\n torch.save(save_ckpt, os.path.join(filepath, 'ckpt_ae.pth'))\n except:\n print('Cannot save autoencoder.')","def SaveDecoderAndData(clf, X, X_not_scaled, y, subjID):\n time_to_save = datetime.datetime.now().isoformat()\n time_to_save = time_to_save.replace('T','-')\n time_to_save = time_to_save.replace(':','-')\n \n model = clf\n model_file = 'Models/' + subjID + '_MI_classifier_' + time_to_save[:19] + '.sav'\n pickle.dump(model, open(model_file, 'wb'))\n \n filepath_export_data = 'Models/' + subjID + '_data_for_MI_classifier_' + time_to_save[:19] + '.npz'\n np.savez_compressed(filepath_export_data, subjID=subjID, X=X, X_not_scaled=X_not_scaled, y=y)","def save_object(self, filename, data):\n with open(filename, 'wb') as outp: # Overwrites any existing file.\n pickle.dump(data, outp, pickle.HIGHEST_PROTOCOL)","def save(self, filename, **kwargs):\n with open(filename, 'wb') as fin:\n pickle.dump(self, fin, **kwargs)","def save_data_file(self):\n with open(self.files['data'], 'w') as outfile:\n outfile.write(self.to_json())\n outfile.close()","def save(self):\n for p, c in self.configs_:\n c.write(p)","def serialize(self):\n output_dir = self.settings.output_dir\n # Remove previous high performers\n best = os.path.join(output_dir, 'best')\n if os.path.exists(best):\n shutil.rmtree(best)\n if not os.path.exists(best):\n os.mkdir(best)\n\n # update this instance to match the the state handler\n self.pareto_frontier = self.state.pareto_frontier\n\n # Get high performing population\n population = self.pareto_frontier.datadict.serialize(self.settings.output_dir)\n paths = []\n\n # update the paths to save to and write them to file\n for individual in population:\n metrics = individual.get('metrics')\n if metrics is not None:\n out = ''\n for key, item in metrics.items():\n assert not isinstance(item, dict)\n out += f'{key}_{item}_'\n uuid = individual.get('uuid')\n out_path = os.path.join(output_dir, 'best', f'{out}uuid_{uuid}.yml')\n if self.running_tests:\n paths.append(out_path)\n if not self.running_tests:\n with open(out_path, 'w') as f:\n yaml.dump(individual, f)\n\n # plot state\n if not self.running_tests and population is not None and len(population) > 0:\n self.pareto_frontier.plot()\n\n # For testing\n if self.running_tests:\n basenames = [os.path.basename(p) for p in paths]\n print(basenames)","def save(self, path):\n individual = self.population.fittest_individual()\n order = [int(l) for l in individual.label_order]\n fitness = individual.fitness\n data = {'name': self.ds.name,\n 'num_labels': len(order),\n 'order': order,\n 'fitness': fitness\n }\n with open(path, 'w') as f:\n json.dump(data, f)","def save(self):\n joblib.dump(\n self.classifier, \"data/models/repeatsfinder/repeatsfinder.joblib\",\n )","def to_pickle(self, filename, **kwargs):\n\n self._check_is_fitted()\n\n return dump(self, filename, **kwargs)","def save_dataset(self):\n if os.path.exists(self.output_path):\n print('Directory already exists. EXITING.')\n sys.exit()\n if not os.path.exists(self.output_path): os.mkdir(self.output_path)\n for window_num, cur_window in enumerate(self.time_windows):\n window_dir = (os.path.join(self.output_path, ('window %s' % str(window_num + 1))))\n if not os.path.exists(window_dir): os.mkdir(window_dir)\n for filepath in cur_window:\n topic = os.path.basename(os.path.dirname(filepath))\n topic_dir = os.path.join(os.path.join(window_dir, topic))\n if not os.path.exists(topic_dir): os.mkdir(topic_dir)\n copy(filepath, topic_dir)\n self.ground_truth.append((len(os.listdir(window_dir))))","def save_as(self, filename: str) -> None:\n save_data = lzma.compress(pickle.dumps(self))\n with open(filename, \"wb\") as f:\n f.write(save_data)","def _pickle_path(self) -> Path:\r\n return self.output_path / \"pickles\"","def dump_me(self, fileName=None) :\n if fileName is None :\n fileName = \"./data/oP4_ModelBuilder.dump\"\n else :\n pass\n with open(fileName,\"wb\") as dumpedFile:\n oPickler = pickle.Pickler(dumpedFile)\n oPickler.dump(self)","def save_synthetic_data(data):\n \n pickle_object = FM().data_file\n with pickle_object.open('wb') as data_file:\n pickle.dump(data, data_file)","def save_pickle(self, path):\n with open(path, 'wb') as f:\n pickle.dump(self, f, protocol=pickle.HIGHEST_PROTOCOL)","def save(self, filename: str):\n if os.path.isfile(filename):\n raise FileExistsError(\"Target file exists\")\n\n with open(filename, \"wb\") as binary_writer:\n pickle.dump([self.gene_sets, self.gene_set_size, self.gene_set_names,\n self.interactors, self.n_curated, self.n_interactors],\n binary_writer)","def save(self, filename):\n with gzip.open(filename, \"w\") as f:\n f.write(pickle.dumps(self))","def save(self, path):\n print(\"Warning: Default save used\")\n with open(path, 'wb') as f:\n pickle.dump(self, f)","def _save(self, data: np.ndarray) -> None:\n ...","def save(self,filename): \n with open(filename, 'wb') as f:\n pickle.dump(self,f)","def save(self, folder):\n if not path.exists(folder):\n os.makedirs(folder)\n param = {\n \"model\": self.__class__.__name__,\n \"nr_labels\": self.nr_labels,\n \"nr_features\": self.nr_features,\n \"nr_codes\": self.nr_codes,\n \"bias\": self.bias,\n \"pred_kwargs\": self.pred_params.to_dict(),\n }\n param = self.append_meta(param)\n with open(\"{}/param.json\".format(folder), \"w\") as f:\n f.write(json.dumps(param, indent=True))\n smat_util.save_matrix(\"{}/W.npz\".format(folder), self.W)\n smat_util.save_matrix(\"{}/C.npz\".format(folder), self.C)","def save(self,filename):\n with open(filename,'wb') as f:\n pickle.dump(self,f)","def _save_data(self):\n self.data.to_csv('data/c&le/{}'.format(self.name))","def save_reaction(self, filename):\n filename = filename.replace('.pkl', '.gpkl')\n filename = filename.replace('.bpkl', '.gpkl')\n # Overwrites any existing file.\n with gzip.GzipFile(filename, 'wb') as output:\n pickle.dump(self, output, pickle.HIGHEST_PROTOCOL)","def save(self):\n data = (\n self.Joints,\n self.Links,\n self.joint_syms,\n self.global_syms,\n self.name,\n self.sym_prefix,\n )\n cloudpickle.dump(data, open(self.save_filename, \"wb\"))","def _save_data(self, data):\n path = os.path.join(self._cache_path, '%s.data' % self._name)\n\n f = bz2.BZ2File(path, 'w')\n f.write(pickle.dumps(data))\n f.close()","def saveSettings(self):\n helpers.saveFile(self.dataDir, self.settingsFilename, json.dumps(self.settings))","def store(self, filename):","def save_pickle(self, filename):\n x, y, _ = self.get_coords_enu()\n cx, cy = self.get_centres_enu()\n coords = dict(x=x, y=y, cx=cx, cy=cy)\n pickle.dump(coords, open(filename, 'wb'))","def save(self, file):\n if isinstance(file, basestring):\n with open(file, \"wb\") as file:\n self.save(file)\n else:\n to_save = (self.model, self.features, self.labels)\n dump(to_save, file, HIGHEST_PICKLE_PROTOCOL)","def save_data_all(interpolated_acti, norm_acti, smoothed_acti, flag_roi, roi_tensor, meta_df, animal, arguments):\r\n\r\n\tconfiguration = pd.DataFrame(arguments, index=[0])\r\n\t\r\n\tpath = os.path.join(paths.path2Output, animal, 'Preprocessed Data')\r\n\ttry:\r\n\t os.makedirs(path)\r\n\texcept:\r\n\t FileExistsError\r\n\t\r\n\tconfiguration.to_csv(os.path.join(path, 'configuration.csv'))\r\n\tnp.save(os.path.join(path, 'acti'), interpolated_acti)\r\n\tnp.save(os.path.join(path, 'norm_acti'), norm_acti)\r\n\tnp.save(os.path.join(path, 'smoothed_acti'), smoothed_acti)\r\n\tnp.save(os.path.join(path,'flag_roi'), flag_roi)\r\n\tnp.save(os.path.join(path,'roi_tensor'), roi_tensor)\r\n\tmeta_df.to_csv(os.path.join(path, 'meta_df.csv'))","def save(self):\n with open(os.path.join(self.save_path, \"experiment.delira.pkl\"),\n \"wb\") as f:\n pickle.dump(self, f)\n\n self.params.save(os.path.join(self.save_path, \"parameters\"))","def save(self) -> None:\n self.saver.save_model_and_weights(self.model)\n self.saver.save_data_shuffle_indices(\n self.data.eval_shuffler.ds_inds\n )\n self.saver.save_input_scaler(self.data.x.scaler)","def save_output(self):\n # Auxiliary functions\n def intro(otype, suffix):\n self.logprint(\"Saving {}...\".format(otype))\n dirname = os.path.join(self.outpath,\\\n self.conf[\"output_prefix\"] + \"_files/{}\".format(suffix))\n if os.path.exists(dirname): # Overwrite existing output\n shutil.rmtree(dirname)\n os.makedirs(dirname)\n return(dirname)\n def save(obj, filename):\n try:\n f = open(filename, \"wb\")\n pickle.dump(obj, f)\n finally:\n f.close()\n def outro(otype): self.logprint(\"{} saved.\".format(otype).capitalize())\n # Saving output\n if self.conf[\"output_mode\"] >= 2: # Save all snapshot pops\n dirname = intro(\"snapshot populations\", \"populations/snapshots\")\n for n in xrange(self.conf[\"n_runs\"]):\n for m in xrange(self.conf[\"n_snapshots\"]):\n pop = self.runs[n].record[\"snapshot_pops\"][m]\n filename = dirname + \"/run{0}_s{1}.pop\".format(n,m)\n save(pop, filename)\n del self.runs[n].record[\"snapshot_pops\"]\n outro(\"snapshot populations\")\n if self.conf[\"output_mode\"] >= 1: # Save final populations\n dirname = intro(\"final populations\", \"populations/final\")\n for n in xrange(self.conf[\"n_runs\"]):\n pop = self.runs[n].record[\"final_pop\"]\n filename = dirname + \"/run{}.pop\".format(n)\n save(pop, filename)\n del self.runs[n].record[\"final_pop\"]\n outro(\"final populations\")\n if self.conf[\"output_mode\"] >= 0: # Save records\n dirname = intro(\"run records\", \"records\")\n for n in xrange(self.conf[\"n_runs\"]):\n rec = self.runs[n].record\n filename = dirname + \"/run{}.rec\".format(n)\n save(rec, filename)\n outro(\"run records\")","def save(self, path):\n\n if not os.path.exists(path):\n os.makedirs(path)\n\n np.save(os.path.join(path, 'V.npy'), self.V.cpu().numpy())\n\n if self.W is not None:\n np.save(os.path.join(path, 'W.npy'), self.W.cpu().numpy())\n\n if self.vb is not None:\n np.save(os.path.join(path, 'v_bias.npy'), self.vb.cpu().numpy())\n\n if self.wb is not None:\n np.save(os.path.join(path, 'w_bias.npy'), self.wb.cpu().numpy())\n\n if self.dictionary is not None:\n self.dictionary.save(os.path.join(path, 'dictionary'))","def save_model(self, filename):\n with open(filename + \".dil\", 'wb') as f:\n dill.dump(self.social_distancing_func, f)\n self.clear_social_distancing_func()\n with open(filename + \".pkl\", 'wb') as f:\n pickle.dump(self, f)","def save(self, path):\n \n # Save matrix\n with open(path, 'wb') as f:\n save_npz(f, self.matrix) \n # Save rows\n with open(path + '_rows', 'wb') as f:\n pickle.dump(self.rows, f)\n # Save columns\n with open(path + '_columns', 'wb') as f:\n pickle.dump(self.columns, f)","def to_pickle(self, filename, **kwargs):\n with open(filename, 'wb') as f:\n pickle.dump(self, f)","def save(self, fname, compression='blosc'):\n\n bo = {\n 'data': self.data.values,\n 'locs': self.locs,\n 'sessions': self.sessions,\n 'sample_rate': self.sample_rate,\n 'kurtosis': self.kurtosis,\n 'kurtosis_threshold' : self.kurtosis_threshold,\n 'meta': self.meta,\n 'date_created': self.date_created,\n 'minimum_voxel_size': self.minimum_voxel_size,\n 'maximum_voxel_size': self.maximum_voxel_size,\n 'label' : self.label,\n 'filter' : self.filter,\n }\n\n if fname[-3:] != '.bo':\n fname += '.bo'\n\n dd.io.save(fname, bo, compression=compression)","def pickle_files(filename, stuff):\n save_stuff = open(filename, \"wb\")\n pickle.dump(stuff, save_stuff)\n save_stuff.close()","def save(self, file_name):\n saved_data = { \"start_config\" : self.start_config, \"action_storage\" : self.action_storage } \n with open(file_name, 'wb') as fh:\n pickle.dump(saved_data, fh)","def save(self, uri):\r\n pf = PyFolder(os.path.dirname(os.path.realpath(uri)), allow_override=True)\r\n pf[os.path.basename(uri)+\"_options.json\"] = {\r\n 'input_cells': self._input_cells,\r\n 'latent_space': self._latent_space,\r\n }\r\n\r\n save_model(self._autoencoder, uri+\"_lstm_autoencoder.hdf5\")\r\n save_model(self._encoder, uri+\"_lstm_encoder.hdf5\")","def save(self, directory='saves/'):\n # Create dirpath for temporary dir\n if directory[-1] != '/':\n directory += '/'\n dirpath = directory + self.name + '/'\n\n if not os.path.exists(dirpath): \n os.makedirs(dirpath)\n else:\n raise Exception(f'Path {dirpath} already exists.')\n\n # DQNs & Optimizer\n torch.save(self.policy_net.state_dict(), f'{dirpath}dqn.pth')\n torch.save(self.optimizer.state_dict(), f'{dirpath}optimizer.pth')\n\n # Trainer pamameters\n params = {}\n for p in self.DEFAULT_VALUES.keys():\n params[p] = getattr(self, p)\n\n with open(f'{dirpath}trainer_parameters.pick', 'wb') as file:\n pickle.dump(params, file)\n\n # Zip the saves in one .zip archive\n zippath = f'{directory}{self.name}'\n shutil.make_archive(zippath, 'zip', dirpath)\n\n # Remove the directory dirpath and files inside\n shutil.rmtree(dirpath)\n\n # Display\n print(f'Model saved at {zippath}.zip')","def save(self, filename = 'array_zest', path = '/home/eric/dev/insitu/data/zs_recovery/'):\n filename = filename# + '_Lx_' + str(self.Lx) + 'm_Ly_' + str(self.Ly) + 'm'\n self.path_filename = path + filename + '.pkl'\n f = open(self.path_filename, 'wb')\n pickle.dump(self.__dict__, f, 2)\n f.close()","def save(self, filename='test'):\n file = open(filename+'.txt','w')\n pickle.dump(self, file)\n file.close()","def save_pickles(classes_count, entities, hierarchy_mapping, iter=''):\n # Save classes_count file\n classes_count_file = file(os.path.join(VisualGenome_PICKLES_PATH, iter + '_' + CLASSES_COUNT_FILE), 'wb')\n # Pickle classes_count\n cPickle.dump(classes_count, classes_count_file, protocol=cPickle.HIGHEST_PROTOCOL)\n # Close the file\n classes_count_file.close()\n # Save hierarchy_mapping file\n hierarchy_mapping_file = file(os.path.join(VisualGenome_PICKLES_PATH, iter + '_' + CLASSES_MAPPING_FILE), 'wb')\n # Pickle hierarchy_mapping\n cPickle.dump(hierarchy_mapping, hierarchy_mapping_file, protocol=cPickle.HIGHEST_PROTOCOL)\n # Close the file\n hierarchy_mapping_file.close()\n # Save entities list\n entities_file = file(os.path.join(VisualGenome_PICKLES_PATH, iter + '_' + ENTITIES_FILE), 'wb')\n # Pickle entities\n cPickle.dump(entities, entities_file, protocol=cPickle.HIGHEST_PROTOCOL)\n # Close the file\n entities_file.close()","def save(self, filename):\n with open(filename, \"wb\") as f:\n pkl.dump(self, f)","def save_matrixes(self):\n save_pickle('/home/rohanpaleja/PycharmProjects/bayesian_prolo/scheduling_env/additions_for_HRI/results', self.matrixes, str(self.num_schedules) + 'matrixes.pkl')","def save(data, filename):\r\n with open(filename, 'wb') as fp:\r\n pickle.dump(data, fp)","def save(self, path):\n pickle.dump(self, open(path, 'wb'))","def save(self, filename):\n with open(filename, 'wb') as f:\n pickle.dump({'wi': self.W_input_to_hidden, 'wo': self.W_hidden_to_output}, f)","def to_file(self, filename):\n\n output_dict = {'random_forest': self.random_forest,\n 'apply_preprocessing': self.apply_preprocessing,\n 'apply_postprocessing': self.apply_postprocessing}\n pickle.dump(output_dict, open(filename, \"wb\"))","def save(self):\n path = self.directory + \"/\" + self.filename\n pickle.dump(self.dictionary, open(path, 'wb'))\n self.context.console.append(\"The Fourier components are saved.\")","def save_reconstructions(reconstructions, out_dir):\n print(\"save reconstruction\")\n out_dir.mkdir(exist_ok=True)\n for fname, recons in reconstructions.items():\n print(\"fname\",fname)\n with h5py.File(out_dir / fname, 'w') as f:\n f.create_dataset('reconstruction', data=recons)","def save(self, datafile):\n with open(datafile,\"wb\") as f:\n cPickle.dump(self.D, f, cPickle.HIGHEST_PROTOCOL)\n upsname = datafile.replace(\".pickle\",\".dat\")\n print \"Saving to upsampled: \", self.D.shape\n self.D.tofile(upsname)"],"string":"[\n \"def pickle_data(self):\\n if 'data_sets.pckl' in self.expected_pickles:\\n to_file(\\n self.data_sets,\\n os.path.join(self.logdir, 'data_sets.pckl')\\n )\\n if 'all_params.pckl' in self.expected_pickles:\\n to_file(\\n self.all_params,\\n os.path.join(self.logdir, 'all_params.pckl')\\n )\\n if 'labels.pckl' in self.expected_pickles:\\n to_file(\\n self.labels,\\n os.path.join(self.logdir, 'labels.pckl')\\n )\\n if 'minimiser_info.pckl' in self.expected_pickles:\\n to_file(\\n self.minimiser_info,\\n os.path.join(self.logdir, 'minimiser_info.pckl')\\n )\",\n \"def pickle_dump_files():\\n with open('data/' + dataset_name + '_' + model_name + '_' + 'predictions', 'wb') as f:\\n pickle.dump(predictions, f)\\n with open('data/' + dataset_name + '_' + model_name + '_' + 'state_sentences', 'wb') as f:\\n pickle.dump(final_state_sentences, f)\\n with open('data/' + dataset_name + '_' + model_name + '_' + 'decoded_sentences', 'wb') as f:\\n pickle.dump(final_decoded_sentences, f)\\n with open('data/' + dataset_name + '_' + model_name + '_' + 'ids', 'wb') as f:\\n pickle.dump(idx, f)\\n with open('data/' + dataset_name + '_' + model_name + '_' + 'exemplars', 'wb') as f:\\n pickle.dump(exemplars, f)\\n with open('data/' + dataset_name + '_' + model_name + '_' + 'counter_exemplars', 'wb') as f:\\n pickle.dump(counter_exemplars, f)\\n with open('data/' + dataset_name + '_' + model_name + '_' + 'top_exemplar_words', 'wb') as f:\\n pickle.dump(top_exemplar_words, f)\\n with open('data/' + dataset_name + '_' + model_name + '_' + 'top_counter_exemplar_words', 'wb') as f:\\n pickle.dump(top_counter_exemplar_words, f)\",\n \"def save_to(self, save_path=\\\"./\\\", run_flag='', save_method=\\\"pickle\\\"):\\n # TODO: Finish the save_method parameters\\n time_stamp = self.time_stamp\\n time_stamp = self.time_stamp + \\\"_\\\" + run_flag\\n save_path = os.path.join(save_path, time_stamp)\\n\\n if not os.path.exists(save_path):\\n os.makedirs(save_path)\\n\\n if self.feature_importance_pool:\\n file_path = os.path.join(save_path, \\\"feature_importances.pkl\\\")\\n save_file(file_path, self.feature_importance_pool)\\n\\n if self.feature_importance_hist:\\n file_path = os.path.join(save_path, \\\"feature_importances_hist.png\\\")\\n save_file(file_path, self.feature_importance_hist[0])\\n\\n if self.area_under_curve_pool:\\n file_path = os.path.join(save_path, \\\"auc_fpr_tpr.pkl\\\")\\n save_file(file_path, self.area_under_curve_pool)\\n\\n if self.receiver_operating_characteristic_curve:\\n file_path = os.path.join(save_path, \\\"roc_curve.png\\\")\\n save_file(file_path, self.receiver_operating_characteristic_curve[0])\\n\\n if self.training_report_pool:\\n file_path = os.path.join(save_path, \\\"training_report.pkl\\\")\\n save_file(file_path, self.training_report_pool)\\n\\n if self.learning_line:\\n file_path = os.path.join(save_path, \\\"learning_curve.png\\\")\\n save_file(file_path, self.learning_line[0])\\n\\n file_path = os.path.join(save_path, time_stamp + \\\"_object.pkl\\\")\\n with open(file_path, 'wb') as opfh:\\n pickle.dump(self, opfh)\",\n \"def __save_datasets(self):\\n self.train.to_csv('{}/{}/{}'.format(path_to_train_set, img_format, 'train.csv'))\\n self.valid.to_csv('{}/{}/{}'.format(path_to_valid_set, img_format, 'valid.csv'))\\n self.test.to_csv('{}/{}/{}'.format(path_to_test_set, img_format, 'test.csv'))\",\n \"def saveSettings(self):\\n self.genFiles.applyData()\\n self.genGraph.applyData()\",\n \"def save_datasets(self):\\n if self.processed_extension == '.csv':\\n # Save to csv\\n logger.info(f'Saving sets to csv:')\\n \\n # TRAIN\\n logger.info(f'train: {self.train_path}')\\n \\n # Concatenate X and y\\n train_data = self.train_data[0]\\n train_data['TARGET'] = self.train_data[1]\\n \\n # Save as csv\\n train_data.to_csv(self.train_path, index = False)\\n \\n \\n # VAL\\n logger.info(f'val: {self.val_path}')\\n \\n # Concatenate X and y\\n val_data = self.val_data[0]\\n val_data['TARGET'] = self.val_data[1]\\n \\n # Save as csv\\n val_data.to_csv(self.val_path, index = False)\\n \\n # TEST\\n logger.info(f'test: {self.test_path}')\\n \\n # Concatenate X and y\\n test_data = self.test_data[0]\\n test_data['TARGET'] = self.test_data[1]\\n \\n # Save as csv\\n self.test_data.to_csv(self.test_path, index = False)\\n \\n elif self.processed_extension == '.npz':\\n # Convert y to numpy array\\n if isinstance(self.train_data[1], pd.Series):\\n self.train_data[1] = self.train_data[1].to_numpy()\\n if isinstance(self.val_data[1], pd.Series):\\n self.val_data[1] = self.val_data[1].to_numpy()\\n if isinstance(self.test_data[1], pd.Series):\\n self.test_data[1] = self.test_data[1].to_numpy()\\n \\n # Save to npz (scipy sparse)\\n logger.info(f'Saving sets to npz:')\\n\\n logger.info(f'train: {self.train_path}')\\n train_data = [self.train_data[0], np.reshape(self.train_data[1], (-1,1))]\\n sparse.save_npz(self.train_path, sparse.hstack(train_data))\\n \\n logger.info(f'val: {self.val_path}')\\n val_data = [self.val_data[0], np.reshape(self.val_data[1], (-1,1))]\\n sparse.save_npz(self.val_path, sparse.hstack(val_data))\\n\\n logger.info(f'test: {self.test_path}')\\n test_data = [self.test_data[0], np.reshape(self.test_data[1], (-1,1))]\\n sparse.save_npz(self.test_path, sparse.hstack(test_data))\\n\\n else:\\n raise AttributeError(f'Wrong extension: {self.processed_extension}')\\n \\n self.input_size = self.train_data[0].shape[1]\\n logger.info(f'Saved datasets.')\",\n \"def save(self, path, name):\\n if not self._frozen:\\n raise Exception(\\\"Dataset must be frozen\\\")\\n # create directory\\n pathlib.Path(os.path.join(path,name)).mkdir(parents=True, exist_ok=True)\\n self._raw_data.to_hdf(os.path.join(path,name,\\\"dataset.h5\\\"), key=\\\"raw_data\\\")\\n self._proc_data.to_hdf(os.path.join(path,name,\\\"dataset.h5\\\"), key=\\\"proc_data\\\")\\n np.save(os.path.join(path,name,\\\"_X_train.npy\\\"), self._X_train)\\n np.save(os.path.join(path,name,\\\"_X_test.npy\\\"), self._X_test)\\n np.save(os.path.join(path,name,\\\"_y_train.npy\\\"), self._y_train)\\n np.save(os.path.join(path,name,\\\"_y_test.npy\\\"), self._y_test)\\n \\n np.save(os.path.join(path,name,\\\"_X_mean.npy\\\"), self._X_mean)\\n np.save(os.path.join(path,name,\\\"_X_std.npy\\\"), self._X_std)\\n np.save(os.path.join(path,name,\\\"_y_mean.npy\\\"), self._y_mean)\\n np.save(os.path.join(path,name,\\\"_y_std.npy\\\"), self._y_std)\\n \\n with open(os.path.join(path,name,\\\"_seed.pkl\\\"), \\\"wb\\\") as fp: #Pickling\\n pickle.dump(self._seed, fp)\\n with open(os.path.join(path,name,\\\"_train_part.pkl\\\"), \\\"wb\\\") as fp: #Pickling\\n pickle.dump(self._train_part, fp)\\n with open(os.path.join(path,name,\\\"_test_part.pkl\\\"), \\\"wb\\\") as fp: #Pickling\\n pickle.dump(self._test_part, fp)\\n with open(os.path.join(path,name,\\\"_columns.pkl\\\"), \\\"wb\\\") as fp: #Pickling\\n pickle.dump(self._columns, fp)\",\n \"def save_all(cls, dirpath=\\\".\\\"):\\n for n, v in cls.__data.items():\\n pickle.dump(v, open(cls.dirpath + n + '.p', 'wb'))\\n print \\\"Data saved to: %s\\\" % dirpath\",\n \"def save(self):\\n pickle_save(self.results, 'results', self.main_dir)\",\n \"def save_inst(self):\\n self.sanity_check()\\n self.data_loaded_check()\\n\\n fname_pub_auth_all = ''.join([self.config.dir_data, '/',\\n self.config.fname_pub_auth_all, '_',\\n self.config.experiment_id, '.pk'])\\n fname_pub_auth_top = ''.join([self.config.dir_data, '/',\\n self.config.fname_pub_auth_top, '_',\\n self.config.experiment_id, '.pk'])\\n fname_pub_inst_all = ''.join([self.config.dir_data, '/',\\n self.config.fname_pub_inst_all, '_',\\n self.config.experiment_id, '.pk'])\\n fname_pub_inst_top = ''.join([self.config.dir_data, '/',\\n self.config.fname_pub_inst_top, '_',\\n self.config.experiment_id, '.pk'])\\n\\n pickle.dump(self.pub_auth_all, open(fname_pub_auth_all, 'wb'))\\n pickle.dump(self.pub_auth_top, open(fname_pub_auth_top, 'wb'))\\n pickle.dump(self.pub_inst_all, open(fname_pub_inst_all, 'wb'))\\n pickle.dump(self.pub_inst_top, open(fname_pub_inst_top, 'wb'))\\n\\n fname_pub_history = ''.join([self.config.dir_data, '/history_',\\n self.config.experiment_id, '.pk'])\\n pickle.dump(self.history, open(fname_pub_history, 'wb'))\\n\\n fname_pub_staff = ''.join([self.config.dir_data, '/staff_',\\n self.config.experiment_id, '.pk'])\\n pickle.dump(self.staff, open(fname_pub_staff, 'wb'))\",\n \"def save_data_pickle(self, save_full=False):\\n self.train.to_pickle('../input/train_mod.pkl')\\n self.test.to_pickle('../input/test_mod.pkl')\\n if save_full:\\n self.train_full.to_pickle('../input/train_full_mod.pkl')\",\n \"def save_outputs(self):\\n write_pickled(join(self.output_folder, \\\"results.pkl\\\"), self.get_results())\",\n \"def save_features_to_file(self):\\n if not os.path.exists(self.features_save_path):\\n os.makedirs(self.features_save_path)\\n for s in self.sets:\\n self.save_features_to_file_by_set(s)\",\n \"def save(self):\\n if self.loaded:\\n list_embeddingNames = [self.embeddings.vsm_name, self.synset_embeddings.vsm_name, self.imagined_embeddings.vsm_name]\\n full_file_name = self.resource_manager.get_multimodal_dataset(self.corpus, list_embeddingNames)\\n logging.info('Saving dataset to [%s]', full_file_name)\\n with lzma.open(full_file_name, 'wb') as f:\\n pickle.dump(self, f)\\n else:\\n logging.error('Dataset not loaded, call \\\"build\\\" method first!')\",\n \"def dumpme(self) :\\n fileName = \\\"./data/oP4_ModelBuilder.dump\\\"\\n with open(fileName,\\\"wb\\\") as dumpedFile:\\n oPickler = pickle.Pickler(dumpedFile)\\n oPickler.dump(self)\",\n \"def _dump_states(self, train=True):\\n\\t\\tprefix = self.config.experiment_dir_name+\\\"/datastreams/\\\"\\n\\t\\ttry:\\n\\t\\t\\tos.mkdir(prefix)\\n\\t\\texcept:\\n\\t\\t\\tpass\\n\\n\\t\\tprefix += \\\"{}.pickle\\\"\\n\\n\\t\\tif train:\\n\\t\\t\\tself.train_accuracy.dump(prefix.format(\\\"train_accuracy\\\"))\\n\\t\\t\\tself.train_epochs.dump(prefix.format(\\\"train_epochs\\\"))\\n\\t\\t\\tself.train_loss.dump(prefix.format(\\\"train_loss\\\"))\\n\\t\\t\\tself.train_confusion_matrix.dump(prefix.format(\\\"train_confusion_matrix\\\"))\\n\\t\\t\\tself.learning_rate.dump(prefix.format(\\\"learning_rate\\\"))\\n\\t\\telse:\\n\\t\\t\\tself.val_accuracy.dump(prefix.format(\\\"val_accuracy\\\"))\\n\\t\\t\\tself.val_epochs.dump(prefix.format(\\\"val_epochs\\\"))\\n\\t\\t\\tself.val_loss.dump(prefix.format(\\\"val_loss\\\"))\\n\\t\\t\\tself.val_confusion_matrix.dump(prefix.format(\\\"val_confusion_matrix\\\"))\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tSave dataset specific metadata into experiment dir\\n\\t\\t\\\"\\\"\\\"\\n\\t\\t# TODO: Redo this with more information from dataset meta.json file\\n\\t\\tmeta_path = self.config.experiment_dir_name+\\\"/meta.json\\\"\\n\\t\\t_meta = {}\\n\\t\\t_meta[\\\"classes\\\"] = self.classes\\n\\t\\t_meta[\\\"plot_platform\\\"] = self.config.plot_platform\\n\\t\\t# _meta[\\\"dataset_dir\\\"] = self.dataset.dataset_folder\\n\\t\\tif not os.path.exists(meta_path):\\n\\t\\t\\tfp = open(meta_path, \\\"w\\\")\\n\\t\\t\\tfp.write(json.dumps(_meta))\\n\\t\\t\\tfp.close()\",\n \"def _save(self, dataset, path, files, copy_files=False):\\n raise NotImplementedError('Loader {} does not support saving datasets.'.format(self.type()))\",\n \"def _save(self):\\n\\t\\t\\n\\t\\tdirectory = self.Output_path\\n\\n\\t\\t# replace with \\n\\t\\t# file_name = hermes.mk_themis_file_name(themis_obj = self)\\n\\t\\tfile_name = f'Themis_{self.CELL_ID[\\\"experiment\\\"]}_u{self.CELL_ID[\\\"unit\\\"]}_c{self.CELL_ID[\\\"cell\\\"]}_r{self.CELL_ID[\\\"run\\\"]}.pkl'\\n\\n\\t\\tsave_path = directory / file_name\\n\\n\\t\\t# Atomic saving (helpful?)\\n\\t\\ttemp_path = save_path.with_suffix(save_path.suffix + '.tmp')\\n\\t\\t\\n\\t\\tself.SavePath = save_path\\n\\n\\t\\t\\n\\t\\twith open(temp_path, 'wb') as f:\\n\\t\\t\\tpickle.dump(self, f)\\n\\n\\t\\ttemp_path.rename(save_path)\\n\\n\\t\\tprint(f'Saved {self.RUN_KEY} as {save_path}')\",\n \"def save(self, path=None):\\n data = self._collect_data()\\n\\n name = np.random.choice(['a', 'b', 'c', 'd', 'e', 'f']+list(map(str, range(0, 10))), size=8)\\n if path is None:\\n path = './logs/'+\\\"\\\".join(name)+'_'\\n with open(path, \\\"wb\\\") as f:\\n cloudpickle.dump(data, f)\\n print(\\\"Saved at {}\\\".format(path))\",\n \"def pickle(self,data,filename):\\n pickle.dump(data, open(filename, 'wb'))\",\n \"def save_configurations(self):\\n # Get the file path\\n self.data_path = self.data_path_entry.get()\\n # Open the file\\n with open(self.data_path, 'rb') as file:\\n self.log('Opened ' + str(self.data_path))\\n # Un-serialize\\n info = pickle.load(file)\\n # Write the new properties\\n self.main_window.overwrite_properties(info)\\n\\n self.exit()\",\n \"def save(self):\\n if self.loaded:\\n full_file_name = self.resource_manager.get_dataset(self.corpus, self.embeddings.vsm_name)\\n logging.info('Saving dataset to [%s]', full_file_name)\\n with lzma.open(full_file_name, 'wb') as f:\\n pickle.dump(self, f)\\n else:\\n logging.error('Dataset not loaded, call \\\"build\\\" method first!')\",\n \"def save(self, filename):\\n with open(filename, 'w') as f:\\n pickle.dump((self.components, self.mean), f)\",\n \"def save_data_pickle(PATH, data, dataset, filename):\\n with open(PATH + '/' + dataset + \\\"_\\\" + filename + \\\".pkl\\\",\\\"wb\\\") as f:\\n pickle.dump(data,f)\\n print(filename, \\\"created\\\")\",\n \"def save(self):\\n\\n # make a clone to preserve the original in case it's still needed\\n clone = {}\\n\\n for machine in self.activity.keys():\\n data = self.activity[machine].copy()\\n data[\\\"filtered activity\\\"] = np.array(data[\\\"filtered activity\\\"], dtype=np.float)\\n data[\\\"raw activity\\\"] = np.array(data[\\\"raw activity\\\"], dtype=np.float)\\n data[\\\"time\\\"] = np.array(data[\\\"time\\\"], dtype=np.float)\\n clone[machine] = data\\n\\n out = open(self.filename, \\\"wb\\\")\\n pickle.dump(clone, out)\\n out.close()\",\n \"def save(self):\\n pickle.dump(self, open(self.path, \\\"wb\\\"))\",\n \"def store(self):\\n\\t\\tprint(\\\"Storing to\\\", self.storagedir)\\n\\n\\t\\tfor filename in self.FILENAMES:\\n\\t\\t\\twith open(os.path.join(self.storagedir, filename), \\\"wb\\\") as handle:\\n\\t\\t\\t\\t_pickle.dump(getattr(self, filename), handle)\",\n \"def save(self, filename=\\\"matpipe.p\\\"):\\n temp_backend = self.learner.backend\\n self.learner._backend = self.learner.backend.fitted_pipeline_\\n for obj in [self, self.learner, self.reducer, self.cleaner,\\n self.autofeaturizer]:\\n obj._logger = None\\n with open(filename, 'wb') as f:\\n pickle.dump(self, f)\\n self.learner._backend = temp_backend\",\n \"def load_files(self):\\n print('Saving numpy mask arrays in {0}'.format(self.ProcDir))\\n\\n if not os.path.isdir(self.ProcDir): os.mkdir(self.ProcDir)\\n if not os.path.isdir(self.OutDir): os.mkdir(self.OutDir)\\n\\n self.Files = {}\\n for ig in self.Set:\\n phase = roipy.tools.load_half(ig,2)\\n # convert wavelength to displacements\\n # NOTE: make attributes of commonly used values in rsc: float(ig.Rsc['WAVELENGTH'])\\n disp = phase * (ig.Wavelength / (4*np.pi))\\n igram = ma.array(disp, mask=ma.nomask)\\n name = self.save_ma(ig, igram) #Mask_ array is just zeros at this point..\\n self.Files[ig.ID] = name\\n\\n print('load_files() complete: {0} interferograms'.format(self.Set.Nig))\",\n \"def save(self, path: utils.URLPath):\\n save_somclassifier_config(self.config, path / \\\"config.json\\\")\\n self.model.save(str(path / \\\"model.h5\\\"))\\n io_functions.save_joblib(self.binarizer, path / \\\"binarizer.joblib\\\")\\n\\n io_functions.save_json(self.data_ids[\\\"validation\\\"], path / \\\"ids_validate.json\\\")\\n io_functions.save_json(self.data_ids[\\\"train\\\"], path / \\\"ids_train.json\\\")\",\n \"def dump(self, model_path):\\n pickle.dump(self.scaler, gzip.open(os.path.join(model_path, 'scaler.pkl.gz'), 'w'),\\n protocol=pickle.HIGHEST_PROTOCOL)\\n# pickle.dump(self.mapper, gzip.open(os.path.join(model_path, 'mapper.pkl.gz'),'w'),\\n# protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(self.batcher, gzip.open(os.path.join(model_path, 'batcher.pkl.gz'), 'w'),\\n protocol=pickle.HIGHEST_PROTOCOL)\",\n \"def save(self, folder):\\n self.generator.save_weights('%s/generator.h5'%folder)\\n self.critic.save_weights('%s/critic.h5'%folder)\",\n \"def save(self):\\n #--Data file exists?\\n filePath = self.path\\n if os.path.exists(filePath):\\n ins = open(filePath)\\n outData = compat.uncpickle(ins)\\n ins.close()\\n #--Delete some data?\\n for key in self.deleted:\\n if key in outData:\\n del outData[key]\\n else:\\n outData = {}\\n #--Write touched data\\n for key in self.changed:\\n outData[key] = self.data[key]\\n #--Pickle it\\n tempPath = filePath+'.tmp'\\n cPickle.dump(outData,open(tempPath,'w'))\\n renameFile(tempPath,filePath,True)\",\n \"def save(self):\\n\\n # TODO:Find place to save data, write logic to save images(Filter out video?)\",\n \"def save(self):\\n if self.hasChanged:\\n filePath = self.path\\n tempPath = filePath+'.tmp'\\n fileDir = os.path.split(filePath)[0]\\n if not os.path.exists(fileDir): os.makedirs(fileDir)\\n cPickle.dump(self.data,open(tempPath,'w'))\\n renameFile(tempPath,filePath,True)\\n self.hasChanged = False\",\n \"def save(self, path):\\n torch.save(\\n {\\n \\\"input_dimension\\\": self.input_dimension,\\n \\\"quantiles\\\": self.quantiles,\\n \\\"width\\\": self.width,\\n \\\"depth\\\": self.depth,\\n \\\"activation\\\": self.activation,\\n \\\"network_state\\\": self.state_dict(),\\n \\\"optimizer_state\\\": self.optimizer.state_dict(),\\n },\\n path,\\n )\",\n \"def _save(self):\\n # TODO: Use local.punny dump (when written)\\n with open(filename, 'w') as f:\\n pickle = Pickler(f)\\n pickle.dump(self.pungen.puns)\",\n \"def save_data_to_disk(self):\\n Omega_M = self.theta_fid[0]\\n for key in self.data.keys():\\n np.save(f'./preloaded_data/{Omega_M}_{self.delta_theta[0]}_{key}.npy', self.data[key])\",\n \"def __savePreProcessedData(self):\\n np.savetxt(self.X_filename, self.X, delimiter=',')\\n np.savetxt(self.y_filename, self.le.fit_transform(self.y), delimiter=',')\\n #Need to save the label Enconder to inverse transform later\\n joblib.dump(self.le, self.le_filename)\\n\\n print(\\\"Saved X and y\\\")\",\n \"def save(self, save_dir='models'):\\n with open(os.path.join(save_dir, 'model_expert_predictor.pkl'), 'wb') as f:\\n pickle.dump(self.model, f)\\n with open(os.path.join(save_dir, 'vectorizer_expert_predictor.pkl'), 'wb') as f:\\n pickle.dump(self.vectorizer, f)\\n with open(os.path.join(save_dir, 'userid2name.pkl'), 'wb') as f:\\n pickle.dump(self.userid2name, f)\\n with open(os.path.join(save_dir, 'name2userid.pkl'), 'wb') as f:\\n pickle.dump(self.name2userid, f)\",\n \"def save(self, dirpath, data=False):\\n if not data:\\n self.data = None\\n self.graphs = None\\n\\n if self.annotator is not None:\\n self.annotator.save(dirpath, data=data)\\n self.annotator = None\\n\\n super().save(join(dirpath, 'batch.pkl'))\",\n \"def _save_data(self, filename):\\n if not os.path.isdir(os.path.dirname(filename)):\\n return False\\n with open(filename, 'w') as f:\\n f.truncate()\\n pickle.dump({\\n 'user_data': self.user_data,\\n 'api_data': self.api_data,\\n 'profiles': self.profiles\\n }, f)\",\n \"def dump_data(self,filename,dump_id):\\n import pickle\\n from Auxiliary import tdc_Filenames\\n data = [ d.get_pure_data_copy() for d in self.plotter.data ]\\n dump_dict={}\\n dump_dict['fft_data'] = data\\n dump_dict['fitting_type'] = self.fft_fit.type \\n dump_dict['nk_plot'] = self.fft_fit.nk_plot\\n # full file name of the file with manipulator dump\\n filename=tdc_Filenames.get_full_vis_filename(dump_id, filename+'.pickle')\\n pickle.dump( dump_dict, open(filename,'w') )\\n print '\\\\nContent dumped in \\\"%s\\\" \\\\n' % filename\",\n \"def save_reconstructions(reconstructions, out_dir):\\n if (not (os.path.exists(out_dir))):\\n os.mkdir(out_dir)\\n out_dir.mkdir(exist_ok=True)\\n print('Saved directory is',out_dir)\\n for fname, recons in reconstructions.items():\\n with h5py.File(out_dir / fname, 'w') as f:\\n f.create_dataset('reconstruction', data=recons)\",\n \"def save(self, filepath):\\n save_ckpt = {\\n 'ae': self.state_dict(),\\n 'optimizer': self.optimizer.state_dict()\\n }\\n try:\\n torch.save(save_ckpt, os.path.join(filepath, 'ckpt_ae.pth'))\\n except:\\n print('Cannot save autoencoder.')\",\n \"def SaveDecoderAndData(clf, X, X_not_scaled, y, subjID):\\n time_to_save = datetime.datetime.now().isoformat()\\n time_to_save = time_to_save.replace('T','-')\\n time_to_save = time_to_save.replace(':','-')\\n \\n model = clf\\n model_file = 'Models/' + subjID + '_MI_classifier_' + time_to_save[:19] + '.sav'\\n pickle.dump(model, open(model_file, 'wb'))\\n \\n filepath_export_data = 'Models/' + subjID + '_data_for_MI_classifier_' + time_to_save[:19] + '.npz'\\n np.savez_compressed(filepath_export_data, subjID=subjID, X=X, X_not_scaled=X_not_scaled, y=y)\",\n \"def save_object(self, filename, data):\\n with open(filename, 'wb') as outp: # Overwrites any existing file.\\n pickle.dump(data, outp, pickle.HIGHEST_PROTOCOL)\",\n \"def save(self, filename, **kwargs):\\n with open(filename, 'wb') as fin:\\n pickle.dump(self, fin, **kwargs)\",\n \"def save_data_file(self):\\n with open(self.files['data'], 'w') as outfile:\\n outfile.write(self.to_json())\\n outfile.close()\",\n \"def save(self):\\n for p, c in self.configs_:\\n c.write(p)\",\n \"def serialize(self):\\n output_dir = self.settings.output_dir\\n # Remove previous high performers\\n best = os.path.join(output_dir, 'best')\\n if os.path.exists(best):\\n shutil.rmtree(best)\\n if not os.path.exists(best):\\n os.mkdir(best)\\n\\n # update this instance to match the the state handler\\n self.pareto_frontier = self.state.pareto_frontier\\n\\n # Get high performing population\\n population = self.pareto_frontier.datadict.serialize(self.settings.output_dir)\\n paths = []\\n\\n # update the paths to save to and write them to file\\n for individual in population:\\n metrics = individual.get('metrics')\\n if metrics is not None:\\n out = ''\\n for key, item in metrics.items():\\n assert not isinstance(item, dict)\\n out += f'{key}_{item}_'\\n uuid = individual.get('uuid')\\n out_path = os.path.join(output_dir, 'best', f'{out}uuid_{uuid}.yml')\\n if self.running_tests:\\n paths.append(out_path)\\n if not self.running_tests:\\n with open(out_path, 'w') as f:\\n yaml.dump(individual, f)\\n\\n # plot state\\n if not self.running_tests and population is not None and len(population) > 0:\\n self.pareto_frontier.plot()\\n\\n # For testing\\n if self.running_tests:\\n basenames = [os.path.basename(p) for p in paths]\\n print(basenames)\",\n \"def save(self, path):\\n individual = self.population.fittest_individual()\\n order = [int(l) for l in individual.label_order]\\n fitness = individual.fitness\\n data = {'name': self.ds.name,\\n 'num_labels': len(order),\\n 'order': order,\\n 'fitness': fitness\\n }\\n with open(path, 'w') as f:\\n json.dump(data, f)\",\n \"def save(self):\\n joblib.dump(\\n self.classifier, \\\"data/models/repeatsfinder/repeatsfinder.joblib\\\",\\n )\",\n \"def to_pickle(self, filename, **kwargs):\\n\\n self._check_is_fitted()\\n\\n return dump(self, filename, **kwargs)\",\n \"def save_dataset(self):\\n if os.path.exists(self.output_path):\\n print('Directory already exists. EXITING.')\\n sys.exit()\\n if not os.path.exists(self.output_path): os.mkdir(self.output_path)\\n for window_num, cur_window in enumerate(self.time_windows):\\n window_dir = (os.path.join(self.output_path, ('window %s' % str(window_num + 1))))\\n if not os.path.exists(window_dir): os.mkdir(window_dir)\\n for filepath in cur_window:\\n topic = os.path.basename(os.path.dirname(filepath))\\n topic_dir = os.path.join(os.path.join(window_dir, topic))\\n if not os.path.exists(topic_dir): os.mkdir(topic_dir)\\n copy(filepath, topic_dir)\\n self.ground_truth.append((len(os.listdir(window_dir))))\",\n \"def save_as(self, filename: str) -> None:\\n save_data = lzma.compress(pickle.dumps(self))\\n with open(filename, \\\"wb\\\") as f:\\n f.write(save_data)\",\n \"def _pickle_path(self) -> Path:\\r\\n return self.output_path / \\\"pickles\\\"\",\n \"def dump_me(self, fileName=None) :\\n if fileName is None :\\n fileName = \\\"./data/oP4_ModelBuilder.dump\\\"\\n else :\\n pass\\n with open(fileName,\\\"wb\\\") as dumpedFile:\\n oPickler = pickle.Pickler(dumpedFile)\\n oPickler.dump(self)\",\n \"def save_synthetic_data(data):\\n \\n pickle_object = FM().data_file\\n with pickle_object.open('wb') as data_file:\\n pickle.dump(data, data_file)\",\n \"def save_pickle(self, path):\\n with open(path, 'wb') as f:\\n pickle.dump(self, f, protocol=pickle.HIGHEST_PROTOCOL)\",\n \"def save(self, filename: str):\\n if os.path.isfile(filename):\\n raise FileExistsError(\\\"Target file exists\\\")\\n\\n with open(filename, \\\"wb\\\") as binary_writer:\\n pickle.dump([self.gene_sets, self.gene_set_size, self.gene_set_names,\\n self.interactors, self.n_curated, self.n_interactors],\\n binary_writer)\",\n \"def save(self, filename):\\n with gzip.open(filename, \\\"w\\\") as f:\\n f.write(pickle.dumps(self))\",\n \"def save(self, path):\\n print(\\\"Warning: Default save used\\\")\\n with open(path, 'wb') as f:\\n pickle.dump(self, f)\",\n \"def _save(self, data: np.ndarray) -> None:\\n ...\",\n \"def save(self,filename): \\n with open(filename, 'wb') as f:\\n pickle.dump(self,f)\",\n \"def save(self, folder):\\n if not path.exists(folder):\\n os.makedirs(folder)\\n param = {\\n \\\"model\\\": self.__class__.__name__,\\n \\\"nr_labels\\\": self.nr_labels,\\n \\\"nr_features\\\": self.nr_features,\\n \\\"nr_codes\\\": self.nr_codes,\\n \\\"bias\\\": self.bias,\\n \\\"pred_kwargs\\\": self.pred_params.to_dict(),\\n }\\n param = self.append_meta(param)\\n with open(\\\"{}/param.json\\\".format(folder), \\\"w\\\") as f:\\n f.write(json.dumps(param, indent=True))\\n smat_util.save_matrix(\\\"{}/W.npz\\\".format(folder), self.W)\\n smat_util.save_matrix(\\\"{}/C.npz\\\".format(folder), self.C)\",\n \"def save(self,filename):\\n with open(filename,'wb') as f:\\n pickle.dump(self,f)\",\n \"def _save_data(self):\\n self.data.to_csv('data/c&le/{}'.format(self.name))\",\n \"def save_reaction(self, filename):\\n filename = filename.replace('.pkl', '.gpkl')\\n filename = filename.replace('.bpkl', '.gpkl')\\n # Overwrites any existing file.\\n with gzip.GzipFile(filename, 'wb') as output:\\n pickle.dump(self, output, pickle.HIGHEST_PROTOCOL)\",\n \"def save(self):\\n data = (\\n self.Joints,\\n self.Links,\\n self.joint_syms,\\n self.global_syms,\\n self.name,\\n self.sym_prefix,\\n )\\n cloudpickle.dump(data, open(self.save_filename, \\\"wb\\\"))\",\n \"def _save_data(self, data):\\n path = os.path.join(self._cache_path, '%s.data' % self._name)\\n\\n f = bz2.BZ2File(path, 'w')\\n f.write(pickle.dumps(data))\\n f.close()\",\n \"def saveSettings(self):\\n helpers.saveFile(self.dataDir, self.settingsFilename, json.dumps(self.settings))\",\n \"def store(self, filename):\",\n \"def save_pickle(self, filename):\\n x, y, _ = self.get_coords_enu()\\n cx, cy = self.get_centres_enu()\\n coords = dict(x=x, y=y, cx=cx, cy=cy)\\n pickle.dump(coords, open(filename, 'wb'))\",\n \"def save(self, file):\\n if isinstance(file, basestring):\\n with open(file, \\\"wb\\\") as file:\\n self.save(file)\\n else:\\n to_save = (self.model, self.features, self.labels)\\n dump(to_save, file, HIGHEST_PICKLE_PROTOCOL)\",\n \"def save_data_all(interpolated_acti, norm_acti, smoothed_acti, flag_roi, roi_tensor, meta_df, animal, arguments):\\r\\n\\r\\n\\tconfiguration = pd.DataFrame(arguments, index=[0])\\r\\n\\t\\r\\n\\tpath = os.path.join(paths.path2Output, animal, 'Preprocessed Data')\\r\\n\\ttry:\\r\\n\\t os.makedirs(path)\\r\\n\\texcept:\\r\\n\\t FileExistsError\\r\\n\\t\\r\\n\\tconfiguration.to_csv(os.path.join(path, 'configuration.csv'))\\r\\n\\tnp.save(os.path.join(path, 'acti'), interpolated_acti)\\r\\n\\tnp.save(os.path.join(path, 'norm_acti'), norm_acti)\\r\\n\\tnp.save(os.path.join(path, 'smoothed_acti'), smoothed_acti)\\r\\n\\tnp.save(os.path.join(path,'flag_roi'), flag_roi)\\r\\n\\tnp.save(os.path.join(path,'roi_tensor'), roi_tensor)\\r\\n\\tmeta_df.to_csv(os.path.join(path, 'meta_df.csv'))\",\n \"def save(self):\\n with open(os.path.join(self.save_path, \\\"experiment.delira.pkl\\\"),\\n \\\"wb\\\") as f:\\n pickle.dump(self, f)\\n\\n self.params.save(os.path.join(self.save_path, \\\"parameters\\\"))\",\n \"def save(self) -> None:\\n self.saver.save_model_and_weights(self.model)\\n self.saver.save_data_shuffle_indices(\\n self.data.eval_shuffler.ds_inds\\n )\\n self.saver.save_input_scaler(self.data.x.scaler)\",\n \"def save_output(self):\\n # Auxiliary functions\\n def intro(otype, suffix):\\n self.logprint(\\\"Saving {}...\\\".format(otype))\\n dirname = os.path.join(self.outpath,\\\\\\n self.conf[\\\"output_prefix\\\"] + \\\"_files/{}\\\".format(suffix))\\n if os.path.exists(dirname): # Overwrite existing output\\n shutil.rmtree(dirname)\\n os.makedirs(dirname)\\n return(dirname)\\n def save(obj, filename):\\n try:\\n f = open(filename, \\\"wb\\\")\\n pickle.dump(obj, f)\\n finally:\\n f.close()\\n def outro(otype): self.logprint(\\\"{} saved.\\\".format(otype).capitalize())\\n # Saving output\\n if self.conf[\\\"output_mode\\\"] >= 2: # Save all snapshot pops\\n dirname = intro(\\\"snapshot populations\\\", \\\"populations/snapshots\\\")\\n for n in xrange(self.conf[\\\"n_runs\\\"]):\\n for m in xrange(self.conf[\\\"n_snapshots\\\"]):\\n pop = self.runs[n].record[\\\"snapshot_pops\\\"][m]\\n filename = dirname + \\\"/run{0}_s{1}.pop\\\".format(n,m)\\n save(pop, filename)\\n del self.runs[n].record[\\\"snapshot_pops\\\"]\\n outro(\\\"snapshot populations\\\")\\n if self.conf[\\\"output_mode\\\"] >= 1: # Save final populations\\n dirname = intro(\\\"final populations\\\", \\\"populations/final\\\")\\n for n in xrange(self.conf[\\\"n_runs\\\"]):\\n pop = self.runs[n].record[\\\"final_pop\\\"]\\n filename = dirname + \\\"/run{}.pop\\\".format(n)\\n save(pop, filename)\\n del self.runs[n].record[\\\"final_pop\\\"]\\n outro(\\\"final populations\\\")\\n if self.conf[\\\"output_mode\\\"] >= 0: # Save records\\n dirname = intro(\\\"run records\\\", \\\"records\\\")\\n for n in xrange(self.conf[\\\"n_runs\\\"]):\\n rec = self.runs[n].record\\n filename = dirname + \\\"/run{}.rec\\\".format(n)\\n save(rec, filename)\\n outro(\\\"run records\\\")\",\n \"def save(self, path):\\n\\n if not os.path.exists(path):\\n os.makedirs(path)\\n\\n np.save(os.path.join(path, 'V.npy'), self.V.cpu().numpy())\\n\\n if self.W is not None:\\n np.save(os.path.join(path, 'W.npy'), self.W.cpu().numpy())\\n\\n if self.vb is not None:\\n np.save(os.path.join(path, 'v_bias.npy'), self.vb.cpu().numpy())\\n\\n if self.wb is not None:\\n np.save(os.path.join(path, 'w_bias.npy'), self.wb.cpu().numpy())\\n\\n if self.dictionary is not None:\\n self.dictionary.save(os.path.join(path, 'dictionary'))\",\n \"def save_model(self, filename):\\n with open(filename + \\\".dil\\\", 'wb') as f:\\n dill.dump(self.social_distancing_func, f)\\n self.clear_social_distancing_func()\\n with open(filename + \\\".pkl\\\", 'wb') as f:\\n pickle.dump(self, f)\",\n \"def save(self, path):\\n \\n # Save matrix\\n with open(path, 'wb') as f:\\n save_npz(f, self.matrix) \\n # Save rows\\n with open(path + '_rows', 'wb') as f:\\n pickle.dump(self.rows, f)\\n # Save columns\\n with open(path + '_columns', 'wb') as f:\\n pickle.dump(self.columns, f)\",\n \"def to_pickle(self, filename, **kwargs):\\n with open(filename, 'wb') as f:\\n pickle.dump(self, f)\",\n \"def save(self, fname, compression='blosc'):\\n\\n bo = {\\n 'data': self.data.values,\\n 'locs': self.locs,\\n 'sessions': self.sessions,\\n 'sample_rate': self.sample_rate,\\n 'kurtosis': self.kurtosis,\\n 'kurtosis_threshold' : self.kurtosis_threshold,\\n 'meta': self.meta,\\n 'date_created': self.date_created,\\n 'minimum_voxel_size': self.minimum_voxel_size,\\n 'maximum_voxel_size': self.maximum_voxel_size,\\n 'label' : self.label,\\n 'filter' : self.filter,\\n }\\n\\n if fname[-3:] != '.bo':\\n fname += '.bo'\\n\\n dd.io.save(fname, bo, compression=compression)\",\n \"def pickle_files(filename, stuff):\\n save_stuff = open(filename, \\\"wb\\\")\\n pickle.dump(stuff, save_stuff)\\n save_stuff.close()\",\n \"def save(self, file_name):\\n saved_data = { \\\"start_config\\\" : self.start_config, \\\"action_storage\\\" : self.action_storage } \\n with open(file_name, 'wb') as fh:\\n pickle.dump(saved_data, fh)\",\n \"def save(self, uri):\\r\\n pf = PyFolder(os.path.dirname(os.path.realpath(uri)), allow_override=True)\\r\\n pf[os.path.basename(uri)+\\\"_options.json\\\"] = {\\r\\n 'input_cells': self._input_cells,\\r\\n 'latent_space': self._latent_space,\\r\\n }\\r\\n\\r\\n save_model(self._autoencoder, uri+\\\"_lstm_autoencoder.hdf5\\\")\\r\\n save_model(self._encoder, uri+\\\"_lstm_encoder.hdf5\\\")\",\n \"def save(self, directory='saves/'):\\n # Create dirpath for temporary dir\\n if directory[-1] != '/':\\n directory += '/'\\n dirpath = directory + self.name + '/'\\n\\n if not os.path.exists(dirpath): \\n os.makedirs(dirpath)\\n else:\\n raise Exception(f'Path {dirpath} already exists.')\\n\\n # DQNs & Optimizer\\n torch.save(self.policy_net.state_dict(), f'{dirpath}dqn.pth')\\n torch.save(self.optimizer.state_dict(), f'{dirpath}optimizer.pth')\\n\\n # Trainer pamameters\\n params = {}\\n for p in self.DEFAULT_VALUES.keys():\\n params[p] = getattr(self, p)\\n\\n with open(f'{dirpath}trainer_parameters.pick', 'wb') as file:\\n pickle.dump(params, file)\\n\\n # Zip the saves in one .zip archive\\n zippath = f'{directory}{self.name}'\\n shutil.make_archive(zippath, 'zip', dirpath)\\n\\n # Remove the directory dirpath and files inside\\n shutil.rmtree(dirpath)\\n\\n # Display\\n print(f'Model saved at {zippath}.zip')\",\n \"def save(self, filename = 'array_zest', path = '/home/eric/dev/insitu/data/zs_recovery/'):\\n filename = filename# + '_Lx_' + str(self.Lx) + 'm_Ly_' + str(self.Ly) + 'm'\\n self.path_filename = path + filename + '.pkl'\\n f = open(self.path_filename, 'wb')\\n pickle.dump(self.__dict__, f, 2)\\n f.close()\",\n \"def save(self, filename='test'):\\n file = open(filename+'.txt','w')\\n pickle.dump(self, file)\\n file.close()\",\n \"def save_pickles(classes_count, entities, hierarchy_mapping, iter=''):\\n # Save classes_count file\\n classes_count_file = file(os.path.join(VisualGenome_PICKLES_PATH, iter + '_' + CLASSES_COUNT_FILE), 'wb')\\n # Pickle classes_count\\n cPickle.dump(classes_count, classes_count_file, protocol=cPickle.HIGHEST_PROTOCOL)\\n # Close the file\\n classes_count_file.close()\\n # Save hierarchy_mapping file\\n hierarchy_mapping_file = file(os.path.join(VisualGenome_PICKLES_PATH, iter + '_' + CLASSES_MAPPING_FILE), 'wb')\\n # Pickle hierarchy_mapping\\n cPickle.dump(hierarchy_mapping, hierarchy_mapping_file, protocol=cPickle.HIGHEST_PROTOCOL)\\n # Close the file\\n hierarchy_mapping_file.close()\\n # Save entities list\\n entities_file = file(os.path.join(VisualGenome_PICKLES_PATH, iter + '_' + ENTITIES_FILE), 'wb')\\n # Pickle entities\\n cPickle.dump(entities, entities_file, protocol=cPickle.HIGHEST_PROTOCOL)\\n # Close the file\\n entities_file.close()\",\n \"def save(self, filename):\\n with open(filename, \\\"wb\\\") as f:\\n pkl.dump(self, f)\",\n \"def save_matrixes(self):\\n save_pickle('/home/rohanpaleja/PycharmProjects/bayesian_prolo/scheduling_env/additions_for_HRI/results', self.matrixes, str(self.num_schedules) + 'matrixes.pkl')\",\n \"def save(data, filename):\\r\\n with open(filename, 'wb') as fp:\\r\\n pickle.dump(data, fp)\",\n \"def save(self, path):\\n pickle.dump(self, open(path, 'wb'))\",\n \"def save(self, filename):\\n with open(filename, 'wb') as f:\\n pickle.dump({'wi': self.W_input_to_hidden, 'wo': self.W_hidden_to_output}, f)\",\n \"def to_file(self, filename):\\n\\n output_dict = {'random_forest': self.random_forest,\\n 'apply_preprocessing': self.apply_preprocessing,\\n 'apply_postprocessing': self.apply_postprocessing}\\n pickle.dump(output_dict, open(filename, \\\"wb\\\"))\",\n \"def save(self):\\n path = self.directory + \\\"/\\\" + self.filename\\n pickle.dump(self.dictionary, open(path, 'wb'))\\n self.context.console.append(\\\"The Fourier components are saved.\\\")\",\n \"def save_reconstructions(reconstructions, out_dir):\\n print(\\\"save reconstruction\\\")\\n out_dir.mkdir(exist_ok=True)\\n for fname, recons in reconstructions.items():\\n print(\\\"fname\\\",fname)\\n with h5py.File(out_dir / fname, 'w') as f:\\n f.create_dataset('reconstruction', data=recons)\",\n \"def save(self, datafile):\\n with open(datafile,\\\"wb\\\") as f:\\n cPickle.dump(self.D, f, cPickle.HIGHEST_PROTOCOL)\\n upsname = datafile.replace(\\\".pickle\\\",\\\".dat\\\")\\n print \\\"Saving to upsampled: \\\", self.D.shape\\n self.D.tofile(upsname)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71841556","0.7051201","0.6999294","0.69657177","0.6965532","0.67290497","0.6701712","0.67006266","0.66806704","0.6629543","0.662331","0.66160923","0.6615659","0.66139543","0.659722","0.65589774","0.65515673","0.65493506","0.6524547","0.64821887","0.6479978","0.6473524","0.64637905","0.64386934","0.6420897","0.6402101","0.6381964","0.6371142","0.63617325","0.6352685","0.6351002","0.6341174","0.63183576","0.62927336","0.62907106","0.62885725","0.6277695","0.6260886","0.6258338","0.6257215","0.6255259","0.6241757","0.6226357","0.6218445","0.62176","0.6214613","0.62129956","0.62125194","0.62008274","0.6186317","0.61798036","0.61762136","0.61704576","0.6170113","0.61682266","0.61560416","0.6154977","0.614537","0.6143835","0.614133","0.6139838","0.6139598","0.6137987","0.6123586","0.6121997","0.6119068","0.61112654","0.6106832","0.61023307","0.6097476","0.6092224","0.60920733","0.6090411","0.6088493","0.60884166","0.6087783","0.60863024","0.6084501","0.6081691","0.60786915","0.6076789","0.60739905","0.6073189","0.60730064","0.60714453","0.60707873","0.6067948","0.60662293","0.60613793","0.60613793","0.6058554","0.60571903","0.6054755","0.60517627","0.60515445","0.60492647","0.60471135","0.6036982","0.60350376","0.6027523"],"string":"[\n \"0.71841556\",\n \"0.7051201\",\n \"0.6999294\",\n \"0.69657177\",\n \"0.6965532\",\n \"0.67290497\",\n \"0.6701712\",\n \"0.67006266\",\n \"0.66806704\",\n \"0.6629543\",\n \"0.662331\",\n \"0.66160923\",\n \"0.6615659\",\n \"0.66139543\",\n \"0.659722\",\n \"0.65589774\",\n \"0.65515673\",\n \"0.65493506\",\n \"0.6524547\",\n \"0.64821887\",\n \"0.6479978\",\n \"0.6473524\",\n \"0.64637905\",\n \"0.64386934\",\n \"0.6420897\",\n \"0.6402101\",\n \"0.6381964\",\n \"0.6371142\",\n \"0.63617325\",\n \"0.6352685\",\n \"0.6351002\",\n \"0.6341174\",\n \"0.63183576\",\n \"0.62927336\",\n \"0.62907106\",\n \"0.62885725\",\n \"0.6277695\",\n \"0.6260886\",\n \"0.6258338\",\n \"0.6257215\",\n \"0.6255259\",\n \"0.6241757\",\n \"0.6226357\",\n \"0.6218445\",\n \"0.62176\",\n \"0.6214613\",\n \"0.62129956\",\n \"0.62125194\",\n \"0.62008274\",\n \"0.6186317\",\n \"0.61798036\",\n \"0.61762136\",\n \"0.61704576\",\n \"0.6170113\",\n \"0.61682266\",\n \"0.61560416\",\n \"0.6154977\",\n \"0.614537\",\n \"0.6143835\",\n \"0.614133\",\n \"0.6139838\",\n \"0.6139598\",\n \"0.6137987\",\n \"0.6123586\",\n \"0.6121997\",\n \"0.6119068\",\n \"0.61112654\",\n \"0.6106832\",\n \"0.61023307\",\n \"0.6097476\",\n \"0.6092224\",\n \"0.60920733\",\n \"0.6090411\",\n \"0.6088493\",\n \"0.60884166\",\n \"0.6087783\",\n \"0.60863024\",\n \"0.6084501\",\n \"0.6081691\",\n \"0.60786915\",\n \"0.6076789\",\n \"0.60739905\",\n \"0.6073189\",\n \"0.60730064\",\n \"0.60714453\",\n \"0.60707873\",\n \"0.6067948\",\n \"0.60662293\",\n \"0.60613793\",\n \"0.60613793\",\n \"0.6058554\",\n \"0.60571903\",\n \"0.6054755\",\n \"0.60517627\",\n \"0.60515445\",\n \"0.60492647\",\n \"0.60471135\",\n \"0.6036982\",\n \"0.60350376\",\n \"0.6027523\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7810631"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":25993,"cells":{"query":{"kind":"string","value":"Initializes pythontwitter wrapper with the Twitter API credentials"},"document":{"kind":"string","value":"def __init__(self):\n self.api = Api(consumer_key=credentials[\"consumer_key\"],\n consumer_secret=credentials[\"consumer_secret\"],\n access_token_key=credentials[\"access_token_key\"],\n access_token_secret=credentials[\"access_token_secret\"])"},"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 setup_twitter():\n auth = tweepy.OAuthHandler(credentials[\"twitter\"][\"consumer_key\"], credentials[\"twitter\"][\"consumer_secret\"])\n auth.set_access_token(credentials[\"twitter\"][\"access_token\"], credentials[\"twitter\"][\"access_token_secret\"])\n return tweepy.API(auth)","def __init__(self):\n # keys and tokens from the Twitter Dev Console\n key = provide_keys('males')\n\n consumer_key = key['consumer_key']\n consumer_secret = key['consumer_secret']\n access_token = key['access_token_key']\n access_token_secret = key['access_token_secret']\n\n # attempt authentication\n\n # create OAuthHandler object\n self.auth = OAuthHandler(consumer_key, consumer_secret)\n\n # set access token and secret\n self.auth.set_access_token(access_token, access_token_secret)\n\n try:\n # create tweepy API object to fetch tweets\n self.api = tweepy.API(self.auth)\n\n except:\n print(\"Error: Authentication Failed\")\n sys.exit(-1)","def initialise():\n twitter = Twython(\n settings.CONSUMER_KEY,\n settings.CONSUMER_SECRET,\n settings.ACCESS_TOKEN,\n settings.ACCESS_TOKEN_SECRET\n )\n\n return twitter","def twitter_setup():\r\n # Authentication and access using keys:\r\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\r\n auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\r\n\r\n # Return API with authentication:\r\n api = tweepy.API(auth)\r\n return api","def twitter_setup():\n # Authentication and access using keys:\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\n auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\n\n # Return API with authentication:\n api = tweepy.API(auth)\n return api","def twitter_setup():\n # Authentication and access using keys:\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\n auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\n\n # Return API with authentication:\n api = tweepy.API(auth)\n return api","def init_api():\n auth = twitter.OAuth(\n os.environ['AUTH_KEY'], os.environ['AUTH_SECRET'],\n os.environ['API_KEY'], os.environ['API_SECRET'],\n )\n return twitter.Twitter(auth=auth)","def __init__(self):\n ### load the json to get twitter config\n # check if the file exists\n if os.path.isfile(CONFIG_FILE):\n tmp_json = json.load(open(CONFIG_FILE))\n # test if tweeting is enabled or not....\n if not tmp_json['twitter']['enable']:\n print(\"We don't want to tweet!\")\n return\n consumer_key = tmp_json['twitter']['consumer_key']\n consumer_secret = tmp_json['twitter']['consumer_secret']\n access_token_key = tmp_json['twitter']['access_token']\n access_token_secret = tmp_json['twitter']['access_token_secret']\n else:\n raise Exception(\"Twitter oauth configuration : unable to open or read file '{0}')\".format(CONFIG_FILE))\n return\n\n ### Connect to twitter\n try:\n self.api = Api(consumer_key = consumer_key,\n consumer_secret = consumer_secret,\n access_token_key = access_token,\n access_token_secret = access_token_secret)\n self.api.VerifyCredentials()\n except TwitterError:\n raise Exception(\"Unable to log in the twitter account : {0}\".format(traceback.format_exc()))","def setup_and_get_tweet():\n\n DEBUG = find_env_variable('debug')\n TWEET = find_env_variable('tweet')\n\n # Loads in 'creds.json' values as a dictionary\n with open('creds.json') as creds:\n credentials = json.loads(creds.read())\n\n # Sets config values from the config file\n CONSUMER_KEY = credentials[\"consumer_key\"]\n CONSUMER_SECRET = credentials[\"consumer_secret\"]\n ACCESS_TOKEN_KEY = credentials[\"access_token_key\"]\n ACCESS_TOKEN_SECRET = credentials[\"access_token_secret\"]\n if DEBUG:\n print('consumer key: {} \\n'\n 'consumer secret: {} \\n'\n 'access token key: {} \\n'\n 'access token secret: {}'.format(CONSUMER_KEY, CONSUMER_SECRET,\n ACCESS_TOKEN_KEY, ACCESS_TOKEN_SECRET))\n\n # Create the Twython Twitter client using our credentials\n # Global is used so that if any other methods need the Twython instance it will be available\n global twitter\n twitter = Twython(CONSUMER_KEY, CONSUMER_SECRET,\n ACCESS_TOKEN_KEY, ACCESS_TOKEN_SECRET)\n # Random tweets list\n potential_tweets = [\n 'Very fresh tweet',\n 'Golly, no tweet provided! Gonna Pick a random one now ^_^',\n 'I sure am tweeting it up right now',\n 'I am the senate',\n 'This sure is a massive collection of tweets'\n ]\n # Checks if TWEET has been set return that else once of our random tweets\n return TWEET if TWEET else random.choice(potential_tweets)","def _connect_twitter_api(self):\r\n auth = tweepy.OAuthHandler(CovidBot.CONSUMER_KEY,\r\n CovidBot.CONSUMER_SECRET)\r\n auth.set_access_token(CovidBot.ACCESS_TOKEN,\r\n CovidBot.ACCESS_TOKEN_SECRET)\r\n self.api = tweepy.API(auth)\r\n logging.info(\"Twitter successfully authenticated\")","def set_twitter_auth():\n auth = ty.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\n auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\n api = ty.API(auth)\n return api","def initTweepy(self):\n CONSUMER_KEY = 'V1lNblYRlu57pqA9NCoxOOC4B'\n CONSUMER_SECRET = '0Q5MBXcHi0eiycmu0Q7lLGzfMHuCw9Y8IwZaxV3dOFYH5DVsCC'\n ACCESS_KEY = '1370328661618880515-29x3QQ6aGziflRMYLtrEu4ZL7mLbov'\n ACCESS_SECRET = 'dejwFK9J9pH2VHS7WYN2FO3YJ1WhpbfskACE3H48HgbwP'\n\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\n auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)\n api = tweepy.API(auth)\n\n return api","def __init__(self, credential):\n\n\t\t__CONSUMER_KEY = credential['twitter_credentials']['CONSUMER_KEY']\n\t\t__CONSUMER_SECRET = credential['twitter_credentials']['CONSUMER_SECRET']\n\t\t__ACCESS_TOKEN = credential['twitter_credentials']['ACCESS_TOKEN']\n\t\t__ACCESS_SECRET = credential['twitter_credentials']['ACCESS_SECRET']\n\t\t\n\t\tif TwitterApp.__api == None:\n\n\t\t\tTwitterApp.__api = twitter.Api(consumer_key = __CONSUMER_KEY,\n\t\t\t\t\t\t\t consumer_secret = __CONSUMER_SECRET,\n\t\t\t\t\t\t\t access_token_key = __ACCESS_TOKEN,\n\t\t\t\t\t \t\t access_token_secret = __ACCESS_SECRET)\n\n\t\t\ttry:\n\t\t\t\t\n\t\t\t\tTwitterApp.__api.VerifyCredentials()\n\t\t\t\tprint(\"Authenticated!\")\n\n\t\t\texcept Exception as e:\n\t\t\t\t\n\t\t\t\tprint(\"Could not authenticate you, verify credentials.\")","def __init__(self):\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, access_token_secret)\n self.api = tweepy.API(auth)","def twitter_auth():\n \n # Twitter API Keys\n consumer_key = \"\"\n consumer_secret_key = \"\"\n access_token = \"\"\n access_token_secret = \"\"\n\n # Twitter API authorisation\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret_key)\n auth.set_access_token(access_token, access_token_secret)\n api = tweepy.API(auth)\n return api","def t_auth():\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, token_secret)\n return tweepy.API(auth)","def get_twitter():\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)","def get_twitter():\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)","def get_twitter():\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)","def get_twitter():\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)","def __init__(self, api_key, api_secret, base_url=settings.TWITTER_API_URL):\n self.api_key = api_key\n self.api_secret = api_secret\n self.base_url = base_url\n self.bearer_token = None\n self.__auth = None\n self.get_bearer_token()\n self.set_requests_auth()\n self.session = requests_retry_session()","def __init__(self):\n super().__init__()\n\n # Will only reply to every 3rd or so tweet, defined in settings\n self.received_tweet_count = 0\n\n # Twitter api init\n self.auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\n self.auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\n self.twitter_api = tweepy.API(self.auth)\n\n print('Authenticated, creating stream...')\n\n self._init_stream()","def connect_twitter(config=cnfg.load(home + twitterConfigFile)):\n try:\n auth = tweepy.OAuthHandler(config['consumer_key'], \n config['consumer_secret'])\n auth.set_access_token(config['access_token'],\n config['access_token_secret'])\n api = tweepy.API(auth)\n return api\n except tweepy.TweepError as e:\n print e.message[0]['code']\n print e.args[0][0]['code']","def __init__(self):\r\n # keys and tokens from the Twitter Dev Console\r\n consumer_key = 'e1I0CSqgSOGxhH940cey1PR50'\r\n consumer_secret = 'APZE7kT2MgJsledQszLbNVcZZEhCUDX3NKAseXTjnsEcggUAkf'\r\n access_token = '876294238144786432-Q9PfwxPd4T7OdYO9hXiFyVDO38Q8jZV'\r\n access_token_secret = 'e0RhKgnLLyHnEOrWS92Tw0pKv5hWrN3chjp4Azm4NayOG'\r\n\r\n # clean tween regular expression\r\n self.pattern = re.compile('(@[A-Za-z0-9]+)|([^0-9A-Za-z \\t])|(\\w+://\\S+)')\r\n\r\n # attempt authentication\r\n try:\r\n # create OAuthHandler object\r\n self.auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\r\n # set access token and secret\r\n self.auth.set_access_token(access_token, access_token_secret)\r\n # create tweepy API object to fetch tweets\r\n self.api = tweepy.API(self.auth)\r\n logging.info(self.api.rate_limit_status()['resources']['search'])\r\n except:\r\n logging.error(\"Error: Authentication Failed\")","def authentication(): \n pathToConfig = os.path.join(prefix, \"twitterConfig\")\n config = json.load(open(pathToConfig))\n consumer_key = config['consumer_key']\n consumer_secret = config['consumer_secret']\n access_token = config['access_token']\n access_token_secret = config['access_token_secret']\n api = twitter.Api(consumer_key=consumer_key, consumer_secret=consumer_secret,\n access_token_key=access_token, access_token_secret=access_token_secret)\n return api","def load_twitter_auth():\n consumer_key = environ['TWITTER_CONSUMER_KEY']\n consumer_secret = environ['TWITTER_CONSUMER_SECRET']\n return tweepy.OAuthHandler(consumer_key, consumer_secret)","def get_twitter():\n \n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)","def __init__(self, config):\n self._config = config\n\n self.twitter = Twitter(auth=OAuth(\n self._config['twitter']['oauth'][0],\n self._config['twitter']['oauth'][1],\n self._config['twitter']['oauth'][2],\n self._config['twitter']['oauth'][3]\n ))\n\n self.sender = Mailer('smtp.gmail.com', use_tls=True, port=587)\n self.sender.login(self._config['mail']['address'], self._config['mail']['pass'])","def __init__(self, consumer_key=None, consumer_secret=None,\n access_token=None, access_token_secret=None):\n if not (consumer_key and consumer_secret and\n access_token and access_token_secret):\n consumer_key = os.environ['TWITTER_CONSUMER_KEY']\n consumer_secret = os.environ['TWITTER_CONSUMER_SECRET']\n access_token = os.environ['TWITTER_ACCESS_TOKEN']\n access_token_secret = os.environ['TWITTER_ACCESS_TOKEN_SECRET']\n\n self.oauth = OAuth(access_token, access_token_secret,\n consumer_key, consumer_secret)\n log.debug(\"Connecting to Twitter.\")\n self.stream = TwitterStream(auth=self.oauth)\n\n self.default_coordinates = [-180, -90, 180, 90]","def twitter_login():\n auth = twitter.OAuth(access_token, access_token_secret, consumer_key, consumer_secret)\n return twitter.Twitter(auth=auth, retry=True)","def twit_api():\n api = twitter.Api(config['twitter-api']['consumer_key'],\n config['twitter-api']['consumer_secret'],\n config['twitter-api']['access_key'],\n config['twitter-api']['access_secret'])\n # todo: error checking\n return api","def authenticate():\n auth = OAuthHandler(config.TW_API_KEY, config.TW_API_SECRET)\n auth.set_access_token(config.TW_ACC_TOKEN, config.TW_ACC_SECRET)\n\n return auth","def get_twitter(t_creds):\n # Authorize Twitter\n client = tweepy.Client(\n consumer_key=t_creds[\"consumer key\"],\n consumer_secret=t_creds[\"consumer secret\"],\n access_token=t_creds[\"access token\"],\n access_token_secret=t_creds[\"access token secret\"],\n )\n\n return client","def __init__(self, conv):\n self.conv = conv\n auth = self.auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, access_token_secret)\n self.api = tweepy.API(auth)","def authenticate(self):\n auth = tw.OAuthHandler(self.consumer_key, self.consumer_secret)\n auth.set_access_token(self.access_token, self.access_secret)\n return tw.API(auth)","def __init__(self, key='', name=None, ver=None, host=None):\n if host == None:\n if name == None: name = API.twitterName\n if ver == None: ver = API.twitterVersion\n ispras.API.__init__(self, key, name, ver)\n else:\n ispras.API.__init__(self, host=host, key=key)","def __init__(self, twitter_consumer_key, twitter_consumer_secret,\n twitter_access_key, twitter_access_secret,\n search_terms, search_on='news',\n bitly_access_token='',\n news_api_key=''):\n\n # Access Keys and Secrets for Twitter API obtained at: https://developer.twitter.com/\n auth = tweepy.OAuthHandler(twitter_consumer_key, twitter_consumer_secret)\n auth.set_access_token(twitter_access_key, twitter_access_secret)\n\n # Store API object for access to Twitter REST API\n self.__api = tweepy.API(auth)\n\n # Term(s) to search news feeds or Twitter on\n self.search_terms = search_terms\n\n # Method TwitterBot will use to search on. Current options are 'news' or 'twitter'\n self.search_on = search_on\n\n # Access token for optional Bitly API: https://dev.bitly.com/\n self.__bitly_access_token = bitly_access_token\n\n # Access token for optional News API: https://newsapi.org/\n self.__news_api_key = news_api_key\n\n # Will store list of items scraped from news or Twitter\n self.list = []","def __init__(self, influencers, credentials, similarity_parameter, popularity_parameter, epsilon):\n \n # Twitter API credentials initialization\n auth = tweepy.OAuthHandler(credentials['consumer_key'], credentials['consumer_secret'])\n auth.set_access_token(credentials['access_token'], credentials['access_token_secret'])\n self.api = tweepy.API(auth)\n\n # Class fields\n self.username = credentials['username']\n self.influencers = influencers\n self.complete_model = None\n self.influencer_models = None\n self.userTweetsStat = {}\n self.similarities = {}\n self.similarity_parameter = similarity_parameter\n self.popularity_parameter = popularity_parameter\n self.epsilon = epsilon\n self.valueState = {influencer: 0 for influencer in self.influencers.allInfluencers}\n self.reward = 1\n self.rewardParam = 0.1\n self.alpha = 0.1\n self.gamma = 1\n self.curDif = 0","def authWithTwitter(self):\n #if file exists, read from it, else pop up auth\n if (os.path.exists(self.AUTH_FILE_PATH)):\n try:\n auth_file = open(self.AUTH_FILE_PATH, \"r\")\n self.USER_TOKEN = auth_file.readline().rsplit(\":\")[1].rsplit(\"\\n\")[0].strip()\n self.USER_SECRET = auth_file.readline().rsplit(\":\")[1].rsplit(\"\\n\")[0].strip()\n auth_file.close()\n self.twitter = OAuthApi(self.CONSUMER_KEY, \n self.CONSUMER_SECRET,\n self.USER_TOKEN,\n self.USER_SECRET)\n except IOError as (errno, strerror):\n print \"I/O error in gwitter.py {0}): {1}\".format(errno, strerror)\n finally:\n if (auth_file != None):\n try: \n auth_file.close()\n auth_file = None\n except Exception:\n pass\n else:\n #Run auth dialog\n auth = AuthDialog.AuthDialog()\n auth.set_oauth_details(self.CONSUMER_KEY, self.CONSUMER_SECRET)\n response = auth.run()\n if response == gtk.RESPONSE_OK:\n #Key's been created, call method again to extract from file\n self.authWithTwitter()","def create_API_access():\n logger = logging.getLogger(__name__)\n logger.info('Creating API connection')\n\n # Find .env automagically by walking up directories until it's found\n dotenv_path = find_dotenv()\n\n # Load up the entries as environment variables\n load_dotenv(dotenv_path)\n\n # Get Twitter API credentials from environment variables\n consumer_key = os.environ.get(\"CONSUMER_KEY\")\n consumer_secret = os.environ.get(\"CONSUMER_SECRET\")\n access_token = os.environ.get(\"ACCESS_TOKEN\")\n access_secret = os.environ.get(\"ACCESS_SECRET\")\n\n # Set up authorization to Twitter API\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, access_secret)\n\n # Create connection object\n api = tweepy.API(auth)\n return api","def get_twitter():\n consumer_key = 'tb9zMiyUJ9UeX6blluI4Wlws8'\n consumer_secret = 'XlGNdXHj6Rd2LJ2t9LodnCLydvO2kZ4KLoq95VnQRXfuKXDgZn'\n access_token = '3231404389-56xTceJ255ar5Sj2sQtWuDj8z0grnNedlqOt5AC'\n access_token_secret = 'qwPAoWezVnfgeQCCaJy03rOQUJG2Z9ZACzVPIjcqu7IKD'\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)","def authenticate_twitter_app(self):\n \n auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\n auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)\n return auth","def login():\n\n # Twitter credentials\n consumer_key = 'XXXX'\n consumer_secret = 'XXXX'\n access_token = 'XXXX'\n access_token_secret = 'XXXX'\n\n # Authenticate\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, access_token_secret)\n\n # API is the main tweepy class we're going to use to interact with twitter\n api = tweepy.API(auth)\n\n # Check to make sure we can authenticate before we begin.\n # Prevents ya boi from trying to do this without an internet connection\n try:\n api.verify_credentials()\n print(\"I'm in...\")\n except:\n print(\"You didn't say the magic word!\")\n\n return api","def _client():\n nonlocal client\n if not client:\n client = twitter.Twitter(authenticator)\n return client","def __init__(self, topics=None, tweet_file=None, mode='batch'):\n self.topics = topics\n # (The twitter API will only return a max of 100 count)\n self.GEN_MAX_TWEET = 100 # the max number of tweets to generate\n self.tweet_file = tweet_file\n self.mode = mode\n self.tweets = []\n\n if topics and tweet_file:\n print(\"WARNING! you input both topics and the tweet file, only one is expected\")\n exit(-1)\n\n if not topics and not tweet_file:\n print(\"WARNING! you input either topics or tweet file, one is expected\")\n exit(-1)\n\n # If file argument is given, it will not connect to twitter server\n # It will just save tweets in self.tweets\n if tweet_file:\n with open(tweet_file, 'r') as infile:\n for line in infile:\n self.tweets.append(json.loads(line))\n\n else:\n consumer_key = 'bbqKfXEU2VJNoWlYJvbdtptOE'\n consumer_secret = 'afPk2JuMMMD6IhP5Xijo60ni4FUK39PDzhU7ylgT9FgNZX9ngh'\n access_token = '434708489-DTeHfK4OYKRuIXlfoWnNgzzwpEZTPCEpSMv8C0ll'\n access_token_secret = 'SjWFYfX2k3q4RJKQXcP1LP9ikhRfckPKOEcrb2cpQ0A0n'\n\n # Attempt authentication\n try:\n # create OAuthHandler object\n self.auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n # set access token and secret\n self.auth.set_access_token(access_token, access_token_secret)\n # create tweepy API object to fetch tweets\n self.api = tweepy.API(self.auth)\n except:\n print(\"Error: Authentication Failed\")\n exit(-1)","def __init__(self, username, password, **kwargs):\n self.url = 'https://heywatch.com'\n self.cli = httplib2.Http(**kwargs)\n self.cli.add_credentials(username, password)\n\n self.headers = {\n 'Accept': 'application/json',\n 'User-Agent': 'HeyWatch py/1.0.1',\n }\n\n self.account()","def __create_api(self):\n consumer_key = os.environ.get(\"CONSUMER_KEY\")\n consumer_secret = os.environ.get(\"CONSUMER_SECRET\")\n access_token = os.getenv(\"ACCESS_TOKEN\")\n access_token_secret = os.environ.get(\"ACCESS_TOKEN_SECRET\")\n\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, access_token_secret)\n api = tweepy.API(\n auth,\n compression=True,\n wait_on_rate_limit=True,\n wait_on_rate_limit_notify=True,\n )\n try:\n api.verify_credentials()\n except Exception as e:\n logging.error(\"Error creating API\", exc_info=True)\n raise e\n return api","def _authorize(self):\n auth = tweepy.OAuthHandler(self.keys[\"consumer_key\"], self.keys[\"consumer_secret\"])\n auth.set_access_token(self.keys[\"access_token\"], self.keys[\"access_token_secret\"])\n return tweepy.API(auth)","def __init__(self):\n self.load_objects()\n super(TwitterMain,self).__init__()","def register():\n\tglobal oauth_token, user_name\n\tuser_name = ''\n\trequest_token_url = 'https://api.twitter.com/oauth/request_token'\n\toauth_nonce = gen_oauth_nonce()\n\toauth_timestamp = gen_oauth_timestamp()\n\toauth_params = {\n\t\t'oauth_consumer_key' : oauth_consumer_key,\n\t\t'oauth_callback' : oauth_callback,\n\t\t'oauth_signature_method' : oauth_signature_method,\n\t\t'oauth_version' : oauth_version,\n\t\t'oauth_nonce' : oauth_nonce,\n\t\t'oauth_timestamp' : oauth_timestamp\n\t}\n\t# Build signature\n\toauth_signature = build_signature('POST', request_token_url, oauth_params)\n\toauth_params['oauth_signature'] = percent_encode(str(oauth_signature))\n\t# Connect\n\trequest = requests.post(request_token_url, '', headers={'Authorization': build_oauth_header(oauth_params)})\n\tif request.status_code == 200:\n\t\tdata = urllib.parse.parse_qs(request.text)\n\t\toauth_token = data['oauth_token'][0]\n\t\toauth_token_secret = data['oauth_token_secret'][0]\n\t\tprint('https://api.twitter.com/oauth/authorize?oauth_token='+oauth_token)\n\t\tpin = input('pin:')\n\t\taccess_token_url = 'https://api.twitter.com/oauth/access_token'\n\t\trequest = post(access_token_url, {'oauth_verifier' : pin})\n\t\tdata = urllib.parse.parse_qs(request.text)\n\t\tuser_name = data['screen_name'][0]\n\t\tuser_dir = users_dir + '/' + user_name\n\t\tif not os.path.exists(user_dir):\n\t\t\tos.makedirs(user_dir)\n\t\tfor varname in conf_files:\n\t\t\tpath = user_dir + '/' + varname\n\t\t\tf = open(path, 'w+')\n\t\t\tf.write(data[varname][0])\n\t\t\tf.close()","def __init__(self, username=None, password=None, account_sid=None,\n http_client=None, environment=None):\n environment = environment or os.environ\n \n self.username = username or environment.get('TWILIO_ACCOUNT_SID')\n \"\"\" :type : str \"\"\"\n self.password = password or environment.get('TWILIO_AUTH_TOKEN')\n \"\"\" :type : str \"\"\"\n self.account_sid = account_sid or self.username\n \"\"\" :type : str \"\"\"\n \n if not self.username or not self.password:\n raise TwilioException(\"Credentials are required to create a TwilioClient\")\n \n self.auth = (self.username, self.password)\n \"\"\" :type : tuple(str, str) \"\"\"\n self.http_client = http_client or Httplib2Client()\n \"\"\" :type : HttpClient \"\"\"\n \n # Domains\n self._api = None\n self._conversations = None\n self._ip_messaging = None\n self._lookups = None\n self._monitor = None\n self._pricing = None\n self._taskrouter = None\n self._trunking = None","def __init__(self):\n\n\t\tself.account_sid = os.environ['TWILIO_ACCOUNT_SID']\n\t\tself.auth_token = os.environ['TWILIO_AUTH_TOKEN']\n\t\tself.twilio_phone_number = os.environ['TWILIO_PHONE_NUMBER']\n\t\tself.client = Client(self.account_sid, self.auth_token)\n\n\t\tself.call_domain = 'http://twimlets.com/echo?Twiml='","def __init__(self, public_key, private_key, token, token_secret, base_url='http://api.telldus.com'):\n self.public_key = public_key\n self.private_key = private_key\n self.token = token\n self.token_secret = token_secret\n\n self.base_url = base_url\n\n self.oauth = self.generate_temp_session()","def __init__(self, **kwargs):\n self._username = kwargs.get('username', current_app.config.get('WORDAI_API_EMAIL', None))\n self._password = kwargs.get('password', current_app.config.get('WORDAI_API_PASSWORD', None))\n self._hash = kwargs.get('hash', current_app.config.get('WORDAI_API_KEY', None))","def __init__(self, consumer_key, consumer_secret, access_token, access_token_secret):\n self.api = self.getAPI(consumer_key, consumer_secret, access_token, access_token_secret)","def twitter(self, twitter):\n\n self._twitter = twitter","def get_api():\n consumer_api_key, consumer_secret_key, access_token, access_secret_token = get_keys()\n return twitter.Api(consumer_key=consumer_api_key,\n consumer_secret=consumer_secret_key,\n access_token_key=access_token,\n access_token_secret=access_secret_token)","def twitter_factory(authenticator):\n client = None\n\n def _client():\n \"\"\" Creates and setups the twitter client if not already done.\"\"\"\n nonlocal client\n if not client:\n client = twitter.Twitter(authenticator)\n return client\n\n return _client # return the function that returns the client","def auth(access_token, access_token_secret, consumer_key, consumer_secret):\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token,access_token_secret)\n return auth","def __init__(self, license_key: str = None, email: str = None, password: str = None, tim_url: str = 'https://timws.tangent.works/v4/api', api_key: str = 'a37b7c81-5a85-4eda-847d-d2d5ba33d2c8', access_token: str = None, logger: Logger = None):\n if self.__logger is None:\n self.__logger = logging.getLogger(__name__)\n\n self.set_tim_url(tim_url)\n self.__api_key = api_key\n\n if access_token:\n self.set_token(access_token)\n self.__license_key = license_key\n self.__email = email\n self.__password = password","def authorise(consumer_key, consumer_secret, access_token, access_token_secret):\r\n # Authorisation:\r\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\r\n auth.set_access_token(access_token, access_token_secret)\r\n\r\n # Creating api object:\r\n api = tweepy.API(auth)\r\n\r\n # Finally:\r\n return api","def setUp(self):\n self.twitter = Twitter(CUR_DIR + \"/test_crossfit.tweets\", CUR_DIR + \"/test_stop_words.txt\")\n self.twitter.load_tweets_and_build_index()\n\n self.searcher = Searcher(self.twitter.tweets, self.twitter.stop_words)","def __init__(self,consumer_key,consumer_secret):\n\t\tself.CONSUMER_KEY = consumer_key\n\t\tself.CONSUMER_SECRET = consumer_secret\n\t\tself.token=None\n\t\tself.secret=None\n\t\tself.resource_owner_key=None\n\t\tself.resource_owner_secret=None","def __init__(self):\n\n self._authorization = None\n self._last_used = datetime.utcnow() - timedelta(hours=10)\n\n self._resource_owner_key = None\n self._resource_owner_secret = None\n\n self._consumer_key = etrade_config.oauth_consumer_key\n self._consumer_secret = etrade_config.oath_consumer_secret\n\n self._auth_file_path = etrade_config.auth_file_path\n self._user_name = etrade_config.user_name\n self._user_pwd = etrade_config.user_pwd","def __init__(self, username=None, password=None, apitoken=None):\n self.__credentials = None\n self.__headers = {}\n if apitoken:\n self.authenticate_by_token(apitoken)\n if username and password:\n self.authenticate(username, password)","def __init__(self, oauth_consumer_token=None, oauth_access_token=None):\n self.consumer_token = oauth_consumer_token\n self.access_token = oauth_access_token","def twitter_auth(k, s):\n\n auth = tweepy.AppAuthHandler(k, s)\n api = tweepy.API(\n auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True\n )\n\n if (not api):\n return None\n else:\n return api","def __init__(self, apikey, secret):\n self.apikey = apikey\n self.secret = secret","def init_from_settings(cls):\n if cls._django_cached_obj:\n return cls._django_cached_obj\n api_obj = cls(settings.TWITTER_API_KEY, settings.TWITTER_API_SECRET)\n cls._django_cached_obj = api_obj\n return api_obj","def get_api():\n # Load auth information.\n token = load_token()\n\n if token is None:\n token_string = get_twitter_auth()\n save_token(token_string)\n token = tweepy.oauth.OAuthToken.from_string(token_string)\n\n try:\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\n auth.set_access_token(token.key, token.secret)\n\n api = tweepy.API(auth)\n except tweepy.TweepError:\n print (\"Error: Unable to get tweepy API, please try again.\")\n sys.exit(1)\n\n return api","def setup_class(cls):\n initialize(api_key=API_KEY, app_key=APP_KEY, api_host=API_HOST)","def __init__(self, tweet_data):\n _hashtags = tweet_data['entities']['hashtags']\n _str_date = tweet_data['created_at']\n self.account = Account(tweet_data['user'])\n self.date = self.format_date(_str_date)\n self.hashtags = [\"#%s\" % (tag['text']) for tag in _hashtags]\n self.likes = tweet_data['favorite_count']\n # Note: replies number is only available with\n # the Premium and Enterprise tier products.\n # https://developer.twitter.com/en/docs/tweets/data-dictionary/overview/tweet-object # noqa\n self.replies = 0\n self.retweets = tweet_data['retweet_count']\n self.text = tweet_data['text']","def twitter_auth(consumer_key=None, consumer_secret=None, access_key=None, access_secret=None):\n\n if not consumer_key:\n consumer_key = os.environ.get('T_CONSUMER_KEY', consumer_key)\n if not consumer_secret:\n consumer_secret = os.environ.get('T_CONSUMER_SECRET', consumer_secret)\n if not access_key:\n access_key = os.environ.get('T_ACCESS_KEY', access_key)\n if not access_secret:\n access_secret = os.environ.get('T_ACCESS_SECRET', access_secret)\n\n auth = [consumer_key, consumer_secret, access_key, access_secret]\n\n for credential in auth:\n if not isinstance(credential, str):\n raise TypeError(\n \"credential must be string, got: %s\" % (type(credential)))\n if len(credential) <= 0:\n raise TypeError('invalid credential %s' % (credential))\n\n return auth","def get_tweets():\n\n # Read bearer token from secrets file\n with open(\"./secrets.yml\", \"r\") as f:\n bearer_token = yaml.load(f, Loader=yaml.FullLoader)[\"BEARER_TOKEN\"]\n\n # Set start and end times as current time rounded down to nearest minute with supplied offset\n dt_fmt = \"%Y-%m-%dT%H:%M:00Z\"\n dt_now = datetime.datetime.now().replace(second=0, microsecond=0)\n start_time_offset = int(sys.argv[1])\n end_time_offset = int(sys.argv[2])\n dt_end = dt_now - datetime.timedelta(minutes=end_time_offset)\n dt_start = dt_now - datetime.timedelta(minutes=start_time_offset)\n dt_end = dt_end.strftime(dt_fmt)\n dt_start = dt_start.strftime(dt_fmt)\n\n # Make request, checking for mentions in specified time period\n logging.info(\"Getting mentions from Twitter\")\n uri = \"https://api.twitter.com/2/tweets/search/recent\"\n headers = {\"Authorization\": f\"Bearer {bearer_token}\"}\n query = {\"query\": f\"@{ACCOUNT_NAME}\",\n \"expansions\" : \"author_id\",\n \"user.fields\" : \"username\",\n \"start_time\" : dt_start,\n \"end_time\" : dt_end}\n response = requests.get(uri, headers=headers, params=query)\n\n # Make connection to local database\n connection = sqlite3.connect(\"../database/procrystaldb.db\")\n cursor = connection.cursor()\n\n # Get current total number of rows in database\n cursor.execute(\"SELECT COUNT(*) FROM Twitter;\")\n initial_rows = cursor.fetchall()[0][0]\n\n # Get usernames and tweet ids from tweets and save to database\n if response.status_code == 200:\n content = response.json()\n num_results = content[\"meta\"][\"result_count\"]\n if num_results > 0:\n # First get dictionary of usernames\n user_id_to_name = {}\n for user in content[\"includes\"][\"users\"]:\n user_id_to_name[user[\"id\"]] = user[\"username\"]\n # Then get tweet id, username and save to database\n for result in content[\"data\"]:\n # if KEYWORD in result[\"text\"].lower():\n tweet_id = result[\"id\"]\n username = user_id_to_name[result[\"author_id\"]]\n sql_insert = f\"\"\"\n INSERT OR IGNORE INTO Twitter (tweet_id, username, reply_sent)\n VALUES ('{tweet_id}', '{username}', false);\n \"\"\"\n cursor.execute(sql_insert)\n logging.info(f\"Mentions fetched: {num_results}\")\n else:\n logging.error(f\"Get mentions errored with: {response.json()}\")\n\n # Get final total number of rows in database and therefore number of rows added\n cursor.execute(\"SELECT COUNT(*) FROM Twitter;\")\n final_rows = cursor.fetchall()[0][0]\n rows_added = final_rows - initial_rows\n logging.info(f\"New mentions added: {rows_added}\")\n\n # Close database connection\n connection.commit()\n connection.close()\n\n return rows_added","def twitter_api(input_encoding=\"utf-8\"):\n\n consumer_key = get_consumer_key()\n consumer_secret = get_consumer_secret()\n access_key, access_secret = \\\n get_access_tokens(consumer_key, consumer_secret)\n\n api = twitter.Api(consumer_key=consumer_key,\n consumer_secret=consumer_secret, access_token_key=access_key,\n access_token_secret=access_secret, input_encoding=input_encoding,\n debugHTTP=False)\n\n return api","def get_api():\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, access_secret)\n api = tweepy.API(auth)\n\n return api","def __init__(self, id_: str, bio: str) -> None:\n\n # YOUR CODE HERE\n self.userid = id_\n self.bio = bio\n self.tweets = []","def __init__(self, authenticator, username, password):\n super(ScriptAuthorizer, self).__init__(authenticator)\n self._username = username\n self._password = password","def __init__(self, config):\n self._slack_client = self._connect(config[\"slack_bot_token\"])\n self.bot_id = self._get_user_id()\n self.default_channel = config[\"default_channel\"]","def get_api(credsfile = DEFAULT_TWITTER_CREDS_PATH):\n fn = os.getcwd() + credsfile\n c = json.load(open(fn, \"r\"))\n # Get authentication token\n auth = tweepy.OAuthHandler(consumer_key = c['consumer_key'],\n consumer_secret = c['consumer_secret'])\n auth.set_access_token(c['access_token'], c['access_token_secret'])\n # create an API handler\n return tweepy.API(auth)","def __init__(self, credentials):\r\n if not has_httplib2:\r\n raise ImportError(\"No module named httplib2\")\r\n super(GAPDecoratorAuthMethod, self).__init__()\r\n self._http = None\r\n self._credentials = credentials\r\n self._action_token = None","def get_twitter_token():\n return None","def get_api(cfg):\n auth = tweepy.OAuthHandler(cfg['consumer_key'], cfg['consumer_secret'])\n auth.set_access_token(cfg['access_token'], cfg['access_token_secret'])\n return tweepy.API(auth)","def access_api():\n\n auth = tweepy.OAuthHandler(Consumer_key, Consumer_key_secret)\n auth.set_access_token(Access_token, Access_token_secret)\n api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)\n\n return api","def api_authentication(token, secret):\n\n api = twitter.Twitter(auth=twitter.OAuth(token, secret,\n CONSUMER_KEY, CONSUMER_SECRET))\n if not api:\n print(\"Authentication failed, try running the script one more time\")\n\n # delete data from the configuration file to force a new\n # authentication next time\n os.remove(TOKEN_FILE)\n return None\n\n return api","def __init__(self):\n self.sp, self.user = self.init_auth_client()\n self.logger = logging.getLogger(__name__)","def __init__(self, apiKey, apiSecret):\n self.apiKey = apiKey\n self.apiSecret = apiSecret","def authenticate():\n auth = OAuthHandler(config.CONSUMER_API_KEY, config.CONSUMER_API_SECRET)\n auth.set_access_token(config.ACCESS_TOKEN, config.ACCESS_TOKEN_SECRET)\n\n return auth","def authenticate():\n auth = OAuthHandler(config.CONSUMER_API_KEY, config.CONSUMER_API_SECRET)\n auth.set_access_token(config.ACCESS_TOKEN, config.ACCESS_TOKEN_SECRET)\n\n return auth","def get_twitter_auth():\n # Authenticate if information not found\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\n\n # Get Auth URL\n try:\n redirect_url = auth.get_authorization_url()\n except tweepy.TweepError:\n print \"Error: Failed to get request token.\"\n sys.exit(1)\n\n # Get Verifier\n print (\"Visit this URL and confirm authentication by typing in the \"\n \"PIN given by Twitter.\")\n webbrowser.open_new_tab(redirect_url)\n verifier = raw_input(\"Twitter Verification PIN: \")\n\n # Get token\n try:\n token = auth.get_access_token(verifier=verifier)\n except tweepy.TweepError:\n print (\"Error: Unable to get access tokens from verifier, \"\n \"please try again.\")\n\n return token.to_string()","def extract_tweets(consumer_key,consumer_secret,access_token,access_token_secret,search_key):\n # Step 1 - Authenticate\n consumer_key= str(consumer_key)\n consumer_secret= str(consumer_secret)\n\n access_token=str(access_token)\n access_token_secret=str(access_token_secret)\n\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, access_token_secret)\n\n api = tweepy.API(auth)\n\n #Step 3 - Retrieve Tweets\n public_tweets = api.search(search_key)\n tweets_list=[]\n for tweet in public_tweets:\n tweets_list.append(tweet.text)\n return tweets_list","def __init__(self, api_url, credentials):\n self.api_url = api_url\n while self.api_url.endswith(\"/\"):\n self.api_url = self.api_url[:-1]\n self.credentials = credentials\n self.username = credentials.username\n self.token = credentials.token","def SetUp(self) :\n self.new_credential = Credential(\"snapchat\", \"chat@gmail.com\", \"Chat001\") # new credential","def __init__(self, token=None, token_path=\"tokens.txt\", username=None, password=None,\n grant_type=\"api-password\", client_id=\"brandwatch-api-client\",\n api_url=\"https://api.brandwatch.com/\"):\n self.api_url = api_url\n self.oauthpath = \"oauth/token\"\n\n if token:\n self._update_by_test_auth(username, token)\n self._write_auth(token_path)\n elif username is not None and password is not None:\n self._update_by_auth(username, password, token_path, grant_type, client_id)\n self._write_auth(token_path)\n elif username is not None:\n self._read_auth(username, token_path)\n else:\n raise KeyError(\"Must provide valid token, username and password,\"\n \" or username and path to token file\")","def __init__(self, auth_key, auth_secret):\n\n self._auth_key = auth_key\n self._auth_secret = auth_secret","def __init__(self, username, password): \n self.login_params = {\n 'GA3T': _random_id(11), # unique identifiers for session\n 'GALX': _random_id(11), # unique identifiers for session\n \"continue\": 'http://www.google.com/trends',\n 'nui': '1',\n 'hl': 'en-US',\n 'rmShown': '1',\n \"PersistentCookie\": \"yes\",\n \"Email\": username,\n \"Passwd\": password,\n 'service': 'trends' \n }\n self.headers = [(\"Content-type\", \"application/x-www-form-urlencoded\"),\n ('User-Agent', 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'),\n (\"Accept\", \"text/plain\")]\n self.url_ServiceLoginBoxAuth = 'https://www.google.com/accounts/ServiceLoginBoxAuth'\n self.url_Export = 'http://www.google.com/trends/viz'\n self.header_dictionary = {}\n self._connect()","def __init__(self, username = None, password = None):\n self.username = config['AUTH']['USERNAME']\n self.password = config['AUTH']['PASSWORD']\n self.login = config['URL']['LOGIN']\n self.nav_url = config['URL']['NAV']\n self.tag_url = config['URL']['TAGS']\n self.direct_url = config['URL']['DM']\n self.driver = webdriver.Chrome(config['ENVIRONMENT']['CHROMEDRIVER'])\n self.stay_logged = False\n self.api = InstagramAPI(self.username, self.password)","def __init__(self):\n self.api_key = secret.TMDB_API_KEY","def __init__(self, api_key, client_id=None, client_secret=None):\n self.api = API(api_key)\n self._manifest = Manifest(self.api)\n self.oauth = OAuth(client_id, client_secret)","def on_activate(self):\n \n self.consumer_key = get_global_option('twitter-consumer-key')\n self.consumer_secret = get_global_option('twitter-consumer-secret')\n self.access_token = get_global_option('twitter-access-token')\n self.token_secret = get_global_option('twitter-token-secret')\n self.api = twitter.Api(consumer_key=self.consumer_key,\n consumer_secret=self.consumer_secret,\n access_token_key=self.access_token,\n access_token_secret=self.token_secret) \n \n check_time = get_global_option(\"twitter-check-time\")\n if check_time:\n check_time = int(check_time)\n else:\n check_time = 30\n logger.info(\"Twitter check timer is every {} seconds\".format(check_time))\n self.timer.start(check_time, now=False)\n return (True, None)"],"string":"[\n \"def setup_twitter():\\n auth = tweepy.OAuthHandler(credentials[\\\"twitter\\\"][\\\"consumer_key\\\"], credentials[\\\"twitter\\\"][\\\"consumer_secret\\\"])\\n auth.set_access_token(credentials[\\\"twitter\\\"][\\\"access_token\\\"], credentials[\\\"twitter\\\"][\\\"access_token_secret\\\"])\\n return tweepy.API(auth)\",\n \"def __init__(self):\\n # keys and tokens from the Twitter Dev Console\\n key = provide_keys('males')\\n\\n consumer_key = key['consumer_key']\\n consumer_secret = key['consumer_secret']\\n access_token = key['access_token_key']\\n access_token_secret = key['access_token_secret']\\n\\n # attempt authentication\\n\\n # create OAuthHandler object\\n self.auth = OAuthHandler(consumer_key, consumer_secret)\\n\\n # set access token and secret\\n self.auth.set_access_token(access_token, access_token_secret)\\n\\n try:\\n # create tweepy API object to fetch tweets\\n self.api = tweepy.API(self.auth)\\n\\n except:\\n print(\\\"Error: Authentication Failed\\\")\\n sys.exit(-1)\",\n \"def initialise():\\n twitter = Twython(\\n settings.CONSUMER_KEY,\\n settings.CONSUMER_SECRET,\\n settings.ACCESS_TOKEN,\\n settings.ACCESS_TOKEN_SECRET\\n )\\n\\n return twitter\",\n \"def twitter_setup():\\r\\n # Authentication and access using keys:\\r\\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\\r\\n auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\\r\\n\\r\\n # Return API with authentication:\\r\\n api = tweepy.API(auth)\\r\\n return api\",\n \"def twitter_setup():\\n # Authentication and access using keys:\\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\\n auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\\n\\n # Return API with authentication:\\n api = tweepy.API(auth)\\n return api\",\n \"def twitter_setup():\\n # Authentication and access using keys:\\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\\n auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\\n\\n # Return API with authentication:\\n api = tweepy.API(auth)\\n return api\",\n \"def init_api():\\n auth = twitter.OAuth(\\n os.environ['AUTH_KEY'], os.environ['AUTH_SECRET'],\\n os.environ['API_KEY'], os.environ['API_SECRET'],\\n )\\n return twitter.Twitter(auth=auth)\",\n \"def __init__(self):\\n ### load the json to get twitter config\\n # check if the file exists\\n if os.path.isfile(CONFIG_FILE):\\n tmp_json = json.load(open(CONFIG_FILE))\\n # test if tweeting is enabled or not....\\n if not tmp_json['twitter']['enable']:\\n print(\\\"We don't want to tweet!\\\")\\n return\\n consumer_key = tmp_json['twitter']['consumer_key']\\n consumer_secret = tmp_json['twitter']['consumer_secret']\\n access_token_key = tmp_json['twitter']['access_token']\\n access_token_secret = tmp_json['twitter']['access_token_secret']\\n else:\\n raise Exception(\\\"Twitter oauth configuration : unable to open or read file '{0}')\\\".format(CONFIG_FILE))\\n return\\n\\n ### Connect to twitter\\n try:\\n self.api = Api(consumer_key = consumer_key,\\n consumer_secret = consumer_secret,\\n access_token_key = access_token,\\n access_token_secret = access_token_secret)\\n self.api.VerifyCredentials()\\n except TwitterError:\\n raise Exception(\\\"Unable to log in the twitter account : {0}\\\".format(traceback.format_exc()))\",\n \"def setup_and_get_tweet():\\n\\n DEBUG = find_env_variable('debug')\\n TWEET = find_env_variable('tweet')\\n\\n # Loads in 'creds.json' values as a dictionary\\n with open('creds.json') as creds:\\n credentials = json.loads(creds.read())\\n\\n # Sets config values from the config file\\n CONSUMER_KEY = credentials[\\\"consumer_key\\\"]\\n CONSUMER_SECRET = credentials[\\\"consumer_secret\\\"]\\n ACCESS_TOKEN_KEY = credentials[\\\"access_token_key\\\"]\\n ACCESS_TOKEN_SECRET = credentials[\\\"access_token_secret\\\"]\\n if DEBUG:\\n print('consumer key: {} \\\\n'\\n 'consumer secret: {} \\\\n'\\n 'access token key: {} \\\\n'\\n 'access token secret: {}'.format(CONSUMER_KEY, CONSUMER_SECRET,\\n ACCESS_TOKEN_KEY, ACCESS_TOKEN_SECRET))\\n\\n # Create the Twython Twitter client using our credentials\\n # Global is used so that if any other methods need the Twython instance it will be available\\n global twitter\\n twitter = Twython(CONSUMER_KEY, CONSUMER_SECRET,\\n ACCESS_TOKEN_KEY, ACCESS_TOKEN_SECRET)\\n # Random tweets list\\n potential_tweets = [\\n 'Very fresh tweet',\\n 'Golly, no tweet provided! Gonna Pick a random one now ^_^',\\n 'I sure am tweeting it up right now',\\n 'I am the senate',\\n 'This sure is a massive collection of tweets'\\n ]\\n # Checks if TWEET has been set return that else once of our random tweets\\n return TWEET if TWEET else random.choice(potential_tweets)\",\n \"def _connect_twitter_api(self):\\r\\n auth = tweepy.OAuthHandler(CovidBot.CONSUMER_KEY,\\r\\n CovidBot.CONSUMER_SECRET)\\r\\n auth.set_access_token(CovidBot.ACCESS_TOKEN,\\r\\n CovidBot.ACCESS_TOKEN_SECRET)\\r\\n self.api = tweepy.API(auth)\\r\\n logging.info(\\\"Twitter successfully authenticated\\\")\",\n \"def set_twitter_auth():\\n auth = ty.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\\n auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\\n api = ty.API(auth)\\n return api\",\n \"def initTweepy(self):\\n CONSUMER_KEY = 'V1lNblYRlu57pqA9NCoxOOC4B'\\n CONSUMER_SECRET = '0Q5MBXcHi0eiycmu0Q7lLGzfMHuCw9Y8IwZaxV3dOFYH5DVsCC'\\n ACCESS_KEY = '1370328661618880515-29x3QQ6aGziflRMYLtrEu4ZL7mLbov'\\n ACCESS_SECRET = 'dejwFK9J9pH2VHS7WYN2FO3YJ1WhpbfskACE3H48HgbwP'\\n\\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\\n auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)\\n api = tweepy.API(auth)\\n\\n return api\",\n \"def __init__(self, credential):\\n\\n\\t\\t__CONSUMER_KEY = credential['twitter_credentials']['CONSUMER_KEY']\\n\\t\\t__CONSUMER_SECRET = credential['twitter_credentials']['CONSUMER_SECRET']\\n\\t\\t__ACCESS_TOKEN = credential['twitter_credentials']['ACCESS_TOKEN']\\n\\t\\t__ACCESS_SECRET = credential['twitter_credentials']['ACCESS_SECRET']\\n\\t\\t\\n\\t\\tif TwitterApp.__api == None:\\n\\n\\t\\t\\tTwitterApp.__api = twitter.Api(consumer_key = __CONSUMER_KEY,\\n\\t\\t\\t\\t\\t\\t\\t consumer_secret = __CONSUMER_SECRET,\\n\\t\\t\\t\\t\\t\\t\\t access_token_key = __ACCESS_TOKEN,\\n\\t\\t\\t\\t\\t \\t\\t access_token_secret = __ACCESS_SECRET)\\n\\n\\t\\t\\ttry:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tTwitterApp.__api.VerifyCredentials()\\n\\t\\t\\t\\tprint(\\\"Authenticated!\\\")\\n\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tprint(\\\"Could not authenticate you, verify credentials.\\\")\",\n \"def __init__(self):\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, access_token_secret)\\n self.api = tweepy.API(auth)\",\n \"def twitter_auth():\\n \\n # Twitter API Keys\\n consumer_key = \\\"\\\"\\n consumer_secret_key = \\\"\\\"\\n access_token = \\\"\\\"\\n access_token_secret = \\\"\\\"\\n\\n # Twitter API authorisation\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret_key)\\n auth.set_access_token(access_token, access_token_secret)\\n api = tweepy.API(auth)\\n return api\",\n \"def t_auth():\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, token_secret)\\n return tweepy.API(auth)\",\n \"def get_twitter():\\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)\",\n \"def get_twitter():\\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)\",\n \"def get_twitter():\\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)\",\n \"def get_twitter():\\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)\",\n \"def __init__(self, api_key, api_secret, base_url=settings.TWITTER_API_URL):\\n self.api_key = api_key\\n self.api_secret = api_secret\\n self.base_url = base_url\\n self.bearer_token = None\\n self.__auth = None\\n self.get_bearer_token()\\n self.set_requests_auth()\\n self.session = requests_retry_session()\",\n \"def __init__(self):\\n super().__init__()\\n\\n # Will only reply to every 3rd or so tweet, defined in settings\\n self.received_tweet_count = 0\\n\\n # Twitter api init\\n self.auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\\n self.auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)\\n self.twitter_api = tweepy.API(self.auth)\\n\\n print('Authenticated, creating stream...')\\n\\n self._init_stream()\",\n \"def connect_twitter(config=cnfg.load(home + twitterConfigFile)):\\n try:\\n auth = tweepy.OAuthHandler(config['consumer_key'], \\n config['consumer_secret'])\\n auth.set_access_token(config['access_token'],\\n config['access_token_secret'])\\n api = tweepy.API(auth)\\n return api\\n except tweepy.TweepError as e:\\n print e.message[0]['code']\\n print e.args[0][0]['code']\",\n \"def __init__(self):\\r\\n # keys and tokens from the Twitter Dev Console\\r\\n consumer_key = 'e1I0CSqgSOGxhH940cey1PR50'\\r\\n consumer_secret = 'APZE7kT2MgJsledQszLbNVcZZEhCUDX3NKAseXTjnsEcggUAkf'\\r\\n access_token = '876294238144786432-Q9PfwxPd4T7OdYO9hXiFyVDO38Q8jZV'\\r\\n access_token_secret = 'e0RhKgnLLyHnEOrWS92Tw0pKv5hWrN3chjp4Azm4NayOG'\\r\\n\\r\\n # clean tween regular expression\\r\\n self.pattern = re.compile('(@[A-Za-z0-9]+)|([^0-9A-Za-z \\\\t])|(\\\\w+://\\\\S+)')\\r\\n\\r\\n # attempt authentication\\r\\n try:\\r\\n # create OAuthHandler object\\r\\n self.auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\r\\n # set access token and secret\\r\\n self.auth.set_access_token(access_token, access_token_secret)\\r\\n # create tweepy API object to fetch tweets\\r\\n self.api = tweepy.API(self.auth)\\r\\n logging.info(self.api.rate_limit_status()['resources']['search'])\\r\\n except:\\r\\n logging.error(\\\"Error: Authentication Failed\\\")\",\n \"def authentication(): \\n pathToConfig = os.path.join(prefix, \\\"twitterConfig\\\")\\n config = json.load(open(pathToConfig))\\n consumer_key = config['consumer_key']\\n consumer_secret = config['consumer_secret']\\n access_token = config['access_token']\\n access_token_secret = config['access_token_secret']\\n api = twitter.Api(consumer_key=consumer_key, consumer_secret=consumer_secret,\\n access_token_key=access_token, access_token_secret=access_token_secret)\\n return api\",\n \"def load_twitter_auth():\\n consumer_key = environ['TWITTER_CONSUMER_KEY']\\n consumer_secret = environ['TWITTER_CONSUMER_SECRET']\\n return tweepy.OAuthHandler(consumer_key, consumer_secret)\",\n \"def get_twitter():\\n \\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)\",\n \"def __init__(self, config):\\n self._config = config\\n\\n self.twitter = Twitter(auth=OAuth(\\n self._config['twitter']['oauth'][0],\\n self._config['twitter']['oauth'][1],\\n self._config['twitter']['oauth'][2],\\n self._config['twitter']['oauth'][3]\\n ))\\n\\n self.sender = Mailer('smtp.gmail.com', use_tls=True, port=587)\\n self.sender.login(self._config['mail']['address'], self._config['mail']['pass'])\",\n \"def __init__(self, consumer_key=None, consumer_secret=None,\\n access_token=None, access_token_secret=None):\\n if not (consumer_key and consumer_secret and\\n access_token and access_token_secret):\\n consumer_key = os.environ['TWITTER_CONSUMER_KEY']\\n consumer_secret = os.environ['TWITTER_CONSUMER_SECRET']\\n access_token = os.environ['TWITTER_ACCESS_TOKEN']\\n access_token_secret = os.environ['TWITTER_ACCESS_TOKEN_SECRET']\\n\\n self.oauth = OAuth(access_token, access_token_secret,\\n consumer_key, consumer_secret)\\n log.debug(\\\"Connecting to Twitter.\\\")\\n self.stream = TwitterStream(auth=self.oauth)\\n\\n self.default_coordinates = [-180, -90, 180, 90]\",\n \"def twitter_login():\\n auth = twitter.OAuth(access_token, access_token_secret, consumer_key, consumer_secret)\\n return twitter.Twitter(auth=auth, retry=True)\",\n \"def twit_api():\\n api = twitter.Api(config['twitter-api']['consumer_key'],\\n config['twitter-api']['consumer_secret'],\\n config['twitter-api']['access_key'],\\n config['twitter-api']['access_secret'])\\n # todo: error checking\\n return api\",\n \"def authenticate():\\n auth = OAuthHandler(config.TW_API_KEY, config.TW_API_SECRET)\\n auth.set_access_token(config.TW_ACC_TOKEN, config.TW_ACC_SECRET)\\n\\n return auth\",\n \"def get_twitter(t_creds):\\n # Authorize Twitter\\n client = tweepy.Client(\\n consumer_key=t_creds[\\\"consumer key\\\"],\\n consumer_secret=t_creds[\\\"consumer secret\\\"],\\n access_token=t_creds[\\\"access token\\\"],\\n access_token_secret=t_creds[\\\"access token secret\\\"],\\n )\\n\\n return client\",\n \"def __init__(self, conv):\\n self.conv = conv\\n auth = self.auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, access_token_secret)\\n self.api = tweepy.API(auth)\",\n \"def authenticate(self):\\n auth = tw.OAuthHandler(self.consumer_key, self.consumer_secret)\\n auth.set_access_token(self.access_token, self.access_secret)\\n return tw.API(auth)\",\n \"def __init__(self, key='', name=None, ver=None, host=None):\\n if host == None:\\n if name == None: name = API.twitterName\\n if ver == None: ver = API.twitterVersion\\n ispras.API.__init__(self, key, name, ver)\\n else:\\n ispras.API.__init__(self, host=host, key=key)\",\n \"def __init__(self, twitter_consumer_key, twitter_consumer_secret,\\n twitter_access_key, twitter_access_secret,\\n search_terms, search_on='news',\\n bitly_access_token='',\\n news_api_key=''):\\n\\n # Access Keys and Secrets for Twitter API obtained at: https://developer.twitter.com/\\n auth = tweepy.OAuthHandler(twitter_consumer_key, twitter_consumer_secret)\\n auth.set_access_token(twitter_access_key, twitter_access_secret)\\n\\n # Store API object for access to Twitter REST API\\n self.__api = tweepy.API(auth)\\n\\n # Term(s) to search news feeds or Twitter on\\n self.search_terms = search_terms\\n\\n # Method TwitterBot will use to search on. Current options are 'news' or 'twitter'\\n self.search_on = search_on\\n\\n # Access token for optional Bitly API: https://dev.bitly.com/\\n self.__bitly_access_token = bitly_access_token\\n\\n # Access token for optional News API: https://newsapi.org/\\n self.__news_api_key = news_api_key\\n\\n # Will store list of items scraped from news or Twitter\\n self.list = []\",\n \"def __init__(self, influencers, credentials, similarity_parameter, popularity_parameter, epsilon):\\n \\n # Twitter API credentials initialization\\n auth = tweepy.OAuthHandler(credentials['consumer_key'], credentials['consumer_secret'])\\n auth.set_access_token(credentials['access_token'], credentials['access_token_secret'])\\n self.api = tweepy.API(auth)\\n\\n # Class fields\\n self.username = credentials['username']\\n self.influencers = influencers\\n self.complete_model = None\\n self.influencer_models = None\\n self.userTweetsStat = {}\\n self.similarities = {}\\n self.similarity_parameter = similarity_parameter\\n self.popularity_parameter = popularity_parameter\\n self.epsilon = epsilon\\n self.valueState = {influencer: 0 for influencer in self.influencers.allInfluencers}\\n self.reward = 1\\n self.rewardParam = 0.1\\n self.alpha = 0.1\\n self.gamma = 1\\n self.curDif = 0\",\n \"def authWithTwitter(self):\\n #if file exists, read from it, else pop up auth\\n if (os.path.exists(self.AUTH_FILE_PATH)):\\n try:\\n auth_file = open(self.AUTH_FILE_PATH, \\\"r\\\")\\n self.USER_TOKEN = auth_file.readline().rsplit(\\\":\\\")[1].rsplit(\\\"\\\\n\\\")[0].strip()\\n self.USER_SECRET = auth_file.readline().rsplit(\\\":\\\")[1].rsplit(\\\"\\\\n\\\")[0].strip()\\n auth_file.close()\\n self.twitter = OAuthApi(self.CONSUMER_KEY, \\n self.CONSUMER_SECRET,\\n self.USER_TOKEN,\\n self.USER_SECRET)\\n except IOError as (errno, strerror):\\n print \\\"I/O error in gwitter.py {0}): {1}\\\".format(errno, strerror)\\n finally:\\n if (auth_file != None):\\n try: \\n auth_file.close()\\n auth_file = None\\n except Exception:\\n pass\\n else:\\n #Run auth dialog\\n auth = AuthDialog.AuthDialog()\\n auth.set_oauth_details(self.CONSUMER_KEY, self.CONSUMER_SECRET)\\n response = auth.run()\\n if response == gtk.RESPONSE_OK:\\n #Key's been created, call method again to extract from file\\n self.authWithTwitter()\",\n \"def create_API_access():\\n logger = logging.getLogger(__name__)\\n logger.info('Creating API connection')\\n\\n # Find .env automagically by walking up directories until it's found\\n dotenv_path = find_dotenv()\\n\\n # Load up the entries as environment variables\\n load_dotenv(dotenv_path)\\n\\n # Get Twitter API credentials from environment variables\\n consumer_key = os.environ.get(\\\"CONSUMER_KEY\\\")\\n consumer_secret = os.environ.get(\\\"CONSUMER_SECRET\\\")\\n access_token = os.environ.get(\\\"ACCESS_TOKEN\\\")\\n access_secret = os.environ.get(\\\"ACCESS_SECRET\\\")\\n\\n # Set up authorization to Twitter API\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, access_secret)\\n\\n # Create connection object\\n api = tweepy.API(auth)\\n return api\",\n \"def get_twitter():\\n consumer_key = 'tb9zMiyUJ9UeX6blluI4Wlws8'\\n consumer_secret = 'XlGNdXHj6Rd2LJ2t9LodnCLydvO2kZ4KLoq95VnQRXfuKXDgZn'\\n access_token = '3231404389-56xTceJ255ar5Sj2sQtWuDj8z0grnNedlqOt5AC'\\n access_token_secret = 'qwPAoWezVnfgeQCCaJy03rOQUJG2Z9ZACzVPIjcqu7IKD'\\n return TwitterAPI(consumer_key, consumer_secret, access_token, access_token_secret)\",\n \"def authenticate_twitter_app(self):\\n \\n auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\\n auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)\\n return auth\",\n \"def login():\\n\\n # Twitter credentials\\n consumer_key = 'XXXX'\\n consumer_secret = 'XXXX'\\n access_token = 'XXXX'\\n access_token_secret = 'XXXX'\\n\\n # Authenticate\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, access_token_secret)\\n\\n # API is the main tweepy class we're going to use to interact with twitter\\n api = tweepy.API(auth)\\n\\n # Check to make sure we can authenticate before we begin.\\n # Prevents ya boi from trying to do this without an internet connection\\n try:\\n api.verify_credentials()\\n print(\\\"I'm in...\\\")\\n except:\\n print(\\\"You didn't say the magic word!\\\")\\n\\n return api\",\n \"def _client():\\n nonlocal client\\n if not client:\\n client = twitter.Twitter(authenticator)\\n return client\",\n \"def __init__(self, topics=None, tweet_file=None, mode='batch'):\\n self.topics = topics\\n # (The twitter API will only return a max of 100 count)\\n self.GEN_MAX_TWEET = 100 # the max number of tweets to generate\\n self.tweet_file = tweet_file\\n self.mode = mode\\n self.tweets = []\\n\\n if topics and tweet_file:\\n print(\\\"WARNING! you input both topics and the tweet file, only one is expected\\\")\\n exit(-1)\\n\\n if not topics and not tweet_file:\\n print(\\\"WARNING! you input either topics or tweet file, one is expected\\\")\\n exit(-1)\\n\\n # If file argument is given, it will not connect to twitter server\\n # It will just save tweets in self.tweets\\n if tweet_file:\\n with open(tweet_file, 'r') as infile:\\n for line in infile:\\n self.tweets.append(json.loads(line))\\n\\n else:\\n consumer_key = 'bbqKfXEU2VJNoWlYJvbdtptOE'\\n consumer_secret = 'afPk2JuMMMD6IhP5Xijo60ni4FUK39PDzhU7ylgT9FgNZX9ngh'\\n access_token = '434708489-DTeHfK4OYKRuIXlfoWnNgzzwpEZTPCEpSMv8C0ll'\\n access_token_secret = 'SjWFYfX2k3q4RJKQXcP1LP9ikhRfckPKOEcrb2cpQ0A0n'\\n\\n # Attempt authentication\\n try:\\n # create OAuthHandler object\\n self.auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n # set access token and secret\\n self.auth.set_access_token(access_token, access_token_secret)\\n # create tweepy API object to fetch tweets\\n self.api = tweepy.API(self.auth)\\n except:\\n print(\\\"Error: Authentication Failed\\\")\\n exit(-1)\",\n \"def __init__(self, username, password, **kwargs):\\n self.url = 'https://heywatch.com'\\n self.cli = httplib2.Http(**kwargs)\\n self.cli.add_credentials(username, password)\\n\\n self.headers = {\\n 'Accept': 'application/json',\\n 'User-Agent': 'HeyWatch py/1.0.1',\\n }\\n\\n self.account()\",\n \"def __create_api(self):\\n consumer_key = os.environ.get(\\\"CONSUMER_KEY\\\")\\n consumer_secret = os.environ.get(\\\"CONSUMER_SECRET\\\")\\n access_token = os.getenv(\\\"ACCESS_TOKEN\\\")\\n access_token_secret = os.environ.get(\\\"ACCESS_TOKEN_SECRET\\\")\\n\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, access_token_secret)\\n api = tweepy.API(\\n auth,\\n compression=True,\\n wait_on_rate_limit=True,\\n wait_on_rate_limit_notify=True,\\n )\\n try:\\n api.verify_credentials()\\n except Exception as e:\\n logging.error(\\\"Error creating API\\\", exc_info=True)\\n raise e\\n return api\",\n \"def _authorize(self):\\n auth = tweepy.OAuthHandler(self.keys[\\\"consumer_key\\\"], self.keys[\\\"consumer_secret\\\"])\\n auth.set_access_token(self.keys[\\\"access_token\\\"], self.keys[\\\"access_token_secret\\\"])\\n return tweepy.API(auth)\",\n \"def __init__(self):\\n self.load_objects()\\n super(TwitterMain,self).__init__()\",\n \"def register():\\n\\tglobal oauth_token, user_name\\n\\tuser_name = ''\\n\\trequest_token_url = 'https://api.twitter.com/oauth/request_token'\\n\\toauth_nonce = gen_oauth_nonce()\\n\\toauth_timestamp = gen_oauth_timestamp()\\n\\toauth_params = {\\n\\t\\t'oauth_consumer_key' : oauth_consumer_key,\\n\\t\\t'oauth_callback' : oauth_callback,\\n\\t\\t'oauth_signature_method' : oauth_signature_method,\\n\\t\\t'oauth_version' : oauth_version,\\n\\t\\t'oauth_nonce' : oauth_nonce,\\n\\t\\t'oauth_timestamp' : oauth_timestamp\\n\\t}\\n\\t# Build signature\\n\\toauth_signature = build_signature('POST', request_token_url, oauth_params)\\n\\toauth_params['oauth_signature'] = percent_encode(str(oauth_signature))\\n\\t# Connect\\n\\trequest = requests.post(request_token_url, '', headers={'Authorization': build_oauth_header(oauth_params)})\\n\\tif request.status_code == 200:\\n\\t\\tdata = urllib.parse.parse_qs(request.text)\\n\\t\\toauth_token = data['oauth_token'][0]\\n\\t\\toauth_token_secret = data['oauth_token_secret'][0]\\n\\t\\tprint('https://api.twitter.com/oauth/authorize?oauth_token='+oauth_token)\\n\\t\\tpin = input('pin:')\\n\\t\\taccess_token_url = 'https://api.twitter.com/oauth/access_token'\\n\\t\\trequest = post(access_token_url, {'oauth_verifier' : pin})\\n\\t\\tdata = urllib.parse.parse_qs(request.text)\\n\\t\\tuser_name = data['screen_name'][0]\\n\\t\\tuser_dir = users_dir + '/' + user_name\\n\\t\\tif not os.path.exists(user_dir):\\n\\t\\t\\tos.makedirs(user_dir)\\n\\t\\tfor varname in conf_files:\\n\\t\\t\\tpath = user_dir + '/' + varname\\n\\t\\t\\tf = open(path, 'w+')\\n\\t\\t\\tf.write(data[varname][0])\\n\\t\\t\\tf.close()\",\n \"def __init__(self, username=None, password=None, account_sid=None,\\n http_client=None, environment=None):\\n environment = environment or os.environ\\n \\n self.username = username or environment.get('TWILIO_ACCOUNT_SID')\\n \\\"\\\"\\\" :type : str \\\"\\\"\\\"\\n self.password = password or environment.get('TWILIO_AUTH_TOKEN')\\n \\\"\\\"\\\" :type : str \\\"\\\"\\\"\\n self.account_sid = account_sid or self.username\\n \\\"\\\"\\\" :type : str \\\"\\\"\\\"\\n \\n if not self.username or not self.password:\\n raise TwilioException(\\\"Credentials are required to create a TwilioClient\\\")\\n \\n self.auth = (self.username, self.password)\\n \\\"\\\"\\\" :type : tuple(str, str) \\\"\\\"\\\"\\n self.http_client = http_client or Httplib2Client()\\n \\\"\\\"\\\" :type : HttpClient \\\"\\\"\\\"\\n \\n # Domains\\n self._api = None\\n self._conversations = None\\n self._ip_messaging = None\\n self._lookups = None\\n self._monitor = None\\n self._pricing = None\\n self._taskrouter = None\\n self._trunking = None\",\n \"def __init__(self):\\n\\n\\t\\tself.account_sid = os.environ['TWILIO_ACCOUNT_SID']\\n\\t\\tself.auth_token = os.environ['TWILIO_AUTH_TOKEN']\\n\\t\\tself.twilio_phone_number = os.environ['TWILIO_PHONE_NUMBER']\\n\\t\\tself.client = Client(self.account_sid, self.auth_token)\\n\\n\\t\\tself.call_domain = 'http://twimlets.com/echo?Twiml='\",\n \"def __init__(self, public_key, private_key, token, token_secret, base_url='http://api.telldus.com'):\\n self.public_key = public_key\\n self.private_key = private_key\\n self.token = token\\n self.token_secret = token_secret\\n\\n self.base_url = base_url\\n\\n self.oauth = self.generate_temp_session()\",\n \"def __init__(self, **kwargs):\\n self._username = kwargs.get('username', current_app.config.get('WORDAI_API_EMAIL', None))\\n self._password = kwargs.get('password', current_app.config.get('WORDAI_API_PASSWORD', None))\\n self._hash = kwargs.get('hash', current_app.config.get('WORDAI_API_KEY', None))\",\n \"def __init__(self, consumer_key, consumer_secret, access_token, access_token_secret):\\n self.api = self.getAPI(consumer_key, consumer_secret, access_token, access_token_secret)\",\n \"def twitter(self, twitter):\\n\\n self._twitter = twitter\",\n \"def get_api():\\n consumer_api_key, consumer_secret_key, access_token, access_secret_token = get_keys()\\n return twitter.Api(consumer_key=consumer_api_key,\\n consumer_secret=consumer_secret_key,\\n access_token_key=access_token,\\n access_token_secret=access_secret_token)\",\n \"def twitter_factory(authenticator):\\n client = None\\n\\n def _client():\\n \\\"\\\"\\\" Creates and setups the twitter client if not already done.\\\"\\\"\\\"\\n nonlocal client\\n if not client:\\n client = twitter.Twitter(authenticator)\\n return client\\n\\n return _client # return the function that returns the client\",\n \"def auth(access_token, access_token_secret, consumer_key, consumer_secret):\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token,access_token_secret)\\n return auth\",\n \"def __init__(self, license_key: str = None, email: str = None, password: str = None, tim_url: str = 'https://timws.tangent.works/v4/api', api_key: str = 'a37b7c81-5a85-4eda-847d-d2d5ba33d2c8', access_token: str = None, logger: Logger = None):\\n if self.__logger is None:\\n self.__logger = logging.getLogger(__name__)\\n\\n self.set_tim_url(tim_url)\\n self.__api_key = api_key\\n\\n if access_token:\\n self.set_token(access_token)\\n self.__license_key = license_key\\n self.__email = email\\n self.__password = password\",\n \"def authorise(consumer_key, consumer_secret, access_token, access_token_secret):\\r\\n # Authorisation:\\r\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\r\\n auth.set_access_token(access_token, access_token_secret)\\r\\n\\r\\n # Creating api object:\\r\\n api = tweepy.API(auth)\\r\\n\\r\\n # Finally:\\r\\n return api\",\n \"def setUp(self):\\n self.twitter = Twitter(CUR_DIR + \\\"/test_crossfit.tweets\\\", CUR_DIR + \\\"/test_stop_words.txt\\\")\\n self.twitter.load_tweets_and_build_index()\\n\\n self.searcher = Searcher(self.twitter.tweets, self.twitter.stop_words)\",\n \"def __init__(self,consumer_key,consumer_secret):\\n\\t\\tself.CONSUMER_KEY = consumer_key\\n\\t\\tself.CONSUMER_SECRET = consumer_secret\\n\\t\\tself.token=None\\n\\t\\tself.secret=None\\n\\t\\tself.resource_owner_key=None\\n\\t\\tself.resource_owner_secret=None\",\n \"def __init__(self):\\n\\n self._authorization = None\\n self._last_used = datetime.utcnow() - timedelta(hours=10)\\n\\n self._resource_owner_key = None\\n self._resource_owner_secret = None\\n\\n self._consumer_key = etrade_config.oauth_consumer_key\\n self._consumer_secret = etrade_config.oath_consumer_secret\\n\\n self._auth_file_path = etrade_config.auth_file_path\\n self._user_name = etrade_config.user_name\\n self._user_pwd = etrade_config.user_pwd\",\n \"def __init__(self, username=None, password=None, apitoken=None):\\n self.__credentials = None\\n self.__headers = {}\\n if apitoken:\\n self.authenticate_by_token(apitoken)\\n if username and password:\\n self.authenticate(username, password)\",\n \"def __init__(self, oauth_consumer_token=None, oauth_access_token=None):\\n self.consumer_token = oauth_consumer_token\\n self.access_token = oauth_access_token\",\n \"def twitter_auth(k, s):\\n\\n auth = tweepy.AppAuthHandler(k, s)\\n api = tweepy.API(\\n auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True\\n )\\n\\n if (not api):\\n return None\\n else:\\n return api\",\n \"def __init__(self, apikey, secret):\\n self.apikey = apikey\\n self.secret = secret\",\n \"def init_from_settings(cls):\\n if cls._django_cached_obj:\\n return cls._django_cached_obj\\n api_obj = cls(settings.TWITTER_API_KEY, settings.TWITTER_API_SECRET)\\n cls._django_cached_obj = api_obj\\n return api_obj\",\n \"def get_api():\\n # Load auth information.\\n token = load_token()\\n\\n if token is None:\\n token_string = get_twitter_auth()\\n save_token(token_string)\\n token = tweepy.oauth.OAuthToken.from_string(token_string)\\n\\n try:\\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\\n auth.set_access_token(token.key, token.secret)\\n\\n api = tweepy.API(auth)\\n except tweepy.TweepError:\\n print (\\\"Error: Unable to get tweepy API, please try again.\\\")\\n sys.exit(1)\\n\\n return api\",\n \"def setup_class(cls):\\n initialize(api_key=API_KEY, app_key=APP_KEY, api_host=API_HOST)\",\n \"def __init__(self, tweet_data):\\n _hashtags = tweet_data['entities']['hashtags']\\n _str_date = tweet_data['created_at']\\n self.account = Account(tweet_data['user'])\\n self.date = self.format_date(_str_date)\\n self.hashtags = [\\\"#%s\\\" % (tag['text']) for tag in _hashtags]\\n self.likes = tweet_data['favorite_count']\\n # Note: replies number is only available with\\n # the Premium and Enterprise tier products.\\n # https://developer.twitter.com/en/docs/tweets/data-dictionary/overview/tweet-object # noqa\\n self.replies = 0\\n self.retweets = tweet_data['retweet_count']\\n self.text = tweet_data['text']\",\n \"def twitter_auth(consumer_key=None, consumer_secret=None, access_key=None, access_secret=None):\\n\\n if not consumer_key:\\n consumer_key = os.environ.get('T_CONSUMER_KEY', consumer_key)\\n if not consumer_secret:\\n consumer_secret = os.environ.get('T_CONSUMER_SECRET', consumer_secret)\\n if not access_key:\\n access_key = os.environ.get('T_ACCESS_KEY', access_key)\\n if not access_secret:\\n access_secret = os.environ.get('T_ACCESS_SECRET', access_secret)\\n\\n auth = [consumer_key, consumer_secret, access_key, access_secret]\\n\\n for credential in auth:\\n if not isinstance(credential, str):\\n raise TypeError(\\n \\\"credential must be string, got: %s\\\" % (type(credential)))\\n if len(credential) <= 0:\\n raise TypeError('invalid credential %s' % (credential))\\n\\n return auth\",\n \"def get_tweets():\\n\\n # Read bearer token from secrets file\\n with open(\\\"./secrets.yml\\\", \\\"r\\\") as f:\\n bearer_token = yaml.load(f, Loader=yaml.FullLoader)[\\\"BEARER_TOKEN\\\"]\\n\\n # Set start and end times as current time rounded down to nearest minute with supplied offset\\n dt_fmt = \\\"%Y-%m-%dT%H:%M:00Z\\\"\\n dt_now = datetime.datetime.now().replace(second=0, microsecond=0)\\n start_time_offset = int(sys.argv[1])\\n end_time_offset = int(sys.argv[2])\\n dt_end = dt_now - datetime.timedelta(minutes=end_time_offset)\\n dt_start = dt_now - datetime.timedelta(minutes=start_time_offset)\\n dt_end = dt_end.strftime(dt_fmt)\\n dt_start = dt_start.strftime(dt_fmt)\\n\\n # Make request, checking for mentions in specified time period\\n logging.info(\\\"Getting mentions from Twitter\\\")\\n uri = \\\"https://api.twitter.com/2/tweets/search/recent\\\"\\n headers = {\\\"Authorization\\\": f\\\"Bearer {bearer_token}\\\"}\\n query = {\\\"query\\\": f\\\"@{ACCOUNT_NAME}\\\",\\n \\\"expansions\\\" : \\\"author_id\\\",\\n \\\"user.fields\\\" : \\\"username\\\",\\n \\\"start_time\\\" : dt_start,\\n \\\"end_time\\\" : dt_end}\\n response = requests.get(uri, headers=headers, params=query)\\n\\n # Make connection to local database\\n connection = sqlite3.connect(\\\"../database/procrystaldb.db\\\")\\n cursor = connection.cursor()\\n\\n # Get current total number of rows in database\\n cursor.execute(\\\"SELECT COUNT(*) FROM Twitter;\\\")\\n initial_rows = cursor.fetchall()[0][0]\\n\\n # Get usernames and tweet ids from tweets and save to database\\n if response.status_code == 200:\\n content = response.json()\\n num_results = content[\\\"meta\\\"][\\\"result_count\\\"]\\n if num_results > 0:\\n # First get dictionary of usernames\\n user_id_to_name = {}\\n for user in content[\\\"includes\\\"][\\\"users\\\"]:\\n user_id_to_name[user[\\\"id\\\"]] = user[\\\"username\\\"]\\n # Then get tweet id, username and save to database\\n for result in content[\\\"data\\\"]:\\n # if KEYWORD in result[\\\"text\\\"].lower():\\n tweet_id = result[\\\"id\\\"]\\n username = user_id_to_name[result[\\\"author_id\\\"]]\\n sql_insert = f\\\"\\\"\\\"\\n INSERT OR IGNORE INTO Twitter (tweet_id, username, reply_sent)\\n VALUES ('{tweet_id}', '{username}', false);\\n \\\"\\\"\\\"\\n cursor.execute(sql_insert)\\n logging.info(f\\\"Mentions fetched: {num_results}\\\")\\n else:\\n logging.error(f\\\"Get mentions errored with: {response.json()}\\\")\\n\\n # Get final total number of rows in database and therefore number of rows added\\n cursor.execute(\\\"SELECT COUNT(*) FROM Twitter;\\\")\\n final_rows = cursor.fetchall()[0][0]\\n rows_added = final_rows - initial_rows\\n logging.info(f\\\"New mentions added: {rows_added}\\\")\\n\\n # Close database connection\\n connection.commit()\\n connection.close()\\n\\n return rows_added\",\n \"def twitter_api(input_encoding=\\\"utf-8\\\"):\\n\\n consumer_key = get_consumer_key()\\n consumer_secret = get_consumer_secret()\\n access_key, access_secret = \\\\\\n get_access_tokens(consumer_key, consumer_secret)\\n\\n api = twitter.Api(consumer_key=consumer_key,\\n consumer_secret=consumer_secret, access_token_key=access_key,\\n access_token_secret=access_secret, input_encoding=input_encoding,\\n debugHTTP=False)\\n\\n return api\",\n \"def get_api():\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, access_secret)\\n api = tweepy.API(auth)\\n\\n return api\",\n \"def __init__(self, id_: str, bio: str) -> None:\\n\\n # YOUR CODE HERE\\n self.userid = id_\\n self.bio = bio\\n self.tweets = []\",\n \"def __init__(self, authenticator, username, password):\\n super(ScriptAuthorizer, self).__init__(authenticator)\\n self._username = username\\n self._password = password\",\n \"def __init__(self, config):\\n self._slack_client = self._connect(config[\\\"slack_bot_token\\\"])\\n self.bot_id = self._get_user_id()\\n self.default_channel = config[\\\"default_channel\\\"]\",\n \"def get_api(credsfile = DEFAULT_TWITTER_CREDS_PATH):\\n fn = os.getcwd() + credsfile\\n c = json.load(open(fn, \\\"r\\\"))\\n # Get authentication token\\n auth = tweepy.OAuthHandler(consumer_key = c['consumer_key'],\\n consumer_secret = c['consumer_secret'])\\n auth.set_access_token(c['access_token'], c['access_token_secret'])\\n # create an API handler\\n return tweepy.API(auth)\",\n \"def __init__(self, credentials):\\r\\n if not has_httplib2:\\r\\n raise ImportError(\\\"No module named httplib2\\\")\\r\\n super(GAPDecoratorAuthMethod, self).__init__()\\r\\n self._http = None\\r\\n self._credentials = credentials\\r\\n self._action_token = None\",\n \"def get_twitter_token():\\n return None\",\n \"def get_api(cfg):\\n auth = tweepy.OAuthHandler(cfg['consumer_key'], cfg['consumer_secret'])\\n auth.set_access_token(cfg['access_token'], cfg['access_token_secret'])\\n return tweepy.API(auth)\",\n \"def access_api():\\n\\n auth = tweepy.OAuthHandler(Consumer_key, Consumer_key_secret)\\n auth.set_access_token(Access_token, Access_token_secret)\\n api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)\\n\\n return api\",\n \"def api_authentication(token, secret):\\n\\n api = twitter.Twitter(auth=twitter.OAuth(token, secret,\\n CONSUMER_KEY, CONSUMER_SECRET))\\n if not api:\\n print(\\\"Authentication failed, try running the script one more time\\\")\\n\\n # delete data from the configuration file to force a new\\n # authentication next time\\n os.remove(TOKEN_FILE)\\n return None\\n\\n return api\",\n \"def __init__(self):\\n self.sp, self.user = self.init_auth_client()\\n self.logger = logging.getLogger(__name__)\",\n \"def __init__(self, apiKey, apiSecret):\\n self.apiKey = apiKey\\n self.apiSecret = apiSecret\",\n \"def authenticate():\\n auth = OAuthHandler(config.CONSUMER_API_KEY, config.CONSUMER_API_SECRET)\\n auth.set_access_token(config.ACCESS_TOKEN, config.ACCESS_TOKEN_SECRET)\\n\\n return auth\",\n \"def authenticate():\\n auth = OAuthHandler(config.CONSUMER_API_KEY, config.CONSUMER_API_SECRET)\\n auth.set_access_token(config.ACCESS_TOKEN, config.ACCESS_TOKEN_SECRET)\\n\\n return auth\",\n \"def get_twitter_auth():\\n # Authenticate if information not found\\n auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)\\n\\n # Get Auth URL\\n try:\\n redirect_url = auth.get_authorization_url()\\n except tweepy.TweepError:\\n print \\\"Error: Failed to get request token.\\\"\\n sys.exit(1)\\n\\n # Get Verifier\\n print (\\\"Visit this URL and confirm authentication by typing in the \\\"\\n \\\"PIN given by Twitter.\\\")\\n webbrowser.open_new_tab(redirect_url)\\n verifier = raw_input(\\\"Twitter Verification PIN: \\\")\\n\\n # Get token\\n try:\\n token = auth.get_access_token(verifier=verifier)\\n except tweepy.TweepError:\\n print (\\\"Error: Unable to get access tokens from verifier, \\\"\\n \\\"please try again.\\\")\\n\\n return token.to_string()\",\n \"def extract_tweets(consumer_key,consumer_secret,access_token,access_token_secret,search_key):\\n # Step 1 - Authenticate\\n consumer_key= str(consumer_key)\\n consumer_secret= str(consumer_secret)\\n\\n access_token=str(access_token)\\n access_token_secret=str(access_token_secret)\\n\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, access_token_secret)\\n\\n api = tweepy.API(auth)\\n\\n #Step 3 - Retrieve Tweets\\n public_tweets = api.search(search_key)\\n tweets_list=[]\\n for tweet in public_tweets:\\n tweets_list.append(tweet.text)\\n return tweets_list\",\n \"def __init__(self, api_url, credentials):\\n self.api_url = api_url\\n while self.api_url.endswith(\\\"/\\\"):\\n self.api_url = self.api_url[:-1]\\n self.credentials = credentials\\n self.username = credentials.username\\n self.token = credentials.token\",\n \"def SetUp(self) :\\n self.new_credential = Credential(\\\"snapchat\\\", \\\"chat@gmail.com\\\", \\\"Chat001\\\") # new credential\",\n \"def __init__(self, token=None, token_path=\\\"tokens.txt\\\", username=None, password=None,\\n grant_type=\\\"api-password\\\", client_id=\\\"brandwatch-api-client\\\",\\n api_url=\\\"https://api.brandwatch.com/\\\"):\\n self.api_url = api_url\\n self.oauthpath = \\\"oauth/token\\\"\\n\\n if token:\\n self._update_by_test_auth(username, token)\\n self._write_auth(token_path)\\n elif username is not None and password is not None:\\n self._update_by_auth(username, password, token_path, grant_type, client_id)\\n self._write_auth(token_path)\\n elif username is not None:\\n self._read_auth(username, token_path)\\n else:\\n raise KeyError(\\\"Must provide valid token, username and password,\\\"\\n \\\" or username and path to token file\\\")\",\n \"def __init__(self, auth_key, auth_secret):\\n\\n self._auth_key = auth_key\\n self._auth_secret = auth_secret\",\n \"def __init__(self, username, password): \\n self.login_params = {\\n 'GA3T': _random_id(11), # unique identifiers for session\\n 'GALX': _random_id(11), # unique identifiers for session\\n \\\"continue\\\": 'http://www.google.com/trends',\\n 'nui': '1',\\n 'hl': 'en-US',\\n 'rmShown': '1',\\n \\\"PersistentCookie\\\": \\\"yes\\\",\\n \\\"Email\\\": username,\\n \\\"Passwd\\\": password,\\n 'service': 'trends' \\n }\\n self.headers = [(\\\"Content-type\\\", \\\"application/x-www-form-urlencoded\\\"),\\n ('User-Agent', 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'),\\n (\\\"Accept\\\", \\\"text/plain\\\")]\\n self.url_ServiceLoginBoxAuth = 'https://www.google.com/accounts/ServiceLoginBoxAuth'\\n self.url_Export = 'http://www.google.com/trends/viz'\\n self.header_dictionary = {}\\n self._connect()\",\n \"def __init__(self, username = None, password = None):\\n self.username = config['AUTH']['USERNAME']\\n self.password = config['AUTH']['PASSWORD']\\n self.login = config['URL']['LOGIN']\\n self.nav_url = config['URL']['NAV']\\n self.tag_url = config['URL']['TAGS']\\n self.direct_url = config['URL']['DM']\\n self.driver = webdriver.Chrome(config['ENVIRONMENT']['CHROMEDRIVER'])\\n self.stay_logged = False\\n self.api = InstagramAPI(self.username, self.password)\",\n \"def __init__(self):\\n self.api_key = secret.TMDB_API_KEY\",\n \"def __init__(self, api_key, client_id=None, client_secret=None):\\n self.api = API(api_key)\\n self._manifest = Manifest(self.api)\\n self.oauth = OAuth(client_id, client_secret)\",\n \"def on_activate(self):\\n \\n self.consumer_key = get_global_option('twitter-consumer-key')\\n self.consumer_secret = get_global_option('twitter-consumer-secret')\\n self.access_token = get_global_option('twitter-access-token')\\n self.token_secret = get_global_option('twitter-token-secret')\\n self.api = twitter.Api(consumer_key=self.consumer_key,\\n consumer_secret=self.consumer_secret,\\n access_token_key=self.access_token,\\n access_token_secret=self.token_secret) \\n \\n check_time = get_global_option(\\\"twitter-check-time\\\")\\n if check_time:\\n check_time = int(check_time)\\n else:\\n check_time = 30\\n logger.info(\\\"Twitter check timer is every {} seconds\\\".format(check_time))\\n self.timer.start(check_time, now=False)\\n return (True, None)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8182253","0.7952092","0.78614396","0.78030735","0.7798696","0.7798696","0.77020943","0.7680609","0.76543593","0.75703394","0.75466865","0.7542911","0.7506404","0.74154884","0.7342675","0.72171617","0.71095985","0.71095985","0.71095985","0.71095985","0.7100531","0.7059411","0.7019133","0.693053","0.6928241","0.69073683","0.6903759","0.6863622","0.6779661","0.66828305","0.66548723","0.66398346","0.6560159","0.6523131","0.65211564","0.6488497","0.6461172","0.6418129","0.6331208","0.63274705","0.6304394","0.6291799","0.6274051","0.62598324","0.6245166","0.62039167","0.6198254","0.61935556","0.61935294","0.6189784","0.6186741","0.6170103","0.61684763","0.61250573","0.6038413","0.6016735","0.6002895","0.6001168","0.59543943","0.591923","0.5888464","0.58870876","0.5867877","0.58605593","0.5855017","0.5850431","0.5834663","0.5827498","0.5814449","0.5798018","0.57963616","0.5796068","0.5786384","0.57548267","0.57353806","0.5721668","0.56922287","0.5692226","0.5687593","0.5679658","0.56697744","0.5666943","0.5662285","0.56525314","0.5647919","0.564272","0.5618504","0.56096053","0.56096053","0.56095743","0.56020415","0.55966073","0.5593127","0.55853546","0.5572557","0.5571922","0.55690986","0.5556357","0.55551285","0.5552925"],"string":"[\n \"0.8182253\",\n \"0.7952092\",\n \"0.78614396\",\n \"0.78030735\",\n \"0.7798696\",\n \"0.7798696\",\n \"0.77020943\",\n \"0.7680609\",\n \"0.76543593\",\n \"0.75703394\",\n \"0.75466865\",\n \"0.7542911\",\n \"0.7506404\",\n \"0.74154884\",\n \"0.7342675\",\n \"0.72171617\",\n \"0.71095985\",\n \"0.71095985\",\n \"0.71095985\",\n \"0.71095985\",\n \"0.7100531\",\n \"0.7059411\",\n \"0.7019133\",\n \"0.693053\",\n \"0.6928241\",\n \"0.69073683\",\n \"0.6903759\",\n \"0.6863622\",\n \"0.6779661\",\n \"0.66828305\",\n \"0.66548723\",\n \"0.66398346\",\n \"0.6560159\",\n \"0.6523131\",\n \"0.65211564\",\n \"0.6488497\",\n \"0.6461172\",\n \"0.6418129\",\n \"0.6331208\",\n \"0.63274705\",\n \"0.6304394\",\n \"0.6291799\",\n \"0.6274051\",\n \"0.62598324\",\n \"0.6245166\",\n \"0.62039167\",\n \"0.6198254\",\n \"0.61935556\",\n \"0.61935294\",\n \"0.6189784\",\n \"0.6186741\",\n \"0.6170103\",\n \"0.61684763\",\n \"0.61250573\",\n \"0.6038413\",\n \"0.6016735\",\n \"0.6002895\",\n \"0.6001168\",\n \"0.59543943\",\n \"0.591923\",\n \"0.5888464\",\n \"0.58870876\",\n \"0.5867877\",\n \"0.58605593\",\n \"0.5855017\",\n \"0.5850431\",\n \"0.5834663\",\n \"0.5827498\",\n \"0.5814449\",\n \"0.5798018\",\n \"0.57963616\",\n \"0.5796068\",\n \"0.5786384\",\n \"0.57548267\",\n \"0.57353806\",\n \"0.5721668\",\n \"0.56922287\",\n \"0.5692226\",\n \"0.5687593\",\n \"0.5679658\",\n \"0.56697744\",\n \"0.5666943\",\n \"0.5662285\",\n \"0.56525314\",\n \"0.5647919\",\n \"0.564272\",\n \"0.5618504\",\n \"0.56096053\",\n \"0.56096053\",\n \"0.56095743\",\n \"0.56020415\",\n \"0.55966073\",\n \"0.5593127\",\n \"0.55853546\",\n \"0.5572557\",\n \"0.5571922\",\n \"0.55690986\",\n \"0.5556357\",\n \"0.55551285\",\n \"0.5552925\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6326717"},"document_rank":{"kind":"string","value":"40"}}},{"rowIdx":25994,"cells":{"query":{"kind":"string","value":"Verifies if the given tokens are valid"},"document":{"kind":"string","value":"def verify_credentials(self):\n try:\n self.api.VerifyCredentials()\n logging.info('Successfully verified')\n return True\n except TwitterError as e:\n logging.error('Error verifying credentials: %s', e.message[0]['message'])\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 test_unused_token_is_valid(self):\n assert self.token.is_valid()","async def validate_token(self, token):","def _check_tokens(number_token=None, name_token=None, gpe_token=None):\n assert number_token is None or number_token == number_token.lower(), \\\n \"Tokens need to be lowercase: %s\" % number_token\n assert name_token is None or name_token == name_token.lower(), \\\n \"Tokens need to be lowercase: %s\" % name_token\n assert gpe_token is None or gpe_token == gpe_token.lower(), \\\n \"Tokens need to be lowercase: %s\" % gpe_token","def testIsValidToken(self):\n self.assertTrue(TokenResource.isValidToken('aValidToken'),\n msg='Expected isValidToken to accept a valid token.')\n self.assertTrue(TokenResource.isValidToken(TokenResource.VALID_TOKEN_CHARS),\n msg='Expected isValidToken to accept a valid token.')\n self.assertFalse(TokenResource.isValidToken('Token!'),\n msg='Expected isValidToken to accept an invalid token.')\n self.assertFalse(TokenResource.isValidToken('an invalid Token'),\n msg='Expected isValidToken to accept an invalid token.')","def test_invalid_tokens(self):\n self.assertTrue(1 + 1)","def test_regex_valid_tokens(self):\n # Don't worry, these tokens have been invalidated.\n tokens = (\n \"NDcyMjY1OTQzMDYy_DEzMz-y.XsyRkw.VXmErH7j511turNpfURmb0rVNm8\",\n \"NDcyMjY1OTQzMDYyNDEzMzMy.Xrim9Q.Ysnu2wacjaKs7qnoo46S8Dm2us8\",\n \"NDc1MDczNjI5Mzk5NTQ3OTA0.XsyR-w.sJf6omBPORBPju3WJEIAcwW9Zds\",\n \"NDY3MjIzMjMwNjUwNzc3NjQx.XsySD_.s45jqDV_Iisn-symw0yDRrk_jf4\",\n )\n\n for token in tokens:\n with self.subTest(token=token):\n results = token_remover.TOKEN_RE.fullmatch(token)\n self.assertIsNotNone(results, f\"{token} was not matched by the regex\")","def __valid_token_format(self, token):\n if len(token) != self.TOKEN_LENGTH * 2:\n return False\n for c in token:\n if c not in '01234567890abcdef':\n return False\n return True","def verify_token(self, token):\n return False","def test_live_thread_token_is_valid(self):\n assert self.token.is_valid()","def check_token_structure(data):\n assert \"token\" in data\n token_structure = data[\"token\"]\n\n assert \"access_token\" in token_structure\n assert \"token_type\" in token_structure\n assert \"expires_in\" in token_structure","def test_rejects_invalid_tokens(self):\n config.set(xsrf_token_key='abcdef')\n tool = utils.XsrfTool()\n self.assertFalse(tool.verify_token(\n 'ThisTokenDoesNotEvenHaveASlash', 12345, 'test_action'))\n timestamp = utils.get_timestamp(XsrfToolTests.TEST_NOW)\n self.assertFalse(\n tool.verify_token('NotTheRightDigest/%f' % timestamp, 12345,\n 'test_action'))","def validateIdentifier(self, tokens):\n return tokens","def check_for_token(token):\n try:\n decode_token(token)\n return True\n except:\n return False","def test_regex_invalid_tokens(self):\n tokens = (\n \"\",\n \"lemon wins\",\n \"..\",\n \"x.y\",\n \"x.y.\",\n \".y.z\",\n \".y.\",\n \"..z\",\n \"x..z\",\n \" . . \",\n \"\\n.\\n.\\n\",\n \"hellö.world.bye\",\n \"base64.nötbåse64.morebase64\",\n \"19jd3J.dfkm3d.€víł§tüff\",\n )\n\n for token in tokens:\n with self.subTest(token=token):\n results = token_remover.TOKEN_RE.findall(token)\n self.assertEqual(len(results), 0)","def validate(cls, token, user, service):\n expected = cls.generate(user, service)\n return token == expected","def _check_token(self, token):\n token = token.lower()\n check = re.sub(r'((^|\\')([a-z]+))+$', '', token)\n if check == '':\n return True\n return False","def verifySpaceToken(spacetoken, setokens):\n\n status = False\n\n setokenslist = setokens.split(\",\")\n if spacetoken in setokenslist:\n tolog(\"Verified space token: %s\" % (spacetoken))\n status = True\n else:\n if spacetoken == \"\":\n tolog(\"Warning: ended up with empty space token\")\n elif \"dst:\" in spacetoken:\n tolog(\"Will not verify GROUPDISK space token: %s\" % (spacetoken))\n status = True\n else:\n tolog(\"Warning: Space token %s is not among allowed values: %s\" % (spacetoken, str(setokenslist)))\n\n return status","def validateOperator(self, tokens):\n return tokens","def validate_token(self, payload, headers, request):\n token = headers.get(self.TOKEN_NAME, \"\")\n\n # no token\n if self.verify == VerificationMethod.NONE:\n # do nothing as no method was chosen\n pass\n\n # static token\n elif self.verify == VerificationMethod.TOKEN:\n if not compare_digest(token, self.token):\n raise PermissionDenied(self.MESSAGE_TOKEN_ERROR)\n\n # hmac token\n elif self.verify == VerificationMethod.HMAC:\n digest = hmac.new(self.secret.encode('utf-8'), request.body, hashlib.sha256).digest()\n computed_hmac = base64.b64encode(digest)\n if not hmac.compare_digest(computed_hmac, token.encode('utf-8')):\n raise PermissionDenied(self.MESSAGE_TOKEN_ERROR)\n\n return True","def verify_token(event):\n if event['token'] != VERIFICATION_TOKEN:\n print('Presented with invalid token - ignoring message...')\n return False\n return True","def _check_tokens_are_valid(format_string, message):\n named_tokens = re.findall(r\"{(\\w*)}\", format_string)\n invalid_tokens = [x for x in named_tokens if x.lower() not in _valid_tokens]\n if invalid_tokens:\n msg = message\n msg += \" [{0}]. \".format(\", \".join(invalid_tokens))\n msg += 'Did you check your \"modules.yaml\" configuration?'\n raise RuntimeError(msg)","def test_missing_multiple_tokens(self):\n self.helper_test_evaluate_raises(\n 'A or (B and (C and not D))',\n expected_exc_type=MissingSymbolError,\n A=0,\n D=1)","def check_token(token):\n valid = re.compile(r\"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-\"\n r\"[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$\")\n\n return valid.match(token)","def test_validate_token_returns_false_for_invalid_token(self, demo_app):\n demo_app.config.get.return_value = self.jwt_key\n token = jwt.encode({}, self.jwt_key_2, algorithm='HS256')\n\n self.assertFalse(\n validate_token(token)[0],\n 'Failed to recognise invalidate token.'\n )","def fin_check(expresion):\n for token in set(bin_tokens.values()).union(set(un_tokens.values())):\n if token in expresion:\n return False\n return True","def test_is_valid_timestamp_valid(self):\n timestamps = (\n \"XsyRkw\",\n \"Xrim9Q\",\n \"XsyR-w\",\n \"XsySD_\",\n \"Dn9r_A\",\n )\n\n for timestamp in timestamps:\n with self.subTest(timestamp=timestamp):\n result = TokenRemover.is_valid_timestamp(timestamp)\n self.assertTrue(result)","def CheckToken(self, token, state):\n # Store some convenience variables\n first_in_line = token.IsFirstInLine()\n last_in_line = token.IsLastInLine()\n last_non_space_token = state.GetLastNonSpaceToken()\n\n type = token.type\n\n # Process the line change.\n if not self._is_html and FLAGS.strict:\n # TODO(robbyw): Support checking indentation in HTML files.\n indentation_errors = self._indentation.CheckToken(token, state)\n for indentation_error in indentation_errors:\n self._HandleError(*indentation_error)\n\n if last_in_line:\n self._CheckLineLength(token, state)\n\n if type == Type.PARAMETERS:\n # Find missing spaces in parameter lists.\n if self.MISSING_PARAMETER_SPACE.search(token.string):\n self._HandleError(errors.MISSING_SPACE, 'Missing space after \",\"',\n token)\n\n # Find extra spaces at the beginning of parameter lists. Make sure\n # we aren't at the beginning of a continuing multi-line list.\n if not first_in_line:\n space_count = len(token.string) - len(token.string.lstrip())\n if space_count:\n self._HandleError(errors.EXTRA_SPACE, 'Extra space after \"(\"',\n token, Position(0, space_count))\n\n elif (type == Type.START_BLOCK and\n token.metadata.context.type == Context.BLOCK):\n self._CheckForMissingSpaceBeforeToken(token)\n\n elif type == Type.END_BLOCK:\n # This check is for object literal end block tokens, but there is no need\n # to test that condition since a comma at the end of any other kind of\n # block is undoubtedly a parse error.\n last_code = token.metadata.last_code\n if last_code.IsOperator(','):\n self._HandleError(errors.COMMA_AT_END_OF_LITERAL,\n 'Illegal comma at end of object literal', last_code,\n Position.All(last_code.string))\n\n if state.InFunction() and state.IsFunctionClose():\n is_immediately_called = (token.next and\n token.next.type == Type.START_PAREN)\n if state.InTopLevelFunction():\n # When the function was top-level and not immediately called, check\n # that it's terminated by a semi-colon.\n if state.InAssignedFunction():\n if not is_immediately_called and (last_in_line or\n not token.next.type == Type.SEMICOLON):\n self._HandleError(errors.MISSING_SEMICOLON_AFTER_FUNCTION,\n 'Missing semicolon after function assigned to a variable',\n token, Position.AtEnd(token.string))\n else:\n if not last_in_line and token.next.type == Type.SEMICOLON:\n self._HandleError(errors.ILLEGAL_SEMICOLON_AFTER_FUNCTION,\n 'Illegal semicolon after function declaration',\n token.next, Position.All(token.next.string))\n\n if (state.InInterfaceMethod() and last_code.type != Type.START_BLOCK):\n self._HandleError(errors.INTERFACE_METHOD_CANNOT_HAVE_CODE,\n 'Interface methods cannot contain code', last_code)\n\n elif (state.IsBlockClose() and\n token.next and token.next.type == Type.SEMICOLON):\n self._HandleError(errors.REDUNDANT_SEMICOLON,\n 'No semicolon is required to end a code block',\n token.next, Position.All(token.next.string))\n\n elif type == Type.SEMICOLON:\n if token.previous and token.previous.type == Type.WHITESPACE:\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \";\"',\n token.previous, Position.All(token.previous.string))\n\n if token.next and token.next.line_number == token.line_number:\n if token.metadata.context.type != Context.FOR_GROUP_BLOCK:\n # TODO(robbyw): Error about no multi-statement lines.\n pass\n\n elif token.next.type not in (\n Type.WHITESPACE, Type.SEMICOLON, Type.END_PAREN):\n self._HandleError(errors.MISSING_SPACE,\n 'Missing space after \";\" in for statement',\n token.next,\n Position.AtBeginning())\n\n last_code = token.metadata.last_code\n if last_code and last_code.type == Type.SEMICOLON:\n # Allow a single double semi colon in for loops for cases like:\n # for (;;) { }.\n # NOTE(user): This is not a perfect check, and will not throw an error\n # for cases like: for (var i = 0;; i < n; i++) {}, but then your code\n # probably won't work either.\n for_token = tokenutil.CustomSearch(last_code,\n lambda token: token.type == Type.KEYWORD and token.string == 'for',\n end_func=lambda token: token.type == Type.SEMICOLON,\n distance=None,\n reverse=True)\n\n if not for_token:\n self._HandleError(errors.REDUNDANT_SEMICOLON, 'Redundant semicolon',\n token, Position.All(token.string))\n\n elif type == Type.START_PAREN:\n if token.previous and token.previous.type == Type.KEYWORD:\n self._HandleError(errors.MISSING_SPACE, 'Missing space before \"(\"',\n token, Position.AtBeginning())\n elif token.previous and token.previous.type == Type.WHITESPACE:\n before_space = token.previous.previous\n if (before_space and before_space.line_number == token.line_number and\n before_space.type == Type.IDENTIFIER):\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \"(\"',\n token.previous, Position.All(token.previous.string))\n\n elif type == Type.START_BRACKET:\n if (not first_in_line and token.previous.type == Type.WHITESPACE and\n last_non_space_token and\n last_non_space_token.type in Type.EXPRESSION_ENDER_TYPES):\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \"[\"',\n token.previous, Position.All(token.previous.string))\n # If the [ token is the first token in a line we shouldn't complain\n # about a missing space before [. This is because some Ecma script\n # languages allow syntax like:\n # [Annotation]\n # class MyClass {...}\n # So we don't want to blindly warn about missing spaces before [.\n # In the the future, when rules for computing exactly how many spaces\n # lines should be indented are added, then we can return errors for\n # [ tokens that are improperly indented.\n # For example:\n # var someVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongVariableName =\n # [a,b,c];\n # should trigger a proper indentation warning message as [ is not indented\n # by four spaces.\n elif (not first_in_line and token.previous and\n not token.previous.type in (\n [Type.WHITESPACE, Type.START_PAREN, Type.START_BRACKET] +\n Type.EXPRESSION_ENDER_TYPES)):\n self._HandleError(errors.MISSING_SPACE, 'Missing space before \"[\"',\n token, Position.AtBeginning())\n\n elif type in (Type.END_PAREN, Type.END_BRACKET):\n # Ensure there is no space before closing parentheses, except when\n # it's in a for statement with an omitted section, or when it's at the\n # beginning of a line.\n if (token.previous and token.previous.type == Type.WHITESPACE and\n not token.previous.IsFirstInLine() and\n not (last_non_space_token and last_non_space_token.line_number ==\n token.line_number and\n last_non_space_token.type == Type.SEMICOLON)):\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \"%s\"' %\n token.string, token.previous, Position.All(token.previous.string))\n\n if token.type == Type.END_BRACKET:\n last_code = token.metadata.last_code\n if last_code.IsOperator(','):\n self._HandleError(errors.COMMA_AT_END_OF_LITERAL,\n 'Illegal comma at end of array literal', last_code,\n Position.All(last_code.string))\n\n elif type == Type.WHITESPACE:\n if self.ILLEGAL_TAB.search(token.string):\n if token.IsFirstInLine():\n self._HandleError(errors.ILLEGAL_TAB,\n 'Illegal tab in whitespace before \"%s\"' % token.next.string,\n token, Position.All(token.string))\n else:\n self._HandleError(errors.ILLEGAL_TAB,\n 'Illegal tab in whitespace after \"%s\"' % token.previous.string,\n token, Position.All(token.string))\n\n # Check whitespace length if it's not the first token of the line and\n # if it's not immediately before a comment.\n if last_in_line:\n # Check for extra whitespace at the end of a line.\n self._HandleError(errors.EXTRA_SPACE, 'Extra space at end of line',\n token, Position.All(token.string))\n elif not first_in_line and not token.next.IsComment():\n if token.length > 1:\n self._HandleError(errors.EXTRA_SPACE, 'Extra space after \"%s\"' %\n token.previous.string, token,\n Position(1, len(token.string) - 1))\n\n elif type == Type.OPERATOR:\n last_code = token.metadata.last_code\n\n if not self._ExpectSpaceBeforeOperator(token):\n if (token.previous and token.previous.type == Type.WHITESPACE and\n last_code and last_code.type in (Type.NORMAL, Type.IDENTIFIER)):\n self._HandleError(errors.EXTRA_SPACE,\n 'Extra space before \"%s\"' % token.string, token.previous,\n Position.All(token.previous.string))\n\n elif (token.previous and\n not token.previous.IsComment() and\n token.previous.type in Type.EXPRESSION_ENDER_TYPES):\n self._HandleError(errors.MISSING_SPACE,\n 'Missing space before \"%s\"' % token.string, token,\n Position.AtBeginning())\n\n # Check that binary operators are not used to start lines.\n if ((not last_code or last_code.line_number != token.line_number) and\n not token.metadata.IsUnaryOperator()):\n self._HandleError(errors.LINE_STARTS_WITH_OPERATOR,\n 'Binary operator should go on previous line \"%s\"' % token.string,\n token)\n\n elif type == Type.DOC_FLAG:\n flag = token.attached_object\n\n if flag.flag_type == 'bug':\n # TODO(robbyw): Check for exactly 1 space on the left.\n string = token.next.string.lstrip()\n string = string.split(' ', 1)[0]\n\n if not string.isdigit():\n self._HandleError(errors.NO_BUG_NUMBER_AFTER_BUG_TAG,\n '@bug should be followed by a bug number', token)\n\n elif flag.flag_type == 'suppress':\n if flag.type is None:\n # A syntactically invalid suppress tag will get tokenized as a normal\n # flag, indicating an error.\n self._HandleError(errors.INCORRECT_SUPPRESS_SYNTAX,\n 'Invalid suppress syntax: should be @suppress {errortype}. '\n 'Spaces matter.', token)\n elif flag.type not in state.GetDocFlag().SUPPRESS_TYPES:\n self._HandleError(errors.INVALID_SUPPRESS_TYPE,\n 'Invalid suppression type: %s' % flag.type,\n token)\n\n elif FLAGS.strict and flag.flag_type == 'author':\n # TODO(user): In non strict mode check the author tag for as much as\n # it exists, though the full form checked below isn't required.\n string = token.next.string\n result = self.AUTHOR_SPEC.match(string)\n if not result:\n self._HandleError(errors.INVALID_AUTHOR_TAG_DESCRIPTION,\n 'Author tag line should be of the form: '\n '@author foo@somewhere.com (Your Name)',\n token.next)\n else:\n # Check spacing between email address and name. Do this before\n # checking earlier spacing so positions are easier to calculate for\n # autofixing.\n num_spaces = len(result.group(2))\n if num_spaces < 1:\n self._HandleError(errors.MISSING_SPACE,\n 'Missing space after email address',\n token.next, Position(result.start(2), 0))\n elif num_spaces > 1:\n self._HandleError(errors.EXTRA_SPACE,\n 'Extra space after email address',\n token.next,\n Position(result.start(2) + 1, num_spaces - 1))\n\n # Check for extra spaces before email address. Can't be too few, if\n # not at least one we wouldn't match @author tag.\n num_spaces = len(result.group(1))\n if num_spaces > 1:\n self._HandleError(errors.EXTRA_SPACE,\n 'Extra space before email address',\n token.next, Position(1, num_spaces - 1))\n\n elif (flag.flag_type in state.GetDocFlag().HAS_DESCRIPTION and\n not self._limited_doc_checks):\n if flag.flag_type == 'param':\n if flag.name is None:\n self._HandleError(errors.MISSING_JSDOC_PARAM_NAME,\n 'Missing name in @param tag', token)\n\n if not flag.description or flag.description is None:\n flag_name = token.type\n if 'name' in token.values:\n flag_name = '@' + token.values['name']\n self._HandleError(errors.MISSING_JSDOC_TAG_DESCRIPTION,\n 'Missing description in %s tag' % flag_name, token)\n else:\n self._CheckForMissingSpaceBeforeToken(flag.description_start_token)\n\n # We want punctuation to be inside of any tags ending a description,\n # so strip tags before checking description. See bug 1127192. Note\n # that depending on how lines break, the real description end token\n # may consist only of stripped html and the effective end token can\n # be different.\n end_token = flag.description_end_token\n end_string = htmlutil.StripTags(end_token.string).strip()\n while (end_string == '' and not\n end_token.type in Type.FLAG_ENDING_TYPES):\n end_token = end_token.previous\n if end_token.type in Type.FLAG_DESCRIPTION_TYPES:\n end_string = htmlutil.StripTags(end_token.string).rstrip()\n\n if not (end_string.endswith('.') or end_string.endswith('?') or\n end_string.endswith('!')):\n # Find the position for the missing punctuation, inside of any html\n # tags.\n desc_str = end_token.string.rstrip()\n while desc_str.endswith('>'):\n start_tag_index = desc_str.rfind('<')\n if start_tag_index < 0:\n break\n desc_str = desc_str[:start_tag_index].rstrip()\n end_position = Position(len(desc_str), 0)\n\n self._HandleError(\n errors.JSDOC_TAG_DESCRIPTION_ENDS_WITH_INVALID_CHARACTER,\n ('%s descriptions must end with valid punctuation such as a '\n 'period.' % token.string),\n end_token, end_position)\n\n if flag.flag_type in state.GetDocFlag().HAS_TYPE:\n if flag.type_start_token is not None:\n self._CheckForMissingSpaceBeforeToken(\n token.attached_object.type_start_token)\n\n if flag.type and flag.type != '' and not flag.type.isspace():\n self._CheckJsDocType(token)\n\n if type in (Type.DOC_FLAG, Type.DOC_INLINE_FLAG):\n if (token.values['name'] not in state.GetDocFlag().LEGAL_DOC and\n token.values['name'] not in FLAGS.custom_jsdoc_tags):\n self._HandleError(errors.INVALID_JSDOC_TAG,\n 'Invalid JsDoc tag: %s' % token.values['name'], token)\n\n if (FLAGS.strict and token.values['name'] == 'inheritDoc' and\n type == Type.DOC_INLINE_FLAG):\n self._HandleError(errors.UNNECESSARY_BRACES_AROUND_INHERIT_DOC,\n 'Unnecessary braces around @inheritDoc',\n token)\n\n elif type == Type.SIMPLE_LVALUE:\n identifier = token.values['identifier']\n\n if ((not state.InFunction() or state.InConstructor()) and\n not state.InParentheses() and not state.InObjectLiteralDescendant()):\n jsdoc = state.GetDocComment()\n if not state.HasDocComment(identifier):\n # Only test for documentation on identifiers with .s in them to\n # avoid checking things like simple variables. We don't require\n # documenting assignments to .prototype itself (bug 1880803).\n if (not state.InConstructor() and\n identifier.find('.') != -1 and not\n identifier.endswith('.prototype') and not\n self._limited_doc_checks):\n comment = state.GetLastComment()\n if not (comment and comment.lower().count('jsdoc inherited')):\n self._HandleError(errors.MISSING_MEMBER_DOCUMENTATION,\n \"No docs found for member '%s'\" % identifier,\n token);\n elif jsdoc and (not state.InConstructor() or\n identifier.startswith('this.')):\n # We are at the top level and the function/member is documented.\n if identifier.endswith('_') and not identifier.endswith('__'):\n if jsdoc.HasFlag('override'):\n self._HandleError(errors.INVALID_OVERRIDE_PRIVATE,\n '%s should not override a private member.' % identifier,\n jsdoc.GetFlag('override').flag_token)\n # Can have a private class which inherits documentation from a\n # public superclass.\n if jsdoc.HasFlag('inheritDoc') and not jsdoc.HasFlag('constructor'):\n self._HandleError(errors.INVALID_INHERIT_DOC_PRIVATE,\n '%s should not inherit from a private member.' % identifier,\n jsdoc.GetFlag('inheritDoc').flag_token)\n if (not jsdoc.HasFlag('private') and\n not ('underscore' in jsdoc.suppressions)):\n self._HandleError(errors.MISSING_PRIVATE,\n 'Member \"%s\" must have @private JsDoc.' %\n identifier, token)\n if jsdoc.HasFlag('private') and 'underscore' in jsdoc.suppressions:\n self._HandleError(errors.UNNECESSARY_SUPPRESS,\n '@suppress {underscore} is not necessary with @private',\n jsdoc.suppressions['underscore'])\n elif jsdoc.HasFlag('private'):\n self._HandleError(errors.EXTRA_PRIVATE,\n 'Member \"%s\" must not have @private JsDoc' %\n identifier, token)\n\n if ((jsdoc.HasFlag('desc') or jsdoc.HasFlag('hidden'))\n and not identifier.startswith('MSG_')\n and identifier.find('.MSG_') == -1):\n # TODO(user): Update error message to show the actual invalid\n # tag, either @desc or @hidden.\n self._HandleError(errors.INVALID_USE_OF_DESC_TAG,\n 'Member \"%s\" should not have @desc JsDoc' % identifier,\n token)\n\n # Check for illegaly assigning live objects as prototype property values.\n index = identifier.find('.prototype.')\n # Ignore anything with additional .s after the prototype.\n if index != -1 and identifier.find('.', index + 11) == -1:\n equal_operator = tokenutil.SearchExcept(token, Type.NON_CODE_TYPES)\n next_code = tokenutil.SearchExcept(equal_operator, Type.NON_CODE_TYPES)\n if next_code and (\n next_code.type in (Type.START_BRACKET, Type.START_BLOCK) or\n next_code.IsOperator('new')):\n self._HandleError(errors.ILLEGAL_PROTOTYPE_MEMBER_VALUE,\n 'Member %s cannot have a non-primitive value' % identifier,\n token)\n\n elif type == Type.END_PARAMETERS:\n # Find extra space at the end of parameter lists. We check the token\n # prior to the current one when it is a closing paren.\n if (token.previous and token.previous.type == Type.PARAMETERS\n and self.ENDS_WITH_SPACE.search(token.previous.string)):\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \")\"',\n token.previous)\n\n jsdoc = state.GetDocComment()\n if state.GetFunction().is_interface:\n if token.previous and token.previous.type == Type.PARAMETERS:\n self._HandleError(errors.INTERFACE_CONSTRUCTOR_CANNOT_HAVE_PARAMS,\n 'Interface constructor cannot have parameters',\n token.previous)\n elif (state.InTopLevel() and jsdoc and not jsdoc.HasFlag('see')\n and not jsdoc.InheritsDocumentation()\n and not state.InObjectLiteralDescendant() and not\n jsdoc.IsInvalidated()):\n distance, edit = jsdoc.CompareParameters(state.GetParams())\n if distance:\n params_iter = iter(state.GetParams())\n docs_iter = iter(jsdoc.ordered_params)\n\n for op in edit:\n if op == 'I':\n # Insertion.\n # Parsing doc comments is the same for all languages\n # but some languages care about parameters that don't have\n # doc comments and some languages don't care.\n # Languages that don't allow variables to by typed such as\n # JavaScript care but languages such as ActionScript or Java\n # that allow variables to be typed don't care.\n if not self._limited_doc_checks:\n self.HandleMissingParameterDoc(token, params_iter.next())\n\n elif op == 'D':\n # Deletion\n self._HandleError(errors.EXTRA_PARAMETER_DOCUMENTATION,\n 'Found docs for non-existing parameter: \"%s\"' %\n docs_iter.next(), token)\n elif op == 'S':\n # Substitution\n if not self._limited_doc_checks:\n self._HandleError(errors.WRONG_PARAMETER_DOCUMENTATION,\n 'Parameter mismatch: got \"%s\", expected \"%s\"' %\n (params_iter.next(), docs_iter.next()), token)\n\n else:\n # Equality - just advance the iterators\n params_iter.next()\n docs_iter.next()\n\n elif type == Type.STRING_TEXT:\n # If this is the first token after the start of the string, but it's at\n # the end of a line, we know we have a multi-line string.\n if token.previous.type in (Type.SINGLE_QUOTE_STRING_START,\n Type.DOUBLE_QUOTE_STRING_START) and last_in_line:\n self._HandleError(errors.MULTI_LINE_STRING,\n 'Multi-line strings are not allowed', token)\n\n\n # This check is orthogonal to the ones above, and repeats some types, so\n # it is a plain if and not an elif.\n if token.type in Type.COMMENT_TYPES:\n if self.ILLEGAL_TAB.search(token.string):\n self._HandleError(errors.ILLEGAL_TAB,\n 'Illegal tab in comment \"%s\"' % token.string, token)\n\n trimmed = token.string.rstrip()\n if last_in_line and token.string != trimmed:\n # Check for extra whitespace at the end of a line.\n self._HandleError(errors.EXTRA_SPACE, 'Extra space at end of line',\n token, Position(len(trimmed), len(token.string) - len(trimmed)))\n\n # This check is also orthogonal since it is based on metadata.\n if token.metadata.is_implied_semicolon:\n self._HandleError(errors.MISSING_SEMICOLON,\n 'Missing semicolon at end of line', token)","def validate_token():\n global vault_token\n global vault_token_time\n\n if vault_token is None:\n return False\n\n return datetime.datetime.now() < vault_token_time","def test_missing_all_tokens(self):\n self.helper_test_evaluate_raises(\n '(A nand B) and not D',\n expected_exc_type=MissingSymbolError)","def validation(self, tokens):\n return self.process_value_pairs(tokens, \"validation\")","def __token_is_valid(self):\n\n if not self.__login_token or len(self.__login_token) < 10:\n # Token is not set or totally invalid\n return False\n\n try:\n jwt.decode(self.__login_token, verify = False)\n return True\n except:\n # Most likely the token is expired as `exp` is in the past\n return False","def isValid(token):\n try:\n decoded = jwt.decode(token, SECRET_KEY)\n return True\n except:\n return False","def test_gen_and_verify_good_token(self):\n config.set(xsrf_token_key='abcdef')\n tool = utils.XsrfTool()\n token = tool.generate_token(12345, 'test_action')\n self.assertTrue(tool.verify_token(token, 12345, 'test_action'))","def check_token(token, secret, message=None):\n\n config = prologin.config.load('timeauth')\n\n if not config['enabled']:\n return True\n\n if token is None:\n return False\n\n # Reject badly formatted tokens.\n chunks = token.split(':')\n if len(chunks) != 2:\n return False\n try:\n timestamp = int(chunks[0])\n except ValueError:\n return False\n\n # Reject outdated tokens.\n if time.time() - timestamp > TOKEN_TIMEOUT:\n return False\n\n # Check if the token is valid.\n return hmac.compare_digest(\n get_hmac(secret, str(message) + chunks[0]), chunks[1]\n )","def identify_errors(tokens, dictionary):\n return set(tokens).difference(dictionary)","def check_symbols(self):\n # this method has a bug in that it never raises KeyError, it raises \n # ValueError instead.\n \n def is_valid(sym):\n # what symbols are valid? (, ), digits, atoms\n if sym in \"()\": return True\n #if sym.isdigit(): return True\n #if sym in _atomic_mass: return True\n if sym.isalnum(): return True\n return False\n\n for t in self._gettokens():\n if not is_valid(t): raise ValueError(\"bad symbol \" + t)\n if t.isalpha() and t not in _atomic_mass: raise KeyError(\"key error \" + t)\n return True","def _match(self, *token_types):\n for token in token_types:\n if self._check(token):\n self._advance()\n return True\n\n return False","def validate_token(self):\n r = requests.get(urljoin(self._url, Client._token_resource),\n params={\"tokenid\": self._token_id})\n\n if r.status_code == requests.status_codes.codes.unauthorized:\n raise ClientUnauthorized()\n elif r.status_code != requests.status_codes.codes.ok:\n error_messages = self._parse_invalid_request(r.text)\n raise ClientException(r.status_code, error_messages)\n\n try:\n type_, value = r.text.split(\"=\")\n value = value.strip(\" \\r\\n\")\n except Exception, e:\n raise ClientException(r.status_code,\n \"Some error has ocurred getting the result value from %s\"\n % r.text)\n\n return value == \"true\"","def _check_grammar(seq, accepted_tokens):\r\n if len(seq) == 0:\r\n if accepted_tokens == [0, 3]:\r\n return True\r\n else:\r\n return False\r\n if seq[0] in accepted_tokens:\r\n curr_token = seq[0]\r\n if curr_token in [0, 2]:\r\n next_possible_tokens = [1, 2]\r\n elif curr_token in [1, 3]:\r\n next_possible_tokens = [0, 3]\r\n else:\r\n raise ValueError\r\n return Model._check_grammar(seq[1:], next_possible_tokens)\r\n return False","def test_bad_token(self):\n user = self.create_user()\n\n token_generator = EmailActivationTokenGenerator()\n bad_activation_keys = (\n 'emailactivationtokengenerator',\n 'emailactivation-tokengenerator',\n '3rd-bademailactivationkey'\n )\n for key in bad_activation_keys:\n self.assertFalse(token_generator.check_token(user, key))","def test_regex_matches_multiple_valid(self):\n token_1 = \"NDY3MjIzMjMwNjUwNzc3NjQx.XsyWGg.uFNEQPCc4ePwGh7egG8UicQssz8\"\n token_2 = \"NDcyMjY1OTQzMDYyNDEzMzMy.XsyWMw.l8XPnDqb0lp-EiQ2g_0xVFT1pyc\"\n message = f\"garbage {token_1} hello {token_2} world\"\n\n results = token_remover.TOKEN_RE.finditer(message)\n results = [match[0] for match in results]\n self.assertCountEqual((token_1, token_2), results)","def validate(data, badchars):\n assert(all(b not in data for b in badchars))","def test_is_valid_timestamp_invalid(self):\n timestamps = (\n (\"B4Yffw\", \"DISCORD_EPOCH - TOKEN_EPOCH - 1\"),\n (\"ew\", \"123\"),\n (\"AoIKgA\", \"42076800\"),\n (\"{hello}[world]&(bye!)\", \"ASCII invalid Base64\"),\n (\"Þíß-ï§-ňøẗ-våłìÐ\", \"Unicode invalid Base64\"),\n )\n\n for timestamp, msg in timestamps:\n with self.subTest(msg=msg):\n result = TokenRemover.is_valid_timestamp(timestamp)\n self.assertFalse(result)","def evaluate_tokenization(test_tokens, gold_tokens):\n matcher = difflib.SequenceMatcher()\n matcher.set_seqs(test_tokens, gold_tokens)\n error_chunks = true_positives = false_positives = false_negatives = 0\n print(\" Token%30s | %-30sToken\" % (\"Error\", \"Correct\"))\n print(\"-\" * 38 + \"+\" + \"-\" * 38)\n for difftype, test_from, test_to, gold_from, gold_to in matcher.get_opcodes():\n if difftype == \"equal\":\n true_positives += test_to - test_from\n else:\n false_positives += test_to - test_from\n false_negatives += gold_to - gold_from\n error_chunks += 1\n test_chunk = \" \".join(test_tokens[test_from:test_to])\n gold_chunk = \" \".join(gold_tokens[gold_from:gold_to])\n print(\"%6d%30s | %-30s%d\" % (test_from, test_chunk, gold_chunk,gold_from))\n precision = 1.0 * true_positives / (true_positives + false_positives)\n recall = 1.0 * true_positives / (true_positives + false_negatives)\n fscore = 2.0 * precision * recall / (precision + recall)\n print()\n print(\"Test size: %5d tokens\" % len(test_tokens))\n print(\"Gold size: %5d tokens\" % len(gold_tokens))\n print(\"Nr errors: %5d chunks\" % error_chunks)\n print(\"Precision: %5.2f %%\" % (100 * precision))\n print(\"Recall: %5.2f %%\" % (100 * recall))\n print(\"F-score: %5.2f %%\" % (100 * fscore))","def test_is_valid_user_id_valid(self):\n ids = (\n \"NDcyMjY1OTQzMDYyNDEzMzMy\",\n \"NDc1MDczNjI5Mzk5NTQ3OTA0\",\n \"NDY3MjIzMjMwNjUwNzc3NjQx\",\n )\n\n for user_id in ids:\n with self.subTest(user_id=user_id):\n result = TokenRemover.is_valid_user_id(user_id)\n self.assertTrue(result)","def is_token_valid(self,pk,request):\n\n pass","def _check_special_token_identifier(key):\n if not (key.endswith('_token') and key != '_token'):\n raise ValueError('Each key needs to have the form \"name_token\".'\n ' Received {}'.format(key))","def check_composite_tokens(self, name, tokens):\n assert len(tokens) >= 2\n key = tokens[0]\n\n assert key.value.lower() == name\n assert tokens[-1].value.lower() == \"end\"\n\n if len(tokens) == 2:\n body = [] # empty TYPE..END block\n else:\n body = tokens[1:-1]\n\n body_tokens = []\n\n for t in body:\n if isinstance(t, dict):\n body_tokens.append(t[\"__tokens__\"])\n else:\n body_tokens.append(t)\n return key, body_tokens","def test_authtoken_is_valid(self):\n auth_client = self.fixtures.auth_client\n # scenario 1: when validity is unlimited (0)\n tomriddle = models.User(username='voldemort', fullname='Tom Riddle')\n scope = ['id', 'email']\n tomriddle_token = models.AuthToken(\n auth_client=auth_client, user=tomriddle, scope=scope, validity=0\n )\n self.assertTrue(tomriddle_token.is_valid())\n\n # scenario 2: when validity has not been given\n draco = models.User(username='draco', fullname='Draco Malfoy')\n draco_token = models.AuthToken(auth_client=auth_client, user=draco, scope=scope)\n with self.assertRaises(TypeError):\n draco_token.is_valid()\n\n # scenario 3: when validity is limited\n harry = models.User(username='harry', fullname='Harry Potter')\n harry_token = models.AuthToken(\n auth_client=auth_client,\n user=harry,\n scope=scope,\n validity=3600,\n created_at=utcnow(),\n )\n self.assertTrue(harry_token.is_valid())\n\n # scenario 4: when validity is limited *and* the token has expired\n cedric = models.User(username='cedric', fullname='Cedric Diggory')\n cedric_token = models.AuthToken(\n auth_client=auth_client,\n user=cedric,\n scope=scope,\n validity=1,\n created_at=utcnow() - timedelta(1),\n )\n self.assertFalse(cedric_token.is_valid())","def test_expired_thread_token_is_valid(self):\n self.token.modified = self.days_ago(const.THREAD_TOKEN_EXPIRY + 1)\n assert not self.token.is_valid()","def check_if_token_is_valid(token):\n if token is None:\n return\n try:\n jwt.decode(\n token,\n key=current_app.config['JWT_KEY'],\n audience=current_app.config['AUTH0_BASE_URL'] + '/api/v2/',\n issuer=current_app.config['AUTH0_BASE_URL'] + '/')\n except (jwt.JWTError,\n jwk.JWKError,\n jwt.ExpiredSignatureError,\n jwt.JWTClaimsError,\n AttributeError,\n AssertionError,\n IndexError):\n return False\n else:\n return True","def isValidNew(cls,corpus):\n valid = True\n valid = valid and Validator.checkRelentitytypes(corpus)\n # Subtokens do not yet fulfill the requirements\n # valid = valid and Validator.checkSubtokens(corpus)\n valid = valid and Validator.checkDeptokens(corpus)\n valid = valid and Validator.checkReltokens(corpus)\n # \n return(valid)","def _validar_token(self):\n\n\t\ttoken = request.headers.get(\"Authorization\").split(\" \")[1]\n\n\t\tres = self.autenticador.validarToken(token)\n\t\tif(not res):\n\t\t\treturn False\n\t\treturn True","def _check_for_typos(all_tokens):\n d = enchant.DictWithPWL(\"en_US\",\"mywords.txt\")\n known_typo_list = enchant.DictWithPWL(\"en_US\", \"add_to_typo_list.txt\")\n unknown_word_list = enchant.DictWithPWL(\"en_US\", \"unknown_words.txt\")\n\n counter = 0\n incorrect_token_list = []\n for token in all_tokens:\n counter += 1\n is_correct = d.check(token)\n known_typo = known_typo_list.check(token)\n unknown_word = unknown_word_list.check(token)\n\n if not is_correct and not known_typo and not unknown_word and len(token) > 4:\n # print counter, \"Token: \", token, \", IC: \", is_correct, \"KT: \", known_typo, \"UW: \", unknown_word, \"LEN: \", len(token)\n print token\n if token not in incorrect_token_list:\n incorrect_token_list.append(token)\n print \"** Num Incorrect: \", len(incorrect_token_list)","def compare_token(got, expected):\n if len(got) != len(expected):\n return False\n for i in range(len(got)):\n if not compare_character(got[i], expected[i]):\n return False\n # just to be extra sure, also compare the hashes (yes, we're cheating\n # here to make it easier to guess the last character)\n got_enc = (''.join(got)).encode('utf-8')\n expected_enc = (''.join(expected)).encode('utf-8')\n return hashlib.sha1(got_enc).digest() == hashlib.sha1(expected_enc).digest()","def is_valid(data):\n return isinstance(data, dict) \\\n and \"u_id\" in data \\\n and \"token\" in data \\\n and isinstance(data[\"u_id\"], int) \\\n and isinstance(data[\"token\"], str)","def validate_token(user, tkn):\n try:\n decoded = jwt.decode(tkn, KEY)\n if decoded['user'] == user:\n stored_token = User.get(User.username == user).token\n if stored_token == tkn:\n return True\n return False\n except jwt.ExpiredSignatureError:\n return HTTPResponse(status=400, body={\"msg\":\"Validation error.\"})","def is_valid(text):\n return is_all_word_segment_in_text(WORDS, text)","def contains_tokens(pattern):\n return type(pattern) is list and len(pattern) > 0","def test_open_closed(self):\n nt = NewickTokenizer(newick='(a,(),(d,e));')\n self.assertRaises(ValueError, nt.tokens)","def verify_token(self, token):\n _now = timezone.now()\n\n if (\n (self.token is not None)\n and (token == self.token)\n and (_now < self.valid_until)\n ):\n self.token = None\n self.valid_until = _now\n self.save()\n\n return True\n else:\n return False","def check_token(self, *args) -> bool:\n if len(args) == 1:\n if isinstance(args[0], str):\n return self.token_name == args[0]\n elif isinstance(args[0], _Enum):\n return self.token_name == args[0].name\n elif isinstance(args[0], _Sequence):\n return self.token_name in args[0]\n raise TypeError(\"_check_token() taking 1 argument, type: str, Enum or Sequence\")","def test_parser(test_input, expected):\n tokens = list(sp.tokenize(test_input))\n assert tokens == expected","def check_token(token):\n # Avoid SQL injection before doing requests\n # with the token and check the validity of it.\n token = MySQLdb.escape_string(token)\n if not validator_db.valid_token(token):\n return custom_response(400, responseMessage.BAD_TOKEN)\n\n return Response(status=200)","def token_valid_check(start_time):\n #calculate the time elapsed since token was last refreshed\n elapsed_time = time.time() - start_time\n #take action if token is expired\n if elapsed_time > 3540:\n return False\n return True","def test_is_token_json_temporally_valid(self):\n payload_list = []\n\n # Test that we reject a payload without 'iat' or 'exp'\n # as the tokens should have a lifetime\n payload_list.append({\n 'sub': CLIENT_ID,\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\n 'jti': '714892f5-014f-43ad-bea0-fa47579db222'\n })\n\n # Test that we reject a payload without 'exp'\n # as such a token would never expire\n payload_list.append({\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\n 'jti': '098cb343-c45e-490d-8aa0-ce1873cdc5f8',\n 'iat': int(time.time()) - 2000000,\n 'sub': CLIENT_ID\n })\n\n # Test that we reject a payload without 'iat'\n # as all tokens should indicate when they were issued\n payload_list.append({\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\n 'jti': '098cb343-c45e-490d-8aa0-ce1873cdc5f8',\n 'sub': CLIENT_ID,\n 'exp': int(time.time()) + 200000\n })\n\n # Test that we reject a payload with an 'iat' and 'exp'\n # in the past (e.g. they have expired)\n payload_list.append({\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\n 'jti': '098cb343-c45e-490d-8aa0-ce1873cdc5f8',\n 'iat': int(time.time()) - 2000000,\n 'sub': CLIENT_ID,\n 'exp': int(time.time()) - 200000\n })\n\n # Test that we reject a payload with an 'iat' and 'exp'\n # in the future (as we should as they are not yet valid)\n payload_list.append({\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\n 'jti': '098cb343-c45e-490d-8aa0-ce1873cdc5f8',\n 'iat': int(time.time()) + 200000,\n 'sub': CLIENT_ID,\n 'exp': int(time.time()) + 2000000\n })\n\n for payload in payload_list:\n # Assert the underlying helper method reponsible for\n # checking temporal validity returns False when passed\n # temporally invalid payloads\n self.assertFalse(\n self._token_checker._is_token_json_temporally_valid(payload),\n \"Payload %s should not be accepted!\" % payload\n )\n\n # Assert the wrapper method valid_token_to_id returns\n # None when passed temporally invalid tokens\n token = self._create_token(payload, PRIVATE_KEY)\n self.assertEqual(\n self._token_checker.valid_token_to_id(token), None,\n \"Token with payload %s should not be accepted!\" % payload\n )","def _assert_valid(self, token_id, token_ref):\n current_time = timeutils.normalize_time(timeutils.utcnow())\n expires = token_ref.get('expires')\n if not expires or current_time > timeutils.normalize_time(expires):\n raise exception.TokenNotFound(token_id=token_id)","def validate(self, username: str, token: str, check_privilege: Optional[str] = None) -> bool:\n cursor = self._db_connection.cursor()\n\n # Get UID from the user's username\n uid = self.get_uid(username=username)\n\n # Check access control privilege (if specified)\n if check_privilege is not None:\n # Get list of privileges associated with the user (if specified)\n cursor.execute('''SELECT privilege FROM access_control WHERE uid = ?''', (uid,))\n db_result = cursor.fetchall()\n privileges = [chunked[0] for chunked in db_result]\n\n # If the user does not have the given privilege\n if check_privilege not in privileges:\n return False\n\n # Get list of tokens associated with a user, if they exist\n cursor.execute(\n '''\n SELECT\n expiration_datetime\n FROM \n tokens \n WHERE \n uid = ? \n AND \n token_content = ?\n ORDER BY \n expiration_datetime\n ;\n ''',\n (uid, token)\n )\n db_result = cursor.fetchone()\n\n # If there aren't any associate tokens in the DB (the user will need to authenticate first!)\n if db_result is None:\n return False\n\n # Verify token is not expired\n expiration_datetime = db_result[0]\n if datetime.datetime.fromisoformat(expiration_datetime) < datetime.datetime.now():\n return False\n else:\n return True","def test_valid_token(self, mock_check_token_not_revoked,\n mock_get_issuer_public_key):\n # Mock the external call to retrieve the IAM public key\n # used in the _verify_token and valid_token_to_id call\n mock_get_issuer_public_key.return_value = PUBLIC_KEY\n # Mock the external call to check the token has not been rejected\n # used in the valid_token_to_id call\n mock_check_token_not_revoked.return_value = CLIENT_ID\n\n # This payload will be valid as we will sign it with PRIVATE_KEY\n payload = self._standard_token()\n\n token = self._create_token(payload, PRIVATE_KEY)\n\n with self.settings(IAM_HOSTNAME_LIST=['iam-test.idc.eu']):\n client_id = payload['sub']\n self.assertEqual(\n self._token_checker.valid_token_to_id(token), client_id,\n \"Token with payload %s should be accepted!\" % payload\n )","def validate(self, encrypted_token: str) -> bool:\n payload, timestamp_ms, crc = self.unsleeve(encrypted_token)\n ts_bytes = timestamp_ms.to_bytes(8, 'big')\n\n computed_crc = zlib.crc32(payload + ts_bytes)\n\n if crc == computed_crc:\n return in_range(timestamp_ms, deadline=self.token_life_ms)\n\n return False","def check_token_validate(self, token):\n payload = {'key': self._lr_object._get_api_key(), 'secret': self._lr_object._get_api_secret(), 'access_token': token}\n url = SECURE_API_URL + \"api/v2/access_token/Validate/\"\n return self._lr_object._get_json(url, payload)","def verify_csrf_token(token=''):\n\tif not token:\n\t\ttoken = managers.request_manager.get_request().arguments().arguments().get(csrf_token_arg_name, \"\")\n\t\tif token:\n\t\t\ttoken = token[0]\n\tif len(token) != 2 * digest_size + 2 * csrf_salt_len:\n\t\tdebug('Incorrect csrf token length')\n\t\traise VDOM_csrf_exception()\n\tsalt = token[2*digest_size:]\n\tif token != create_csrf_token(salt):\n\t\tdebug('Incorrect csrf token value')\n\t\traise VDOM_csrf_exception()","def validate_words(self):\n if not self.words or not self.mnemonic.check(self.words):\n raise InvalidWords","def test_validate_input_rejection_invalid_symbol(self):\n with nose.assert_raises(exceptions.RejectionError):\n self.dtm1.validate_input('02')","def sanity_check(secret):\n matches = list()\n for cur_file in CASSETTE_PATH.rglob(\"*.yaml\"):\n if secret in cur_file.read_text():\n matches.append(cur_file)\n if matches:\n click.secho(\"Found {0} cassettes that still mention auth token:\".format(len(matches)), fg=\"red\")\n for cur_match in matches:\n click.secho(\"\\t{0}\".format(cur_match.name), fg=\"red\")\n return False\n click.secho(\"Cassettes look clean - no mentions of auth tokens!\", fg=\"green\")\n return True","def is_token_valid(self):\n try:\n token_details = jwt.decode(self.__token, verify=False)\n self.__admin_id = token_details[\"id\"]\n self.__username = token_details[\"username\"]\n expiry = token_details[\"expiry\"]\n if time.time() > expiry:\n raise TokenExpiredException\n cursor = self.__connection.cursor()\n cursor.execute(\n \"select password from neutron_admin_credential where admin_id=%s and username=%s\",\n (self.__admin_id, self.__username)\n )\n result = cursor.fetchone()\n if result is None:\n self.__message = \"Invalid id details\"\n return False\n passsword = result[\"password\"]\n admin_secret = passsword + get_admin_credential()\n jwt.decode(self.__token, key=admin_secret, verify=True)\n return True\n except jwt.DecodeError:\n self.__message = \"Invalid Token\"\n return False\n except KeyError:\n self.__message = \"Insecure Token\"\n return False\n except ValueError:\n self.__message = \"Insecure Token\"","def check_token(self, user, token):\n\n # Parse the token\n try:\n ts_b36, hash = token.split(\"-\")\n except ValueError:\n return False\n\n try:\n ts = base36_to_int(ts_b36)\n except ValueError:\n return False\n\n # Check that the timestamp/uid has not been tampered with\n recomputed_token = self._make_token_with_timestamp(user, ts)\n\n log.debug(\"Ricalcolo re_token=%s token=%s\" % (recomputed_token, token))\n if not constant_time_compare(recomputed_token, token):\n return False\n\n # Check the timestamp is within limit\n if (self._num_days(self._today()) - ts) > settings.REFERRAL_TOKEN_RESET_TIMEOUT_DAYS:\n return False\n\n return True","def containsToken(self, token):\n if token.sentence != self.tokens[0].sentence:\n return False # not in same sentence\n \n return self.tokens[0].index <= token.index and token.index <= self.tokens[-1].index","def test_empty(self):\n\n tokens = list(Lexer(\"\").generate_tokens())\n self.assertEqual(tokens, [])","def wellformedness_check(tokens):\n stack = []\n for token in tokens:\n if token.is_a(Start):\n stack.append(token)\n elif token.is_a(End):\n try:\n start = stack.pop()\n except IndexError:\n raise WellformednessError('Extra end tag found: \"%s\"' % token.xml)\n if start.name != token.name:\n raise WellformednessError('\"%s\" matched by \"%s\"' % (start.xml, token.xml))\n elif token.is_a(Error):\n raise MarkupError(token.xml + tokens.next().xml)\n yield token","def _validate_token(self):\n if not self.token:\n self.login()\n if not self.token:\n # TODO: create exception for this\n # Access is denied!!\n raise Exception(\"AccessDenied\")","def _check_sanity(self, tags: List[str], n_words: int):\n n_out = 0\n\n for tag in tags:\n if (\"<\" not in tag) and (\">\" not in tag):\n n_out += 1\n\n return n_out == n_words","def _check_sanity(self, tags: List[str], n_words: int):\n n_out = 0\n\n for tag in tags:\n if (\"<\" not in tag) and (\">\" not in tag):\n n_out += 1\n\n return n_out == n_words","def test_generate_and_validate_token(self):\n\n audience = 'http://www.service.teletracking.com/'\n roles = {'role': ['admin', 'user'], 'audience': audience}\n secret = 'drMemxWrLen6fCXQA5jO6gXkK/UoZVzPGRDiff7ByPU='\n token = AuthenticationHandler.generate_auth_token(roles, secret)\n decoded_token = AuthenticationHandler.validate_and_decode_token(\n token=token, key=secret,\n audience=audience\n )\n self.assertTrue(decoded_token['role'][0] == 'admin')\n self.assertTrue(decoded_token['role'][1] == 'user')","def validate():","def test_issue401(EN, text, i):\n tokens = EN(text)\n assert tokens[i].lemma_ != \"'\"","def test_max_used_thread_token_is_valid(self):\n self.token.use_count = const.MAX_TOKEN_USE_COUNT\n assert not self.token.is_valid()","def test_unclosed(self):\n nt = NewickTokenizer(newick='(a,(b,c)')\n self.assertRaises(ValueError, nt.tokens)","def _is_oauth_token_valid(token: dict, time_key=\"expires_on\") -> bool:\n if \"access_token\" not in token or token.get(\"token_type\", \"\") != \"Bearer\" or time_key not in token:\n raise AirflowException(f\"Can't get necessary data from OAuth token: {token}\")\n\n return int(token[time_key]) > (int(time.time()) + TOKEN_REFRESH_LEAD_TIME)","def test_missing_single_token(self):\n self.helper_test_evaluate_raises(\n 'A or (B and (C and not D))',\n expected_exc_type=MissingSymbolError,\n A=0,\n B=1,\n D=1)","def is_valid(url):\n\n HAVERFORD_TOKEN = 'Haverford users only'\n INVALID_TOKENS = [HAVERFORD_TOKEN, \"Site Intel\", \"SITE Institute\"]\n content = urlopen(url).read()\n\n for token in INVALID_TOKENS:\n if token in content:\n return False\n return True","def validate_token():\n try:\n token = validate_auth()\n except Unauthorized:\n return jsonify(valid=False, expires_in=0)\n expires = oidc.user_getfield('exp')\n delta = expires - datetime.now().timestamp()\n return jsonify(valid=True, expires_in=delta)","def _validate_jwt_token(self):\n # force https so that we don't send around tokens unsecurely\n url = 'https://{}/api/token/verify'.format(urlparse(self.base_url).netloc)\n \n # paranoid: check again that we only send the token to https\n if urlparse(url).scheme != \"https\":\n msg = 'This should not happen, please file a bug report.'\n raise Exception(msg)\n\n if not self.jwt_access_token:\n raise FDSNUnauthorizedException(\"Unauthorized, authentication \"\n \"required.\", )\n\n # convert to json\n data = json.dumps({\"token\": self.jwt_access_token})\n # encode\n data = bytes(data, \"utf-8\")\n headers = {\"Content-Type\": \"application/json\"}\n html = urllib_request.Request(url, data=data, headers=headers)\n # decode('utf-8')\n try:\n result = urllib_request.urlopen(html).read().decode(\"utf-8\")\n dic = json.loads(result)\n valid = not bool(dic)\n if self.debug:\n print('Valid token : {}'.format(valid))\n return valid\n except urllib_error.HTTPError as e:\n return False","def check_token(self, token):\n decoded_token = manage_tokens.decode(token)\n if decoded_token is None:\n return {'error': 'Token is invalid'}\n\n if 'email' not in decoded_token or 'expires' not in decoded_token \\\n or 'token' not in decoded_token:\n return {'error': 'Token is invalid'}\n\n self.email = decoded_token['email']\n self.user_in_db = User.users_db.get(decoded_token['email'])\n\n if not self.user_in_db:\n # User does not exist\n return {'error': 'User does not exist'}\n\n if self.user_in_db['token'] != decoded_token['token']:\n return {'error': 'Token is invalid'}\n\n if decoded_token['expires'] < time.time():\n return {'error': 'Token is expired'}\n\n return decoded_token","def is_valid_posse(posse: 'Tuple'):\n # todo: write this as iterator through test types\n # could use test types as blocks for lambda calculus\n # for test in attribute tests:\n\n # print('testing posse: %s' % str(posse))\n\n prefixes = set()\n cases = set()\n lengths = set()\n letters = set()\n\n for member in posse:\n # prefix validity\n prefixes.add(member[0])\n\n # case validity\n if ord(member[1]) in THIRD_CASE:\n cases.add(2)\n elif member[1].isupper():\n cases.add(1)\n else:\n cases.add(0)\n\n # length validity\n lengths.add(len(member[1:]))\n\n # letter validity\n # print('letter validity for %s' % member)\n for letter_type in LETTER_SETS:\n if ord(member[1]) in LETTER_SETS[letter_type]:\n letters.add(letter_type)\n\n prefix_is_valid = len(prefixes) == 1 or len(prefixes) == 3\n case_is_valid = len(cases) == 1 or len(cases) == 3\n length_is_valid = len(lengths) == 1 or len(lengths) == 3\n letter_is_valid = len(letters) == 1 or len(letters) == 3\n\n # print('prefix_is_valid: %s' % prefix_is_valid)\n # print('case_is_valid: %s' % case_is_valid)\n # print('length_is_valid: %s' % length_is_valid)\n # print('letter_is_valid: %s' % letter_is_valid)\n\n return all((prefix_is_valid,\n case_is_valid,\n length_is_valid,\n letter_is_valid))","def test_0001(self):\n assert self.vca.token","def test_0001(self):\n assert self.vca.token","def test_0001(self):\n assert self.vca.token","def check_token(token):\n token = db.session.query(Token).filter(Token.token==token).first()\n if token == None:\n return False\n #TODO token lifetime\n #if (datetime.datetime.now() - token.date >= datetime.timedelta(day=2)):\n # return False \n return True","def verify_token(auth_token):\n blacklisted_token = TokenBlacklisting.query.filter_by(\n token=str(auth_token)).first()\n if blacklisted_token:\n return True\n return False","def check_for_value(tokens):\n ntoks = 0\n for tok in tokens:\n if tok.isspace() or tok == ',':\n continue\n elif tok in ('=', '/', '$', '&'):\n break\n else:\n ntoks += 1\n\n # If ntoks reaches 2, then there must be at least one value.\n if ntoks > 1:\n break\n\n return ntoks > 0"],"string":"[\n \"def test_unused_token_is_valid(self):\\n assert self.token.is_valid()\",\n \"async def validate_token(self, token):\",\n \"def _check_tokens(number_token=None, name_token=None, gpe_token=None):\\n assert number_token is None or number_token == number_token.lower(), \\\\\\n \\\"Tokens need to be lowercase: %s\\\" % number_token\\n assert name_token is None or name_token == name_token.lower(), \\\\\\n \\\"Tokens need to be lowercase: %s\\\" % name_token\\n assert gpe_token is None or gpe_token == gpe_token.lower(), \\\\\\n \\\"Tokens need to be lowercase: %s\\\" % gpe_token\",\n \"def testIsValidToken(self):\\n self.assertTrue(TokenResource.isValidToken('aValidToken'),\\n msg='Expected isValidToken to accept a valid token.')\\n self.assertTrue(TokenResource.isValidToken(TokenResource.VALID_TOKEN_CHARS),\\n msg='Expected isValidToken to accept a valid token.')\\n self.assertFalse(TokenResource.isValidToken('Token!'),\\n msg='Expected isValidToken to accept an invalid token.')\\n self.assertFalse(TokenResource.isValidToken('an invalid Token'),\\n msg='Expected isValidToken to accept an invalid token.')\",\n \"def test_invalid_tokens(self):\\n self.assertTrue(1 + 1)\",\n \"def test_regex_valid_tokens(self):\\n # Don't worry, these tokens have been invalidated.\\n tokens = (\\n \\\"NDcyMjY1OTQzMDYy_DEzMz-y.XsyRkw.VXmErH7j511turNpfURmb0rVNm8\\\",\\n \\\"NDcyMjY1OTQzMDYyNDEzMzMy.Xrim9Q.Ysnu2wacjaKs7qnoo46S8Dm2us8\\\",\\n \\\"NDc1MDczNjI5Mzk5NTQ3OTA0.XsyR-w.sJf6omBPORBPju3WJEIAcwW9Zds\\\",\\n \\\"NDY3MjIzMjMwNjUwNzc3NjQx.XsySD_.s45jqDV_Iisn-symw0yDRrk_jf4\\\",\\n )\\n\\n for token in tokens:\\n with self.subTest(token=token):\\n results = token_remover.TOKEN_RE.fullmatch(token)\\n self.assertIsNotNone(results, f\\\"{token} was not matched by the regex\\\")\",\n \"def __valid_token_format(self, token):\\n if len(token) != self.TOKEN_LENGTH * 2:\\n return False\\n for c in token:\\n if c not in '01234567890abcdef':\\n return False\\n return True\",\n \"def verify_token(self, token):\\n return False\",\n \"def test_live_thread_token_is_valid(self):\\n assert self.token.is_valid()\",\n \"def check_token_structure(data):\\n assert \\\"token\\\" in data\\n token_structure = data[\\\"token\\\"]\\n\\n assert \\\"access_token\\\" in token_structure\\n assert \\\"token_type\\\" in token_structure\\n assert \\\"expires_in\\\" in token_structure\",\n \"def test_rejects_invalid_tokens(self):\\n config.set(xsrf_token_key='abcdef')\\n tool = utils.XsrfTool()\\n self.assertFalse(tool.verify_token(\\n 'ThisTokenDoesNotEvenHaveASlash', 12345, 'test_action'))\\n timestamp = utils.get_timestamp(XsrfToolTests.TEST_NOW)\\n self.assertFalse(\\n tool.verify_token('NotTheRightDigest/%f' % timestamp, 12345,\\n 'test_action'))\",\n \"def validateIdentifier(self, tokens):\\n return tokens\",\n \"def check_for_token(token):\\n try:\\n decode_token(token)\\n return True\\n except:\\n return False\",\n \"def test_regex_invalid_tokens(self):\\n tokens = (\\n \\\"\\\",\\n \\\"lemon wins\\\",\\n \\\"..\\\",\\n \\\"x.y\\\",\\n \\\"x.y.\\\",\\n \\\".y.z\\\",\\n \\\".y.\\\",\\n \\\"..z\\\",\\n \\\"x..z\\\",\\n \\\" . . \\\",\\n \\\"\\\\n.\\\\n.\\\\n\\\",\\n \\\"hellö.world.bye\\\",\\n \\\"base64.nötbåse64.morebase64\\\",\\n \\\"19jd3J.dfkm3d.€víł§tüff\\\",\\n )\\n\\n for token in tokens:\\n with self.subTest(token=token):\\n results = token_remover.TOKEN_RE.findall(token)\\n self.assertEqual(len(results), 0)\",\n \"def validate(cls, token, user, service):\\n expected = cls.generate(user, service)\\n return token == expected\",\n \"def _check_token(self, token):\\n token = token.lower()\\n check = re.sub(r'((^|\\\\')([a-z]+))+$', '', token)\\n if check == '':\\n return True\\n return False\",\n \"def verifySpaceToken(spacetoken, setokens):\\n\\n status = False\\n\\n setokenslist = setokens.split(\\\",\\\")\\n if spacetoken in setokenslist:\\n tolog(\\\"Verified space token: %s\\\" % (spacetoken))\\n status = True\\n else:\\n if spacetoken == \\\"\\\":\\n tolog(\\\"Warning: ended up with empty space token\\\")\\n elif \\\"dst:\\\" in spacetoken:\\n tolog(\\\"Will not verify GROUPDISK space token: %s\\\" % (spacetoken))\\n status = True\\n else:\\n tolog(\\\"Warning: Space token %s is not among allowed values: %s\\\" % (spacetoken, str(setokenslist)))\\n\\n return status\",\n \"def validateOperator(self, tokens):\\n return tokens\",\n \"def validate_token(self, payload, headers, request):\\n token = headers.get(self.TOKEN_NAME, \\\"\\\")\\n\\n # no token\\n if self.verify == VerificationMethod.NONE:\\n # do nothing as no method was chosen\\n pass\\n\\n # static token\\n elif self.verify == VerificationMethod.TOKEN:\\n if not compare_digest(token, self.token):\\n raise PermissionDenied(self.MESSAGE_TOKEN_ERROR)\\n\\n # hmac token\\n elif self.verify == VerificationMethod.HMAC:\\n digest = hmac.new(self.secret.encode('utf-8'), request.body, hashlib.sha256).digest()\\n computed_hmac = base64.b64encode(digest)\\n if not hmac.compare_digest(computed_hmac, token.encode('utf-8')):\\n raise PermissionDenied(self.MESSAGE_TOKEN_ERROR)\\n\\n return True\",\n \"def verify_token(event):\\n if event['token'] != VERIFICATION_TOKEN:\\n print('Presented with invalid token - ignoring message...')\\n return False\\n return True\",\n \"def _check_tokens_are_valid(format_string, message):\\n named_tokens = re.findall(r\\\"{(\\\\w*)}\\\", format_string)\\n invalid_tokens = [x for x in named_tokens if x.lower() not in _valid_tokens]\\n if invalid_tokens:\\n msg = message\\n msg += \\\" [{0}]. \\\".format(\\\", \\\".join(invalid_tokens))\\n msg += 'Did you check your \\\"modules.yaml\\\" configuration?'\\n raise RuntimeError(msg)\",\n \"def test_missing_multiple_tokens(self):\\n self.helper_test_evaluate_raises(\\n 'A or (B and (C and not D))',\\n expected_exc_type=MissingSymbolError,\\n A=0,\\n D=1)\",\n \"def check_token(token):\\n valid = re.compile(r\\\"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-\\\"\\n r\\\"[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$\\\")\\n\\n return valid.match(token)\",\n \"def test_validate_token_returns_false_for_invalid_token(self, demo_app):\\n demo_app.config.get.return_value = self.jwt_key\\n token = jwt.encode({}, self.jwt_key_2, algorithm='HS256')\\n\\n self.assertFalse(\\n validate_token(token)[0],\\n 'Failed to recognise invalidate token.'\\n )\",\n \"def fin_check(expresion):\\n for token in set(bin_tokens.values()).union(set(un_tokens.values())):\\n if token in expresion:\\n return False\\n return True\",\n \"def test_is_valid_timestamp_valid(self):\\n timestamps = (\\n \\\"XsyRkw\\\",\\n \\\"Xrim9Q\\\",\\n \\\"XsyR-w\\\",\\n \\\"XsySD_\\\",\\n \\\"Dn9r_A\\\",\\n )\\n\\n for timestamp in timestamps:\\n with self.subTest(timestamp=timestamp):\\n result = TokenRemover.is_valid_timestamp(timestamp)\\n self.assertTrue(result)\",\n \"def CheckToken(self, token, state):\\n # Store some convenience variables\\n first_in_line = token.IsFirstInLine()\\n last_in_line = token.IsLastInLine()\\n last_non_space_token = state.GetLastNonSpaceToken()\\n\\n type = token.type\\n\\n # Process the line change.\\n if not self._is_html and FLAGS.strict:\\n # TODO(robbyw): Support checking indentation in HTML files.\\n indentation_errors = self._indentation.CheckToken(token, state)\\n for indentation_error in indentation_errors:\\n self._HandleError(*indentation_error)\\n\\n if last_in_line:\\n self._CheckLineLength(token, state)\\n\\n if type == Type.PARAMETERS:\\n # Find missing spaces in parameter lists.\\n if self.MISSING_PARAMETER_SPACE.search(token.string):\\n self._HandleError(errors.MISSING_SPACE, 'Missing space after \\\",\\\"',\\n token)\\n\\n # Find extra spaces at the beginning of parameter lists. Make sure\\n # we aren't at the beginning of a continuing multi-line list.\\n if not first_in_line:\\n space_count = len(token.string) - len(token.string.lstrip())\\n if space_count:\\n self._HandleError(errors.EXTRA_SPACE, 'Extra space after \\\"(\\\"',\\n token, Position(0, space_count))\\n\\n elif (type == Type.START_BLOCK and\\n token.metadata.context.type == Context.BLOCK):\\n self._CheckForMissingSpaceBeforeToken(token)\\n\\n elif type == Type.END_BLOCK:\\n # This check is for object literal end block tokens, but there is no need\\n # to test that condition since a comma at the end of any other kind of\\n # block is undoubtedly a parse error.\\n last_code = token.metadata.last_code\\n if last_code.IsOperator(','):\\n self._HandleError(errors.COMMA_AT_END_OF_LITERAL,\\n 'Illegal comma at end of object literal', last_code,\\n Position.All(last_code.string))\\n\\n if state.InFunction() and state.IsFunctionClose():\\n is_immediately_called = (token.next and\\n token.next.type == Type.START_PAREN)\\n if state.InTopLevelFunction():\\n # When the function was top-level and not immediately called, check\\n # that it's terminated by a semi-colon.\\n if state.InAssignedFunction():\\n if not is_immediately_called and (last_in_line or\\n not token.next.type == Type.SEMICOLON):\\n self._HandleError(errors.MISSING_SEMICOLON_AFTER_FUNCTION,\\n 'Missing semicolon after function assigned to a variable',\\n token, Position.AtEnd(token.string))\\n else:\\n if not last_in_line and token.next.type == Type.SEMICOLON:\\n self._HandleError(errors.ILLEGAL_SEMICOLON_AFTER_FUNCTION,\\n 'Illegal semicolon after function declaration',\\n token.next, Position.All(token.next.string))\\n\\n if (state.InInterfaceMethod() and last_code.type != Type.START_BLOCK):\\n self._HandleError(errors.INTERFACE_METHOD_CANNOT_HAVE_CODE,\\n 'Interface methods cannot contain code', last_code)\\n\\n elif (state.IsBlockClose() and\\n token.next and token.next.type == Type.SEMICOLON):\\n self._HandleError(errors.REDUNDANT_SEMICOLON,\\n 'No semicolon is required to end a code block',\\n token.next, Position.All(token.next.string))\\n\\n elif type == Type.SEMICOLON:\\n if token.previous and token.previous.type == Type.WHITESPACE:\\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \\\";\\\"',\\n token.previous, Position.All(token.previous.string))\\n\\n if token.next and token.next.line_number == token.line_number:\\n if token.metadata.context.type != Context.FOR_GROUP_BLOCK:\\n # TODO(robbyw): Error about no multi-statement lines.\\n pass\\n\\n elif token.next.type not in (\\n Type.WHITESPACE, Type.SEMICOLON, Type.END_PAREN):\\n self._HandleError(errors.MISSING_SPACE,\\n 'Missing space after \\\";\\\" in for statement',\\n token.next,\\n Position.AtBeginning())\\n\\n last_code = token.metadata.last_code\\n if last_code and last_code.type == Type.SEMICOLON:\\n # Allow a single double semi colon in for loops for cases like:\\n # for (;;) { }.\\n # NOTE(user): This is not a perfect check, and will not throw an error\\n # for cases like: for (var i = 0;; i < n; i++) {}, but then your code\\n # probably won't work either.\\n for_token = tokenutil.CustomSearch(last_code,\\n lambda token: token.type == Type.KEYWORD and token.string == 'for',\\n end_func=lambda token: token.type == Type.SEMICOLON,\\n distance=None,\\n reverse=True)\\n\\n if not for_token:\\n self._HandleError(errors.REDUNDANT_SEMICOLON, 'Redundant semicolon',\\n token, Position.All(token.string))\\n\\n elif type == Type.START_PAREN:\\n if token.previous and token.previous.type == Type.KEYWORD:\\n self._HandleError(errors.MISSING_SPACE, 'Missing space before \\\"(\\\"',\\n token, Position.AtBeginning())\\n elif token.previous and token.previous.type == Type.WHITESPACE:\\n before_space = token.previous.previous\\n if (before_space and before_space.line_number == token.line_number and\\n before_space.type == Type.IDENTIFIER):\\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \\\"(\\\"',\\n token.previous, Position.All(token.previous.string))\\n\\n elif type == Type.START_BRACKET:\\n if (not first_in_line and token.previous.type == Type.WHITESPACE and\\n last_non_space_token and\\n last_non_space_token.type in Type.EXPRESSION_ENDER_TYPES):\\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \\\"[\\\"',\\n token.previous, Position.All(token.previous.string))\\n # If the [ token is the first token in a line we shouldn't complain\\n # about a missing space before [. This is because some Ecma script\\n # languages allow syntax like:\\n # [Annotation]\\n # class MyClass {...}\\n # So we don't want to blindly warn about missing spaces before [.\\n # In the the future, when rules for computing exactly how many spaces\\n # lines should be indented are added, then we can return errors for\\n # [ tokens that are improperly indented.\\n # For example:\\n # var someVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongVariableName =\\n # [a,b,c];\\n # should trigger a proper indentation warning message as [ is not indented\\n # by four spaces.\\n elif (not first_in_line and token.previous and\\n not token.previous.type in (\\n [Type.WHITESPACE, Type.START_PAREN, Type.START_BRACKET] +\\n Type.EXPRESSION_ENDER_TYPES)):\\n self._HandleError(errors.MISSING_SPACE, 'Missing space before \\\"[\\\"',\\n token, Position.AtBeginning())\\n\\n elif type in (Type.END_PAREN, Type.END_BRACKET):\\n # Ensure there is no space before closing parentheses, except when\\n # it's in a for statement with an omitted section, or when it's at the\\n # beginning of a line.\\n if (token.previous and token.previous.type == Type.WHITESPACE and\\n not token.previous.IsFirstInLine() and\\n not (last_non_space_token and last_non_space_token.line_number ==\\n token.line_number and\\n last_non_space_token.type == Type.SEMICOLON)):\\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \\\"%s\\\"' %\\n token.string, token.previous, Position.All(token.previous.string))\\n\\n if token.type == Type.END_BRACKET:\\n last_code = token.metadata.last_code\\n if last_code.IsOperator(','):\\n self._HandleError(errors.COMMA_AT_END_OF_LITERAL,\\n 'Illegal comma at end of array literal', last_code,\\n Position.All(last_code.string))\\n\\n elif type == Type.WHITESPACE:\\n if self.ILLEGAL_TAB.search(token.string):\\n if token.IsFirstInLine():\\n self._HandleError(errors.ILLEGAL_TAB,\\n 'Illegal tab in whitespace before \\\"%s\\\"' % token.next.string,\\n token, Position.All(token.string))\\n else:\\n self._HandleError(errors.ILLEGAL_TAB,\\n 'Illegal tab in whitespace after \\\"%s\\\"' % token.previous.string,\\n token, Position.All(token.string))\\n\\n # Check whitespace length if it's not the first token of the line and\\n # if it's not immediately before a comment.\\n if last_in_line:\\n # Check for extra whitespace at the end of a line.\\n self._HandleError(errors.EXTRA_SPACE, 'Extra space at end of line',\\n token, Position.All(token.string))\\n elif not first_in_line and not token.next.IsComment():\\n if token.length > 1:\\n self._HandleError(errors.EXTRA_SPACE, 'Extra space after \\\"%s\\\"' %\\n token.previous.string, token,\\n Position(1, len(token.string) - 1))\\n\\n elif type == Type.OPERATOR:\\n last_code = token.metadata.last_code\\n\\n if not self._ExpectSpaceBeforeOperator(token):\\n if (token.previous and token.previous.type == Type.WHITESPACE and\\n last_code and last_code.type in (Type.NORMAL, Type.IDENTIFIER)):\\n self._HandleError(errors.EXTRA_SPACE,\\n 'Extra space before \\\"%s\\\"' % token.string, token.previous,\\n Position.All(token.previous.string))\\n\\n elif (token.previous and\\n not token.previous.IsComment() and\\n token.previous.type in Type.EXPRESSION_ENDER_TYPES):\\n self._HandleError(errors.MISSING_SPACE,\\n 'Missing space before \\\"%s\\\"' % token.string, token,\\n Position.AtBeginning())\\n\\n # Check that binary operators are not used to start lines.\\n if ((not last_code or last_code.line_number != token.line_number) and\\n not token.metadata.IsUnaryOperator()):\\n self._HandleError(errors.LINE_STARTS_WITH_OPERATOR,\\n 'Binary operator should go on previous line \\\"%s\\\"' % token.string,\\n token)\\n\\n elif type == Type.DOC_FLAG:\\n flag = token.attached_object\\n\\n if flag.flag_type == 'bug':\\n # TODO(robbyw): Check for exactly 1 space on the left.\\n string = token.next.string.lstrip()\\n string = string.split(' ', 1)[0]\\n\\n if not string.isdigit():\\n self._HandleError(errors.NO_BUG_NUMBER_AFTER_BUG_TAG,\\n '@bug should be followed by a bug number', token)\\n\\n elif flag.flag_type == 'suppress':\\n if flag.type is None:\\n # A syntactically invalid suppress tag will get tokenized as a normal\\n # flag, indicating an error.\\n self._HandleError(errors.INCORRECT_SUPPRESS_SYNTAX,\\n 'Invalid suppress syntax: should be @suppress {errortype}. '\\n 'Spaces matter.', token)\\n elif flag.type not in state.GetDocFlag().SUPPRESS_TYPES:\\n self._HandleError(errors.INVALID_SUPPRESS_TYPE,\\n 'Invalid suppression type: %s' % flag.type,\\n token)\\n\\n elif FLAGS.strict and flag.flag_type == 'author':\\n # TODO(user): In non strict mode check the author tag for as much as\\n # it exists, though the full form checked below isn't required.\\n string = token.next.string\\n result = self.AUTHOR_SPEC.match(string)\\n if not result:\\n self._HandleError(errors.INVALID_AUTHOR_TAG_DESCRIPTION,\\n 'Author tag line should be of the form: '\\n '@author foo@somewhere.com (Your Name)',\\n token.next)\\n else:\\n # Check spacing between email address and name. Do this before\\n # checking earlier spacing so positions are easier to calculate for\\n # autofixing.\\n num_spaces = len(result.group(2))\\n if num_spaces < 1:\\n self._HandleError(errors.MISSING_SPACE,\\n 'Missing space after email address',\\n token.next, Position(result.start(2), 0))\\n elif num_spaces > 1:\\n self._HandleError(errors.EXTRA_SPACE,\\n 'Extra space after email address',\\n token.next,\\n Position(result.start(2) + 1, num_spaces - 1))\\n\\n # Check for extra spaces before email address. Can't be too few, if\\n # not at least one we wouldn't match @author tag.\\n num_spaces = len(result.group(1))\\n if num_spaces > 1:\\n self._HandleError(errors.EXTRA_SPACE,\\n 'Extra space before email address',\\n token.next, Position(1, num_spaces - 1))\\n\\n elif (flag.flag_type in state.GetDocFlag().HAS_DESCRIPTION and\\n not self._limited_doc_checks):\\n if flag.flag_type == 'param':\\n if flag.name is None:\\n self._HandleError(errors.MISSING_JSDOC_PARAM_NAME,\\n 'Missing name in @param tag', token)\\n\\n if not flag.description or flag.description is None:\\n flag_name = token.type\\n if 'name' in token.values:\\n flag_name = '@' + token.values['name']\\n self._HandleError(errors.MISSING_JSDOC_TAG_DESCRIPTION,\\n 'Missing description in %s tag' % flag_name, token)\\n else:\\n self._CheckForMissingSpaceBeforeToken(flag.description_start_token)\\n\\n # We want punctuation to be inside of any tags ending a description,\\n # so strip tags before checking description. See bug 1127192. Note\\n # that depending on how lines break, the real description end token\\n # may consist only of stripped html and the effective end token can\\n # be different.\\n end_token = flag.description_end_token\\n end_string = htmlutil.StripTags(end_token.string).strip()\\n while (end_string == '' and not\\n end_token.type in Type.FLAG_ENDING_TYPES):\\n end_token = end_token.previous\\n if end_token.type in Type.FLAG_DESCRIPTION_TYPES:\\n end_string = htmlutil.StripTags(end_token.string).rstrip()\\n\\n if not (end_string.endswith('.') or end_string.endswith('?') or\\n end_string.endswith('!')):\\n # Find the position for the missing punctuation, inside of any html\\n # tags.\\n desc_str = end_token.string.rstrip()\\n while desc_str.endswith('>'):\\n start_tag_index = desc_str.rfind('<')\\n if start_tag_index < 0:\\n break\\n desc_str = desc_str[:start_tag_index].rstrip()\\n end_position = Position(len(desc_str), 0)\\n\\n self._HandleError(\\n errors.JSDOC_TAG_DESCRIPTION_ENDS_WITH_INVALID_CHARACTER,\\n ('%s descriptions must end with valid punctuation such as a '\\n 'period.' % token.string),\\n end_token, end_position)\\n\\n if flag.flag_type in state.GetDocFlag().HAS_TYPE:\\n if flag.type_start_token is not None:\\n self._CheckForMissingSpaceBeforeToken(\\n token.attached_object.type_start_token)\\n\\n if flag.type and flag.type != '' and not flag.type.isspace():\\n self._CheckJsDocType(token)\\n\\n if type in (Type.DOC_FLAG, Type.DOC_INLINE_FLAG):\\n if (token.values['name'] not in state.GetDocFlag().LEGAL_DOC and\\n token.values['name'] not in FLAGS.custom_jsdoc_tags):\\n self._HandleError(errors.INVALID_JSDOC_TAG,\\n 'Invalid JsDoc tag: %s' % token.values['name'], token)\\n\\n if (FLAGS.strict and token.values['name'] == 'inheritDoc' and\\n type == Type.DOC_INLINE_FLAG):\\n self._HandleError(errors.UNNECESSARY_BRACES_AROUND_INHERIT_DOC,\\n 'Unnecessary braces around @inheritDoc',\\n token)\\n\\n elif type == Type.SIMPLE_LVALUE:\\n identifier = token.values['identifier']\\n\\n if ((not state.InFunction() or state.InConstructor()) and\\n not state.InParentheses() and not state.InObjectLiteralDescendant()):\\n jsdoc = state.GetDocComment()\\n if not state.HasDocComment(identifier):\\n # Only test for documentation on identifiers with .s in them to\\n # avoid checking things like simple variables. We don't require\\n # documenting assignments to .prototype itself (bug 1880803).\\n if (not state.InConstructor() and\\n identifier.find('.') != -1 and not\\n identifier.endswith('.prototype') and not\\n self._limited_doc_checks):\\n comment = state.GetLastComment()\\n if not (comment and comment.lower().count('jsdoc inherited')):\\n self._HandleError(errors.MISSING_MEMBER_DOCUMENTATION,\\n \\\"No docs found for member '%s'\\\" % identifier,\\n token);\\n elif jsdoc and (not state.InConstructor() or\\n identifier.startswith('this.')):\\n # We are at the top level and the function/member is documented.\\n if identifier.endswith('_') and not identifier.endswith('__'):\\n if jsdoc.HasFlag('override'):\\n self._HandleError(errors.INVALID_OVERRIDE_PRIVATE,\\n '%s should not override a private member.' % identifier,\\n jsdoc.GetFlag('override').flag_token)\\n # Can have a private class which inherits documentation from a\\n # public superclass.\\n if jsdoc.HasFlag('inheritDoc') and not jsdoc.HasFlag('constructor'):\\n self._HandleError(errors.INVALID_INHERIT_DOC_PRIVATE,\\n '%s should not inherit from a private member.' % identifier,\\n jsdoc.GetFlag('inheritDoc').flag_token)\\n if (not jsdoc.HasFlag('private') and\\n not ('underscore' in jsdoc.suppressions)):\\n self._HandleError(errors.MISSING_PRIVATE,\\n 'Member \\\"%s\\\" must have @private JsDoc.' %\\n identifier, token)\\n if jsdoc.HasFlag('private') and 'underscore' in jsdoc.suppressions:\\n self._HandleError(errors.UNNECESSARY_SUPPRESS,\\n '@suppress {underscore} is not necessary with @private',\\n jsdoc.suppressions['underscore'])\\n elif jsdoc.HasFlag('private'):\\n self._HandleError(errors.EXTRA_PRIVATE,\\n 'Member \\\"%s\\\" must not have @private JsDoc' %\\n identifier, token)\\n\\n if ((jsdoc.HasFlag('desc') or jsdoc.HasFlag('hidden'))\\n and not identifier.startswith('MSG_')\\n and identifier.find('.MSG_') == -1):\\n # TODO(user): Update error message to show the actual invalid\\n # tag, either @desc or @hidden.\\n self._HandleError(errors.INVALID_USE_OF_DESC_TAG,\\n 'Member \\\"%s\\\" should not have @desc JsDoc' % identifier,\\n token)\\n\\n # Check for illegaly assigning live objects as prototype property values.\\n index = identifier.find('.prototype.')\\n # Ignore anything with additional .s after the prototype.\\n if index != -1 and identifier.find('.', index + 11) == -1:\\n equal_operator = tokenutil.SearchExcept(token, Type.NON_CODE_TYPES)\\n next_code = tokenutil.SearchExcept(equal_operator, Type.NON_CODE_TYPES)\\n if next_code and (\\n next_code.type in (Type.START_BRACKET, Type.START_BLOCK) or\\n next_code.IsOperator('new')):\\n self._HandleError(errors.ILLEGAL_PROTOTYPE_MEMBER_VALUE,\\n 'Member %s cannot have a non-primitive value' % identifier,\\n token)\\n\\n elif type == Type.END_PARAMETERS:\\n # Find extra space at the end of parameter lists. We check the token\\n # prior to the current one when it is a closing paren.\\n if (token.previous and token.previous.type == Type.PARAMETERS\\n and self.ENDS_WITH_SPACE.search(token.previous.string)):\\n self._HandleError(errors.EXTRA_SPACE, 'Extra space before \\\")\\\"',\\n token.previous)\\n\\n jsdoc = state.GetDocComment()\\n if state.GetFunction().is_interface:\\n if token.previous and token.previous.type == Type.PARAMETERS:\\n self._HandleError(errors.INTERFACE_CONSTRUCTOR_CANNOT_HAVE_PARAMS,\\n 'Interface constructor cannot have parameters',\\n token.previous)\\n elif (state.InTopLevel() and jsdoc and not jsdoc.HasFlag('see')\\n and not jsdoc.InheritsDocumentation()\\n and not state.InObjectLiteralDescendant() and not\\n jsdoc.IsInvalidated()):\\n distance, edit = jsdoc.CompareParameters(state.GetParams())\\n if distance:\\n params_iter = iter(state.GetParams())\\n docs_iter = iter(jsdoc.ordered_params)\\n\\n for op in edit:\\n if op == 'I':\\n # Insertion.\\n # Parsing doc comments is the same for all languages\\n # but some languages care about parameters that don't have\\n # doc comments and some languages don't care.\\n # Languages that don't allow variables to by typed such as\\n # JavaScript care but languages such as ActionScript or Java\\n # that allow variables to be typed don't care.\\n if not self._limited_doc_checks:\\n self.HandleMissingParameterDoc(token, params_iter.next())\\n\\n elif op == 'D':\\n # Deletion\\n self._HandleError(errors.EXTRA_PARAMETER_DOCUMENTATION,\\n 'Found docs for non-existing parameter: \\\"%s\\\"' %\\n docs_iter.next(), token)\\n elif op == 'S':\\n # Substitution\\n if not self._limited_doc_checks:\\n self._HandleError(errors.WRONG_PARAMETER_DOCUMENTATION,\\n 'Parameter mismatch: got \\\"%s\\\", expected \\\"%s\\\"' %\\n (params_iter.next(), docs_iter.next()), token)\\n\\n else:\\n # Equality - just advance the iterators\\n params_iter.next()\\n docs_iter.next()\\n\\n elif type == Type.STRING_TEXT:\\n # If this is the first token after the start of the string, but it's at\\n # the end of a line, we know we have a multi-line string.\\n if token.previous.type in (Type.SINGLE_QUOTE_STRING_START,\\n Type.DOUBLE_QUOTE_STRING_START) and last_in_line:\\n self._HandleError(errors.MULTI_LINE_STRING,\\n 'Multi-line strings are not allowed', token)\\n\\n\\n # This check is orthogonal to the ones above, and repeats some types, so\\n # it is a plain if and not an elif.\\n if token.type in Type.COMMENT_TYPES:\\n if self.ILLEGAL_TAB.search(token.string):\\n self._HandleError(errors.ILLEGAL_TAB,\\n 'Illegal tab in comment \\\"%s\\\"' % token.string, token)\\n\\n trimmed = token.string.rstrip()\\n if last_in_line and token.string != trimmed:\\n # Check for extra whitespace at the end of a line.\\n self._HandleError(errors.EXTRA_SPACE, 'Extra space at end of line',\\n token, Position(len(trimmed), len(token.string) - len(trimmed)))\\n\\n # This check is also orthogonal since it is based on metadata.\\n if token.metadata.is_implied_semicolon:\\n self._HandleError(errors.MISSING_SEMICOLON,\\n 'Missing semicolon at end of line', token)\",\n \"def validate_token():\\n global vault_token\\n global vault_token_time\\n\\n if vault_token is None:\\n return False\\n\\n return datetime.datetime.now() < vault_token_time\",\n \"def test_missing_all_tokens(self):\\n self.helper_test_evaluate_raises(\\n '(A nand B) and not D',\\n expected_exc_type=MissingSymbolError)\",\n \"def validation(self, tokens):\\n return self.process_value_pairs(tokens, \\\"validation\\\")\",\n \"def __token_is_valid(self):\\n\\n if not self.__login_token or len(self.__login_token) < 10:\\n # Token is not set or totally invalid\\n return False\\n\\n try:\\n jwt.decode(self.__login_token, verify = False)\\n return True\\n except:\\n # Most likely the token is expired as `exp` is in the past\\n return False\",\n \"def isValid(token):\\n try:\\n decoded = jwt.decode(token, SECRET_KEY)\\n return True\\n except:\\n return False\",\n \"def test_gen_and_verify_good_token(self):\\n config.set(xsrf_token_key='abcdef')\\n tool = utils.XsrfTool()\\n token = tool.generate_token(12345, 'test_action')\\n self.assertTrue(tool.verify_token(token, 12345, 'test_action'))\",\n \"def check_token(token, secret, message=None):\\n\\n config = prologin.config.load('timeauth')\\n\\n if not config['enabled']:\\n return True\\n\\n if token is None:\\n return False\\n\\n # Reject badly formatted tokens.\\n chunks = token.split(':')\\n if len(chunks) != 2:\\n return False\\n try:\\n timestamp = int(chunks[0])\\n except ValueError:\\n return False\\n\\n # Reject outdated tokens.\\n if time.time() - timestamp > TOKEN_TIMEOUT:\\n return False\\n\\n # Check if the token is valid.\\n return hmac.compare_digest(\\n get_hmac(secret, str(message) + chunks[0]), chunks[1]\\n )\",\n \"def identify_errors(tokens, dictionary):\\n return set(tokens).difference(dictionary)\",\n \"def check_symbols(self):\\n # this method has a bug in that it never raises KeyError, it raises \\n # ValueError instead.\\n \\n def is_valid(sym):\\n # what symbols are valid? (, ), digits, atoms\\n if sym in \\\"()\\\": return True\\n #if sym.isdigit(): return True\\n #if sym in _atomic_mass: return True\\n if sym.isalnum(): return True\\n return False\\n\\n for t in self._gettokens():\\n if not is_valid(t): raise ValueError(\\\"bad symbol \\\" + t)\\n if t.isalpha() and t not in _atomic_mass: raise KeyError(\\\"key error \\\" + t)\\n return True\",\n \"def _match(self, *token_types):\\n for token in token_types:\\n if self._check(token):\\n self._advance()\\n return True\\n\\n return False\",\n \"def validate_token(self):\\n r = requests.get(urljoin(self._url, Client._token_resource),\\n params={\\\"tokenid\\\": self._token_id})\\n\\n if r.status_code == requests.status_codes.codes.unauthorized:\\n raise ClientUnauthorized()\\n elif r.status_code != requests.status_codes.codes.ok:\\n error_messages = self._parse_invalid_request(r.text)\\n raise ClientException(r.status_code, error_messages)\\n\\n try:\\n type_, value = r.text.split(\\\"=\\\")\\n value = value.strip(\\\" \\\\r\\\\n\\\")\\n except Exception, e:\\n raise ClientException(r.status_code,\\n \\\"Some error has ocurred getting the result value from %s\\\"\\n % r.text)\\n\\n return value == \\\"true\\\"\",\n \"def _check_grammar(seq, accepted_tokens):\\r\\n if len(seq) == 0:\\r\\n if accepted_tokens == [0, 3]:\\r\\n return True\\r\\n else:\\r\\n return False\\r\\n if seq[0] in accepted_tokens:\\r\\n curr_token = seq[0]\\r\\n if curr_token in [0, 2]:\\r\\n next_possible_tokens = [1, 2]\\r\\n elif curr_token in [1, 3]:\\r\\n next_possible_tokens = [0, 3]\\r\\n else:\\r\\n raise ValueError\\r\\n return Model._check_grammar(seq[1:], next_possible_tokens)\\r\\n return False\",\n \"def test_bad_token(self):\\n user = self.create_user()\\n\\n token_generator = EmailActivationTokenGenerator()\\n bad_activation_keys = (\\n 'emailactivationtokengenerator',\\n 'emailactivation-tokengenerator',\\n '3rd-bademailactivationkey'\\n )\\n for key in bad_activation_keys:\\n self.assertFalse(token_generator.check_token(user, key))\",\n \"def test_regex_matches_multiple_valid(self):\\n token_1 = \\\"NDY3MjIzMjMwNjUwNzc3NjQx.XsyWGg.uFNEQPCc4ePwGh7egG8UicQssz8\\\"\\n token_2 = \\\"NDcyMjY1OTQzMDYyNDEzMzMy.XsyWMw.l8XPnDqb0lp-EiQ2g_0xVFT1pyc\\\"\\n message = f\\\"garbage {token_1} hello {token_2} world\\\"\\n\\n results = token_remover.TOKEN_RE.finditer(message)\\n results = [match[0] for match in results]\\n self.assertCountEqual((token_1, token_2), results)\",\n \"def validate(data, badchars):\\n assert(all(b not in data for b in badchars))\",\n \"def test_is_valid_timestamp_invalid(self):\\n timestamps = (\\n (\\\"B4Yffw\\\", \\\"DISCORD_EPOCH - TOKEN_EPOCH - 1\\\"),\\n (\\\"ew\\\", \\\"123\\\"),\\n (\\\"AoIKgA\\\", \\\"42076800\\\"),\\n (\\\"{hello}[world]&(bye!)\\\", \\\"ASCII invalid Base64\\\"),\\n (\\\"Þíß-ï§-ňøẗ-våłìÐ\\\", \\\"Unicode invalid Base64\\\"),\\n )\\n\\n for timestamp, msg in timestamps:\\n with self.subTest(msg=msg):\\n result = TokenRemover.is_valid_timestamp(timestamp)\\n self.assertFalse(result)\",\n \"def evaluate_tokenization(test_tokens, gold_tokens):\\n matcher = difflib.SequenceMatcher()\\n matcher.set_seqs(test_tokens, gold_tokens)\\n error_chunks = true_positives = false_positives = false_negatives = 0\\n print(\\\" Token%30s | %-30sToken\\\" % (\\\"Error\\\", \\\"Correct\\\"))\\n print(\\\"-\\\" * 38 + \\\"+\\\" + \\\"-\\\" * 38)\\n for difftype, test_from, test_to, gold_from, gold_to in matcher.get_opcodes():\\n if difftype == \\\"equal\\\":\\n true_positives += test_to - test_from\\n else:\\n false_positives += test_to - test_from\\n false_negatives += gold_to - gold_from\\n error_chunks += 1\\n test_chunk = \\\" \\\".join(test_tokens[test_from:test_to])\\n gold_chunk = \\\" \\\".join(gold_tokens[gold_from:gold_to])\\n print(\\\"%6d%30s | %-30s%d\\\" % (test_from, test_chunk, gold_chunk,gold_from))\\n precision = 1.0 * true_positives / (true_positives + false_positives)\\n recall = 1.0 * true_positives / (true_positives + false_negatives)\\n fscore = 2.0 * precision * recall / (precision + recall)\\n print()\\n print(\\\"Test size: %5d tokens\\\" % len(test_tokens))\\n print(\\\"Gold size: %5d tokens\\\" % len(gold_tokens))\\n print(\\\"Nr errors: %5d chunks\\\" % error_chunks)\\n print(\\\"Precision: %5.2f %%\\\" % (100 * precision))\\n print(\\\"Recall: %5.2f %%\\\" % (100 * recall))\\n print(\\\"F-score: %5.2f %%\\\" % (100 * fscore))\",\n \"def test_is_valid_user_id_valid(self):\\n ids = (\\n \\\"NDcyMjY1OTQzMDYyNDEzMzMy\\\",\\n \\\"NDc1MDczNjI5Mzk5NTQ3OTA0\\\",\\n \\\"NDY3MjIzMjMwNjUwNzc3NjQx\\\",\\n )\\n\\n for user_id in ids:\\n with self.subTest(user_id=user_id):\\n result = TokenRemover.is_valid_user_id(user_id)\\n self.assertTrue(result)\",\n \"def is_token_valid(self,pk,request):\\n\\n pass\",\n \"def _check_special_token_identifier(key):\\n if not (key.endswith('_token') and key != '_token'):\\n raise ValueError('Each key needs to have the form \\\"name_token\\\".'\\n ' Received {}'.format(key))\",\n \"def check_composite_tokens(self, name, tokens):\\n assert len(tokens) >= 2\\n key = tokens[0]\\n\\n assert key.value.lower() == name\\n assert tokens[-1].value.lower() == \\\"end\\\"\\n\\n if len(tokens) == 2:\\n body = [] # empty TYPE..END block\\n else:\\n body = tokens[1:-1]\\n\\n body_tokens = []\\n\\n for t in body:\\n if isinstance(t, dict):\\n body_tokens.append(t[\\\"__tokens__\\\"])\\n else:\\n body_tokens.append(t)\\n return key, body_tokens\",\n \"def test_authtoken_is_valid(self):\\n auth_client = self.fixtures.auth_client\\n # scenario 1: when validity is unlimited (0)\\n tomriddle = models.User(username='voldemort', fullname='Tom Riddle')\\n scope = ['id', 'email']\\n tomriddle_token = models.AuthToken(\\n auth_client=auth_client, user=tomriddle, scope=scope, validity=0\\n )\\n self.assertTrue(tomriddle_token.is_valid())\\n\\n # scenario 2: when validity has not been given\\n draco = models.User(username='draco', fullname='Draco Malfoy')\\n draco_token = models.AuthToken(auth_client=auth_client, user=draco, scope=scope)\\n with self.assertRaises(TypeError):\\n draco_token.is_valid()\\n\\n # scenario 3: when validity is limited\\n harry = models.User(username='harry', fullname='Harry Potter')\\n harry_token = models.AuthToken(\\n auth_client=auth_client,\\n user=harry,\\n scope=scope,\\n validity=3600,\\n created_at=utcnow(),\\n )\\n self.assertTrue(harry_token.is_valid())\\n\\n # scenario 4: when validity is limited *and* the token has expired\\n cedric = models.User(username='cedric', fullname='Cedric Diggory')\\n cedric_token = models.AuthToken(\\n auth_client=auth_client,\\n user=cedric,\\n scope=scope,\\n validity=1,\\n created_at=utcnow() - timedelta(1),\\n )\\n self.assertFalse(cedric_token.is_valid())\",\n \"def test_expired_thread_token_is_valid(self):\\n self.token.modified = self.days_ago(const.THREAD_TOKEN_EXPIRY + 1)\\n assert not self.token.is_valid()\",\n \"def check_if_token_is_valid(token):\\n if token is None:\\n return\\n try:\\n jwt.decode(\\n token,\\n key=current_app.config['JWT_KEY'],\\n audience=current_app.config['AUTH0_BASE_URL'] + '/api/v2/',\\n issuer=current_app.config['AUTH0_BASE_URL'] + '/')\\n except (jwt.JWTError,\\n jwk.JWKError,\\n jwt.ExpiredSignatureError,\\n jwt.JWTClaimsError,\\n AttributeError,\\n AssertionError,\\n IndexError):\\n return False\\n else:\\n return True\",\n \"def isValidNew(cls,corpus):\\n valid = True\\n valid = valid and Validator.checkRelentitytypes(corpus)\\n # Subtokens do not yet fulfill the requirements\\n # valid = valid and Validator.checkSubtokens(corpus)\\n valid = valid and Validator.checkDeptokens(corpus)\\n valid = valid and Validator.checkReltokens(corpus)\\n # \\n return(valid)\",\n \"def _validar_token(self):\\n\\n\\t\\ttoken = request.headers.get(\\\"Authorization\\\").split(\\\" \\\")[1]\\n\\n\\t\\tres = self.autenticador.validarToken(token)\\n\\t\\tif(not res):\\n\\t\\t\\treturn False\\n\\t\\treturn True\",\n \"def _check_for_typos(all_tokens):\\n d = enchant.DictWithPWL(\\\"en_US\\\",\\\"mywords.txt\\\")\\n known_typo_list = enchant.DictWithPWL(\\\"en_US\\\", \\\"add_to_typo_list.txt\\\")\\n unknown_word_list = enchant.DictWithPWL(\\\"en_US\\\", \\\"unknown_words.txt\\\")\\n\\n counter = 0\\n incorrect_token_list = []\\n for token in all_tokens:\\n counter += 1\\n is_correct = d.check(token)\\n known_typo = known_typo_list.check(token)\\n unknown_word = unknown_word_list.check(token)\\n\\n if not is_correct and not known_typo and not unknown_word and len(token) > 4:\\n # print counter, \\\"Token: \\\", token, \\\", IC: \\\", is_correct, \\\"KT: \\\", known_typo, \\\"UW: \\\", unknown_word, \\\"LEN: \\\", len(token)\\n print token\\n if token not in incorrect_token_list:\\n incorrect_token_list.append(token)\\n print \\\"** Num Incorrect: \\\", len(incorrect_token_list)\",\n \"def compare_token(got, expected):\\n if len(got) != len(expected):\\n return False\\n for i in range(len(got)):\\n if not compare_character(got[i], expected[i]):\\n return False\\n # just to be extra sure, also compare the hashes (yes, we're cheating\\n # here to make it easier to guess the last character)\\n got_enc = (''.join(got)).encode('utf-8')\\n expected_enc = (''.join(expected)).encode('utf-8')\\n return hashlib.sha1(got_enc).digest() == hashlib.sha1(expected_enc).digest()\",\n \"def is_valid(data):\\n return isinstance(data, dict) \\\\\\n and \\\"u_id\\\" in data \\\\\\n and \\\"token\\\" in data \\\\\\n and isinstance(data[\\\"u_id\\\"], int) \\\\\\n and isinstance(data[\\\"token\\\"], str)\",\n \"def validate_token(user, tkn):\\n try:\\n decoded = jwt.decode(tkn, KEY)\\n if decoded['user'] == user:\\n stored_token = User.get(User.username == user).token\\n if stored_token == tkn:\\n return True\\n return False\\n except jwt.ExpiredSignatureError:\\n return HTTPResponse(status=400, body={\\\"msg\\\":\\\"Validation error.\\\"})\",\n \"def is_valid(text):\\n return is_all_word_segment_in_text(WORDS, text)\",\n \"def contains_tokens(pattern):\\n return type(pattern) is list and len(pattern) > 0\",\n \"def test_open_closed(self):\\n nt = NewickTokenizer(newick='(a,(),(d,e));')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def verify_token(self, token):\\n _now = timezone.now()\\n\\n if (\\n (self.token is not None)\\n and (token == self.token)\\n and (_now < self.valid_until)\\n ):\\n self.token = None\\n self.valid_until = _now\\n self.save()\\n\\n return True\\n else:\\n return False\",\n \"def check_token(self, *args) -> bool:\\n if len(args) == 1:\\n if isinstance(args[0], str):\\n return self.token_name == args[0]\\n elif isinstance(args[0], _Enum):\\n return self.token_name == args[0].name\\n elif isinstance(args[0], _Sequence):\\n return self.token_name in args[0]\\n raise TypeError(\\\"_check_token() taking 1 argument, type: str, Enum or Sequence\\\")\",\n \"def test_parser(test_input, expected):\\n tokens = list(sp.tokenize(test_input))\\n assert tokens == expected\",\n \"def check_token(token):\\n # Avoid SQL injection before doing requests\\n # with the token and check the validity of it.\\n token = MySQLdb.escape_string(token)\\n if not validator_db.valid_token(token):\\n return custom_response(400, responseMessage.BAD_TOKEN)\\n\\n return Response(status=200)\",\n \"def token_valid_check(start_time):\\n #calculate the time elapsed since token was last refreshed\\n elapsed_time = time.time() - start_time\\n #take action if token is expired\\n if elapsed_time > 3540:\\n return False\\n return True\",\n \"def test_is_token_json_temporally_valid(self):\\n payload_list = []\\n\\n # Test that we reject a payload without 'iat' or 'exp'\\n # as the tokens should have a lifetime\\n payload_list.append({\\n 'sub': CLIENT_ID,\\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\\n 'jti': '714892f5-014f-43ad-bea0-fa47579db222'\\n })\\n\\n # Test that we reject a payload without 'exp'\\n # as such a token would never expire\\n payload_list.append({\\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\\n 'jti': '098cb343-c45e-490d-8aa0-ce1873cdc5f8',\\n 'iat': int(time.time()) - 2000000,\\n 'sub': CLIENT_ID\\n })\\n\\n # Test that we reject a payload without 'iat'\\n # as all tokens should indicate when they were issued\\n payload_list.append({\\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\\n 'jti': '098cb343-c45e-490d-8aa0-ce1873cdc5f8',\\n 'sub': CLIENT_ID,\\n 'exp': int(time.time()) + 200000\\n })\\n\\n # Test that we reject a payload with an 'iat' and 'exp'\\n # in the past (e.g. they have expired)\\n payload_list.append({\\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\\n 'jti': '098cb343-c45e-490d-8aa0-ce1873cdc5f8',\\n 'iat': int(time.time()) - 2000000,\\n 'sub': CLIENT_ID,\\n 'exp': int(time.time()) - 200000\\n })\\n\\n # Test that we reject a payload with an 'iat' and 'exp'\\n # in the future (as we should as they are not yet valid)\\n payload_list.append({\\n 'iss': 'https://iam-test.indigo-datacloud.eu/',\\n 'jti': '098cb343-c45e-490d-8aa0-ce1873cdc5f8',\\n 'iat': int(time.time()) + 200000,\\n 'sub': CLIENT_ID,\\n 'exp': int(time.time()) + 2000000\\n })\\n\\n for payload in payload_list:\\n # Assert the underlying helper method reponsible for\\n # checking temporal validity returns False when passed\\n # temporally invalid payloads\\n self.assertFalse(\\n self._token_checker._is_token_json_temporally_valid(payload),\\n \\\"Payload %s should not be accepted!\\\" % payload\\n )\\n\\n # Assert the wrapper method valid_token_to_id returns\\n # None when passed temporally invalid tokens\\n token = self._create_token(payload, PRIVATE_KEY)\\n self.assertEqual(\\n self._token_checker.valid_token_to_id(token), None,\\n \\\"Token with payload %s should not be accepted!\\\" % payload\\n )\",\n \"def _assert_valid(self, token_id, token_ref):\\n current_time = timeutils.normalize_time(timeutils.utcnow())\\n expires = token_ref.get('expires')\\n if not expires or current_time > timeutils.normalize_time(expires):\\n raise exception.TokenNotFound(token_id=token_id)\",\n \"def validate(self, username: str, token: str, check_privilege: Optional[str] = None) -> bool:\\n cursor = self._db_connection.cursor()\\n\\n # Get UID from the user's username\\n uid = self.get_uid(username=username)\\n\\n # Check access control privilege (if specified)\\n if check_privilege is not None:\\n # Get list of privileges associated with the user (if specified)\\n cursor.execute('''SELECT privilege FROM access_control WHERE uid = ?''', (uid,))\\n db_result = cursor.fetchall()\\n privileges = [chunked[0] for chunked in db_result]\\n\\n # If the user does not have the given privilege\\n if check_privilege not in privileges:\\n return False\\n\\n # Get list of tokens associated with a user, if they exist\\n cursor.execute(\\n '''\\n SELECT\\n expiration_datetime\\n FROM \\n tokens \\n WHERE \\n uid = ? \\n AND \\n token_content = ?\\n ORDER BY \\n expiration_datetime\\n ;\\n ''',\\n (uid, token)\\n )\\n db_result = cursor.fetchone()\\n\\n # If there aren't any associate tokens in the DB (the user will need to authenticate first!)\\n if db_result is None:\\n return False\\n\\n # Verify token is not expired\\n expiration_datetime = db_result[0]\\n if datetime.datetime.fromisoformat(expiration_datetime) < datetime.datetime.now():\\n return False\\n else:\\n return True\",\n \"def test_valid_token(self, mock_check_token_not_revoked,\\n mock_get_issuer_public_key):\\n # Mock the external call to retrieve the IAM public key\\n # used in the _verify_token and valid_token_to_id call\\n mock_get_issuer_public_key.return_value = PUBLIC_KEY\\n # Mock the external call to check the token has not been rejected\\n # used in the valid_token_to_id call\\n mock_check_token_not_revoked.return_value = CLIENT_ID\\n\\n # This payload will be valid as we will sign it with PRIVATE_KEY\\n payload = self._standard_token()\\n\\n token = self._create_token(payload, PRIVATE_KEY)\\n\\n with self.settings(IAM_HOSTNAME_LIST=['iam-test.idc.eu']):\\n client_id = payload['sub']\\n self.assertEqual(\\n self._token_checker.valid_token_to_id(token), client_id,\\n \\\"Token with payload %s should be accepted!\\\" % payload\\n )\",\n \"def validate(self, encrypted_token: str) -> bool:\\n payload, timestamp_ms, crc = self.unsleeve(encrypted_token)\\n ts_bytes = timestamp_ms.to_bytes(8, 'big')\\n\\n computed_crc = zlib.crc32(payload + ts_bytes)\\n\\n if crc == computed_crc:\\n return in_range(timestamp_ms, deadline=self.token_life_ms)\\n\\n return False\",\n \"def check_token_validate(self, token):\\n payload = {'key': self._lr_object._get_api_key(), 'secret': self._lr_object._get_api_secret(), 'access_token': token}\\n url = SECURE_API_URL + \\\"api/v2/access_token/Validate/\\\"\\n return self._lr_object._get_json(url, payload)\",\n \"def verify_csrf_token(token=''):\\n\\tif not token:\\n\\t\\ttoken = managers.request_manager.get_request().arguments().arguments().get(csrf_token_arg_name, \\\"\\\")\\n\\t\\tif token:\\n\\t\\t\\ttoken = token[0]\\n\\tif len(token) != 2 * digest_size + 2 * csrf_salt_len:\\n\\t\\tdebug('Incorrect csrf token length')\\n\\t\\traise VDOM_csrf_exception()\\n\\tsalt = token[2*digest_size:]\\n\\tif token != create_csrf_token(salt):\\n\\t\\tdebug('Incorrect csrf token value')\\n\\t\\traise VDOM_csrf_exception()\",\n \"def validate_words(self):\\n if not self.words or not self.mnemonic.check(self.words):\\n raise InvalidWords\",\n \"def test_validate_input_rejection_invalid_symbol(self):\\n with nose.assert_raises(exceptions.RejectionError):\\n self.dtm1.validate_input('02')\",\n \"def sanity_check(secret):\\n matches = list()\\n for cur_file in CASSETTE_PATH.rglob(\\\"*.yaml\\\"):\\n if secret in cur_file.read_text():\\n matches.append(cur_file)\\n if matches:\\n click.secho(\\\"Found {0} cassettes that still mention auth token:\\\".format(len(matches)), fg=\\\"red\\\")\\n for cur_match in matches:\\n click.secho(\\\"\\\\t{0}\\\".format(cur_match.name), fg=\\\"red\\\")\\n return False\\n click.secho(\\\"Cassettes look clean - no mentions of auth tokens!\\\", fg=\\\"green\\\")\\n return True\",\n \"def is_token_valid(self):\\n try:\\n token_details = jwt.decode(self.__token, verify=False)\\n self.__admin_id = token_details[\\\"id\\\"]\\n self.__username = token_details[\\\"username\\\"]\\n expiry = token_details[\\\"expiry\\\"]\\n if time.time() > expiry:\\n raise TokenExpiredException\\n cursor = self.__connection.cursor()\\n cursor.execute(\\n \\\"select password from neutron_admin_credential where admin_id=%s and username=%s\\\",\\n (self.__admin_id, self.__username)\\n )\\n result = cursor.fetchone()\\n if result is None:\\n self.__message = \\\"Invalid id details\\\"\\n return False\\n passsword = result[\\\"password\\\"]\\n admin_secret = passsword + get_admin_credential()\\n jwt.decode(self.__token, key=admin_secret, verify=True)\\n return True\\n except jwt.DecodeError:\\n self.__message = \\\"Invalid Token\\\"\\n return False\\n except KeyError:\\n self.__message = \\\"Insecure Token\\\"\\n return False\\n except ValueError:\\n self.__message = \\\"Insecure Token\\\"\",\n \"def check_token(self, user, token):\\n\\n # Parse the token\\n try:\\n ts_b36, hash = token.split(\\\"-\\\")\\n except ValueError:\\n return False\\n\\n try:\\n ts = base36_to_int(ts_b36)\\n except ValueError:\\n return False\\n\\n # Check that the timestamp/uid has not been tampered with\\n recomputed_token = self._make_token_with_timestamp(user, ts)\\n\\n log.debug(\\\"Ricalcolo re_token=%s token=%s\\\" % (recomputed_token, token))\\n if not constant_time_compare(recomputed_token, token):\\n return False\\n\\n # Check the timestamp is within limit\\n if (self._num_days(self._today()) - ts) > settings.REFERRAL_TOKEN_RESET_TIMEOUT_DAYS:\\n return False\\n\\n return True\",\n \"def containsToken(self, token):\\n if token.sentence != self.tokens[0].sentence:\\n return False # not in same sentence\\n \\n return self.tokens[0].index <= token.index and token.index <= self.tokens[-1].index\",\n \"def test_empty(self):\\n\\n tokens = list(Lexer(\\\"\\\").generate_tokens())\\n self.assertEqual(tokens, [])\",\n \"def wellformedness_check(tokens):\\n stack = []\\n for token in tokens:\\n if token.is_a(Start):\\n stack.append(token)\\n elif token.is_a(End):\\n try:\\n start = stack.pop()\\n except IndexError:\\n raise WellformednessError('Extra end tag found: \\\"%s\\\"' % token.xml)\\n if start.name != token.name:\\n raise WellformednessError('\\\"%s\\\" matched by \\\"%s\\\"' % (start.xml, token.xml))\\n elif token.is_a(Error):\\n raise MarkupError(token.xml + tokens.next().xml)\\n yield token\",\n \"def _validate_token(self):\\n if not self.token:\\n self.login()\\n if not self.token:\\n # TODO: create exception for this\\n # Access is denied!!\\n raise Exception(\\\"AccessDenied\\\")\",\n \"def _check_sanity(self, tags: List[str], n_words: int):\\n n_out = 0\\n\\n for tag in tags:\\n if (\\\"<\\\" not in tag) and (\\\">\\\" not in tag):\\n n_out += 1\\n\\n return n_out == n_words\",\n \"def _check_sanity(self, tags: List[str], n_words: int):\\n n_out = 0\\n\\n for tag in tags:\\n if (\\\"<\\\" not in tag) and (\\\">\\\" not in tag):\\n n_out += 1\\n\\n return n_out == n_words\",\n \"def test_generate_and_validate_token(self):\\n\\n audience = 'http://www.service.teletracking.com/'\\n roles = {'role': ['admin', 'user'], 'audience': audience}\\n secret = 'drMemxWrLen6fCXQA5jO6gXkK/UoZVzPGRDiff7ByPU='\\n token = AuthenticationHandler.generate_auth_token(roles, secret)\\n decoded_token = AuthenticationHandler.validate_and_decode_token(\\n token=token, key=secret,\\n audience=audience\\n )\\n self.assertTrue(decoded_token['role'][0] == 'admin')\\n self.assertTrue(decoded_token['role'][1] == 'user')\",\n \"def validate():\",\n \"def test_issue401(EN, text, i):\\n tokens = EN(text)\\n assert tokens[i].lemma_ != \\\"'\\\"\",\n \"def test_max_used_thread_token_is_valid(self):\\n self.token.use_count = const.MAX_TOKEN_USE_COUNT\\n assert not self.token.is_valid()\",\n \"def test_unclosed(self):\\n nt = NewickTokenizer(newick='(a,(b,c)')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def _is_oauth_token_valid(token: dict, time_key=\\\"expires_on\\\") -> bool:\\n if \\\"access_token\\\" not in token or token.get(\\\"token_type\\\", \\\"\\\") != \\\"Bearer\\\" or time_key not in token:\\n raise AirflowException(f\\\"Can't get necessary data from OAuth token: {token}\\\")\\n\\n return int(token[time_key]) > (int(time.time()) + TOKEN_REFRESH_LEAD_TIME)\",\n \"def test_missing_single_token(self):\\n self.helper_test_evaluate_raises(\\n 'A or (B and (C and not D))',\\n expected_exc_type=MissingSymbolError,\\n A=0,\\n B=1,\\n D=1)\",\n \"def is_valid(url):\\n\\n HAVERFORD_TOKEN = 'Haverford users only'\\n INVALID_TOKENS = [HAVERFORD_TOKEN, \\\"Site Intel\\\", \\\"SITE Institute\\\"]\\n content = urlopen(url).read()\\n\\n for token in INVALID_TOKENS:\\n if token in content:\\n return False\\n return True\",\n \"def validate_token():\\n try:\\n token = validate_auth()\\n except Unauthorized:\\n return jsonify(valid=False, expires_in=0)\\n expires = oidc.user_getfield('exp')\\n delta = expires - datetime.now().timestamp()\\n return jsonify(valid=True, expires_in=delta)\",\n \"def _validate_jwt_token(self):\\n # force https so that we don't send around tokens unsecurely\\n url = 'https://{}/api/token/verify'.format(urlparse(self.base_url).netloc)\\n \\n # paranoid: check again that we only send the token to https\\n if urlparse(url).scheme != \\\"https\\\":\\n msg = 'This should not happen, please file a bug report.'\\n raise Exception(msg)\\n\\n if not self.jwt_access_token:\\n raise FDSNUnauthorizedException(\\\"Unauthorized, authentication \\\"\\n \\\"required.\\\", )\\n\\n # convert to json\\n data = json.dumps({\\\"token\\\": self.jwt_access_token})\\n # encode\\n data = bytes(data, \\\"utf-8\\\")\\n headers = {\\\"Content-Type\\\": \\\"application/json\\\"}\\n html = urllib_request.Request(url, data=data, headers=headers)\\n # decode('utf-8')\\n try:\\n result = urllib_request.urlopen(html).read().decode(\\\"utf-8\\\")\\n dic = json.loads(result)\\n valid = not bool(dic)\\n if self.debug:\\n print('Valid token : {}'.format(valid))\\n return valid\\n except urllib_error.HTTPError as e:\\n return False\",\n \"def check_token(self, token):\\n decoded_token = manage_tokens.decode(token)\\n if decoded_token is None:\\n return {'error': 'Token is invalid'}\\n\\n if 'email' not in decoded_token or 'expires' not in decoded_token \\\\\\n or 'token' not in decoded_token:\\n return {'error': 'Token is invalid'}\\n\\n self.email = decoded_token['email']\\n self.user_in_db = User.users_db.get(decoded_token['email'])\\n\\n if not self.user_in_db:\\n # User does not exist\\n return {'error': 'User does not exist'}\\n\\n if self.user_in_db['token'] != decoded_token['token']:\\n return {'error': 'Token is invalid'}\\n\\n if decoded_token['expires'] < time.time():\\n return {'error': 'Token is expired'}\\n\\n return decoded_token\",\n \"def is_valid_posse(posse: 'Tuple'):\\n # todo: write this as iterator through test types\\n # could use test types as blocks for lambda calculus\\n # for test in attribute tests:\\n\\n # print('testing posse: %s' % str(posse))\\n\\n prefixes = set()\\n cases = set()\\n lengths = set()\\n letters = set()\\n\\n for member in posse:\\n # prefix validity\\n prefixes.add(member[0])\\n\\n # case validity\\n if ord(member[1]) in THIRD_CASE:\\n cases.add(2)\\n elif member[1].isupper():\\n cases.add(1)\\n else:\\n cases.add(0)\\n\\n # length validity\\n lengths.add(len(member[1:]))\\n\\n # letter validity\\n # print('letter validity for %s' % member)\\n for letter_type in LETTER_SETS:\\n if ord(member[1]) in LETTER_SETS[letter_type]:\\n letters.add(letter_type)\\n\\n prefix_is_valid = len(prefixes) == 1 or len(prefixes) == 3\\n case_is_valid = len(cases) == 1 or len(cases) == 3\\n length_is_valid = len(lengths) == 1 or len(lengths) == 3\\n letter_is_valid = len(letters) == 1 or len(letters) == 3\\n\\n # print('prefix_is_valid: %s' % prefix_is_valid)\\n # print('case_is_valid: %s' % case_is_valid)\\n # print('length_is_valid: %s' % length_is_valid)\\n # print('letter_is_valid: %s' % letter_is_valid)\\n\\n return all((prefix_is_valid,\\n case_is_valid,\\n length_is_valid,\\n letter_is_valid))\",\n \"def test_0001(self):\\n assert self.vca.token\",\n \"def test_0001(self):\\n assert self.vca.token\",\n \"def test_0001(self):\\n assert self.vca.token\",\n \"def check_token(token):\\n token = db.session.query(Token).filter(Token.token==token).first()\\n if token == None:\\n return False\\n #TODO token lifetime\\n #if (datetime.datetime.now() - token.date >= datetime.timedelta(day=2)):\\n # return False \\n return True\",\n \"def verify_token(auth_token):\\n blacklisted_token = TokenBlacklisting.query.filter_by(\\n token=str(auth_token)).first()\\n if blacklisted_token:\\n return True\\n return False\",\n \"def check_for_value(tokens):\\n ntoks = 0\\n for tok in tokens:\\n if tok.isspace() or tok == ',':\\n continue\\n elif tok in ('=', '/', '$', '&'):\\n break\\n else:\\n ntoks += 1\\n\\n # If ntoks reaches 2, then there must be at least one value.\\n if ntoks > 1:\\n break\\n\\n return ntoks > 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76983315","0.7479158","0.73251635","0.7157225","0.71501803","0.7138056","0.7013063","0.69469047","0.6733868","0.66120076","0.65514505","0.6477569","0.6383798","0.6369523","0.6334665","0.6297028","0.6261812","0.6243167","0.62244207","0.62236446","0.617018","0.61486495","0.61327624","0.61192405","0.61174166","0.60861504","0.6079028","0.6077153","0.6064271","0.6062483","0.6006739","0.5999209","0.59595793","0.5910464","0.59086096","0.58885956","0.58831793","0.5873542","0.5868498","0.585651","0.5855626","0.5846826","0.5816053","0.5805776","0.58043396","0.57996804","0.5779508","0.57794327","0.5768831","0.5764876","0.5739425","0.5736447","0.5722827","0.5722336","0.571985","0.57188725","0.57030225","0.5689195","0.56782526","0.567312","0.56712157","0.5669115","0.5666193","0.56620395","0.5649251","0.5649157","0.5642529","0.56286824","0.5628064","0.56280607","0.56215477","0.56210285","0.5617797","0.5615381","0.56097305","0.5605717","0.55988604","0.5596003","0.55914813","0.55912113","0.5591202","0.5589017","0.5589017","0.55825967","0.55780834","0.5564855","0.55445075","0.5524806","0.5513394","0.5513314","0.551095","0.5499282","0.5498775","0.5490714","0.5490131","0.5485167","0.5485167","0.5485167","0.5466163","0.5464216","0.54636955"],"string":"[\n \"0.76983315\",\n \"0.7479158\",\n \"0.73251635\",\n \"0.7157225\",\n \"0.71501803\",\n \"0.7138056\",\n \"0.7013063\",\n \"0.69469047\",\n \"0.6733868\",\n \"0.66120076\",\n \"0.65514505\",\n \"0.6477569\",\n \"0.6383798\",\n \"0.6369523\",\n \"0.6334665\",\n \"0.6297028\",\n \"0.6261812\",\n \"0.6243167\",\n \"0.62244207\",\n \"0.62236446\",\n \"0.617018\",\n \"0.61486495\",\n \"0.61327624\",\n \"0.61192405\",\n \"0.61174166\",\n \"0.60861504\",\n \"0.6079028\",\n \"0.6077153\",\n \"0.6064271\",\n \"0.6062483\",\n \"0.6006739\",\n \"0.5999209\",\n \"0.59595793\",\n \"0.5910464\",\n \"0.59086096\",\n \"0.58885956\",\n \"0.58831793\",\n \"0.5873542\",\n \"0.5868498\",\n \"0.585651\",\n \"0.5855626\",\n \"0.5846826\",\n \"0.5816053\",\n \"0.5805776\",\n \"0.58043396\",\n \"0.57996804\",\n \"0.5779508\",\n \"0.57794327\",\n \"0.5768831\",\n \"0.5764876\",\n \"0.5739425\",\n \"0.5736447\",\n \"0.5722827\",\n \"0.5722336\",\n \"0.571985\",\n \"0.57188725\",\n \"0.57030225\",\n \"0.5689195\",\n \"0.56782526\",\n \"0.567312\",\n \"0.56712157\",\n \"0.5669115\",\n \"0.5666193\",\n \"0.56620395\",\n \"0.5649251\",\n \"0.5649157\",\n \"0.5642529\",\n \"0.56286824\",\n \"0.5628064\",\n \"0.56280607\",\n \"0.56215477\",\n \"0.56210285\",\n \"0.5617797\",\n \"0.5615381\",\n \"0.56097305\",\n \"0.5605717\",\n \"0.55988604\",\n \"0.5596003\",\n \"0.55914813\",\n \"0.55912113\",\n \"0.5591202\",\n \"0.5589017\",\n \"0.5589017\",\n \"0.55825967\",\n \"0.55780834\",\n \"0.5564855\",\n \"0.55445075\",\n \"0.5524806\",\n \"0.5513394\",\n \"0.5513314\",\n \"0.551095\",\n \"0.5499282\",\n \"0.5498775\",\n \"0.5490714\",\n \"0.5490131\",\n \"0.5485167\",\n \"0.5485167\",\n \"0.5485167\",\n \"0.5466163\",\n \"0.5464216\",\n \"0.54636955\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":25995,"cells":{"query":{"kind":"string","value":"Posts a twit on the moody_py account"},"document":{"kind":"string","value":"def tweet(self, twitter_post, instruction):\n if instruction is None:\n logging.error('Instruction parameter missing')\n return TwitterResponse(description='Instruction parameter missing')\n\n if instruction == Instruction.PROCESS_WEATHER_DATA:\n twit_content = \"{}, {} {} C {}\".format(twitter_post.post_text, twitter_post.condition, twitter_post.temperature,\n twitter_post.youtube_url)\n if instruction == Instruction.PROCESS_ARTIST:\n twit_content = \"Requested: {} {}\".format(twitter_post.post_text, twitter_post.youtube_url)\n\n if instruction == Instruction.PROCESS_INSTAGRAM_POST:\n twit_content = twitter_post.post_text\n\n if twitter_post.post_text is None or twitter_post.youtube_url is None:\n return TwitterResponse(description='Twitter post text or youtube_url not resolved!')\n try:\n status = self.api.PostUpdate(twit_content)\n logging.info('Posted twit with status: %s', status)\n return TwitterResponse(status)\n except TwitterError as e:\n logging.error('Error posting twit: %s', e.message[0]['message'])\n return TwitterResponse(description='Fatal error while posting tweet')"},"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 post_to_twitter(tweet):\n auth = tweepy.OAuthHandler(\n os.environ['BLADAMADUR_CONSUMER_KEY'],\n os.environ['BLADAMADUR_CONSUMER_SECRET'])\n auth.set_access_token(\n os.environ['BLADAMADUR_ACCESS_TOKEN'],\n os.environ['BLADAMADUR_ACCESS_TOKEN_SECRET'])\n api = tweepy.API(auth)\n\n api.update_status(tweet)","def post_to_twitter(sender, instance, **kwargs):\n\n if instance.pk: #only post the tweet if it's a new record. \n return False \n \n accounts = TwitterAccount.objects.all()\n \n for account in accounts:\n bittle = Bittle.objects.bitlify(instance.get_absolute_url())\n mesg = \"%s: %s\" % (\"New Blog Post\", bittle.shortUrl)\n username = account.username\n password = account.get_password()\n try:\n twitter_api = twitter.Api(username, password)\n twitter_api.PostUpdate(mesg)\n except urllib2.HttpError, ex:\n print str(ex)\n return False","def tweet(api, message):\n status = api.PostUpdate(message)","def post_tweet():\n if not request.get_json() or 'tweet' not in request.get_json():\n raise exceptions.HttpError(message=\"No tweet info in body\")\n\n post_tweet = Tweet(\n id=None,\n name=None,\n tweet=request.get_json()[\"tweet\"],\n created_at=None,\n type = 'original'\n )\n\n tweet = Storage.post_tweet(tweet=post_tweet)\n return jsonify(tweet.to_dict()), 201","def send_tweet(media_id, quote, movie_name):\n\n tweet = '{} - {}'.format(quote, movie_name)\n request_data = {\n 'status': tweet,\n 'media_ids': media_id\n }\n\n requests.post(url=constants.POST_TWEET_URL, data=request_data, auth=oauth)","def post_tweet(self, message):\n twitter = TwitterAPI(\n # os.environ[\"consumerKey\"],\n # os.environ[\"consumerSecret\"],\n # os.environ[\"accessToken\"],\n # os.environ[\"accessTokenSecret\"],\n self.twitter_creds[\"consumerKey\"],\n self.twitter_creds[\"consumerSecret\"],\n self.twitter_creds[\"accessToken\"],\n self.twitter_creds[\"accessTokenSecret\"],\n )\n\n request = twitter.request(\"statuses/update\", {\"status\": message})\n\n status_code = request.status_code\n if status_code == 200:\n rootLogger.info(\"Successfully tweeted: {}\".format(message))\n else:\n rootLogger.error(\"HTTP status code: {} -- unsuccessfully tweeted: {}\".format(status_code, message))","def tweet(self, message: str) -> None:\n\n # YOUR CODE HERE\n tweet = Tweet(self.userid, date.today(), message)\n self.tweets.append(tweet)","async def tweet():\n with logger.contextualize(request_id=str(uuid.uuid4())):\n tweets = generate()\n upload(tweets)","def post_to_tweets(data, url):\n\n print(\"here,\", url)\n\n albums = find_all_images(data['content'])\n text = strip_text(data['content'])\n\n \"\"\"Where applicable, the images are associated with the text. This means, that to make an appropriate thread the\n conversion from a post to tweets should take into account how words relate to images in a spacial way. For this\n reason, we convert to tweets in batches.\"\"\"\n\n cfg = get_keys() # grab keys\n api = get_api(cfg) # setup API\n in_reply_to = None\n twitter_url = 'https://twitter.com'\n\n # for idx, caption in enumerate(text):\n # if idx > 0:\n # url_img = None\n # caption = re.findall(r\"[\\w']+|[.!?;]\\ \", caption)\n # text[idx] = text_to_tweets(caption, url_img)\n\n try:\n if data['in_reply_to'] is not None: # if post is reply ...\n for reply in data['in_reply_to']:\n if reply[:len(twitter_url)] == twitter_url: # if the URL points to twitter ...\n in_reply_to = reply.split('/')[-1:] # ... get the status id\n except KeyError:\n pass\n\n url = 'https://' + DOMAIN_NAME + url\n\n tweets = text_to_tweets(text, url=url) # process string into tweet thread\n\n # try and parse a lat lng.\n try:\n lat, lng = data['geo'][4:].split(\",\")\n except KeyError:\n lat, lng = None, None\n\n # post the first tweet so that we have a status id to start the thread\n status = api.update_status(status=tweets[0].pop(0), in_reply_to_status_id=in_reply_to)\n first_id = status.id # the id which points to origin of thread\n\n for album_group in text:\n try:\n media = album_group.pop(0) # get the corresponding album\n for tweet in album_group:\n status = api.update_with_media(filename=media, status=tweet, in_reply_to_status_id=status.id, lat=lat, long=lng)\n media = None\n except IndexError: # if we're out of albums...\n pass\n return 'http://twitter.com/{name}/status/{id}'.format(name=status.user.screen_name, id=first_id, lat=lat, lng=lng)","def post_to_twitter(sender, instance, *args, **kwargs):\n\n # avoid to post the same object twice\n if not kwargs.get('created'):\n return False\n\n # check if there's a twitter account configured\n import tweepy\n try:\n consumer_key = os.environ.get('TWITTER_CONSUMER_KEY')\n consumer_secret = os.environ.get('TWITTER_CONSUMER_SECRET')\n access_key = os.environ.get('TWITTER_ACCESS_KEY')\n access_secret = os.environ.get('TWITTER_ACCESS_SECRET')\n except AttributeError:\n print 'WARNING: Twitter account not configured.'\n return False\n\n # create the twitter message\n try:\n text = instance.get_twitter_message()\n except AttributeError:\n text = unicode(instance)\n\n mesg = u'%s' % (text)\n if len(mesg) > TWITTER_MAXLENGTH:\n size = len(mesg + '...') - TWITTER_MAXLENGTH\n mesg = u'%s...' % (text[:-size])\n\n try:\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_key, access_secret)\n api = tweepy.API(auth)\n api.update_status(mesg)\n except urllib2.HTTPError, ex:\n print 'ERROR:', str(ex)\n return False","def send_tweet(data):\n # Fill in the values noted in previous step here\n cfg = get_keys() # grab keys\n api = get_api(cfg) # setup API\n in_reply_to = None\n twitter_url = 'https://twitter.com'\n if data['in_reply_to'] is not None: # if post is reply ...\n for reply in data['in_reply_to']:\n if reply[:len(twitter_url)] == twitter_url: # if the URL points to twitter ...\n in_reply_to = reply.split('/')[-1:] # ... get the status id\n url = 'https://' + DOMAIN_NAME + data['url']\n tweets = post_to_tweets(data=data['content'], url=url) # process string into tweet thread\n # post the first tweet so that we have a status id to start the thread\n status = api.update_status(status=tweets.pop(0), in_reply_to_status_id=in_reply_to)\n first_id = status.id # the id which points to origin of thread\n try:\n lat,lng = data['geo'][4:].split(\",\")\n except KeyError:\n lat, lng = None, None\n for tweet in tweets:\n status = api.update_status(status=tweet, in_reply_to_status_id=status.id)\n return 'http://twitter.com/{name}/status/{id}'.format(name=status.user.screen_name, id=first_id, lat=lat, lng=lng)","def command_tweet(self, bot, update):\n\n bot.sendChatAction(update.message.chat_id, action='typing')\n\n tweet = ext.get_last_tweet(self.config['twitter'])\n\n for url in tweet.get('images', []):\n self.send_photo_url(bot, update, url)\n\n messages = [\n u'{text}',\n '[@{user[screen_name]}](https://twitter.com/{user[screen_name]}) '\n '- {ago}'\n ]\n\n for msg in messages:\n self.send_message(bot, update, msg.format(**tweet))","def tweet(self, message):\n if self.api_key == \"\":\n return False\n ts = TagStripper()\n ts.feed(message)\n params = urllib.urlencode(\n {'api_key': self.api_key,\n 'status': ts.get_collected_data()})\n\n headers = {\"Content-type\": \"application/x-www-form-urlencoded\",\n \"Accept\": \"text/plain\"}\n\n conn = httplib.HTTPConnection(\"api.thingspeak.com:80\")\n\n try:\n conn.request(\"POST\",\n \"/apps/thingtweet/1/statuses/update\",\n params,\n headers)\n\n response = conn.getresponse()\n data = response.read()\n conn.close()\n return True, ts.get_collected_data()\n except httplib.HTTPException as http_exception:\n return False, http_exception.message","def tweet(user):\n api = get_api(user)\n msg = 'I used hackt to follow @hackerschool batches on twitter. You can too at http://bit.ly/hs_hackt'\n\n try:\n api.PostUpdate(msg)\n except twitter.TwitterError as error:\n return {'msg': error.message[0]['message']}","def postTweet(self, userId: int, tweetId: int) -> None:\n ts = time.time()\n self.posts[userId].append((ts, tweetId))","def tweet(api):\n logger.info(\"Tweeting content\")\n urls = get_article('the_onion.txt')\n lines = content_list(urls)\n\n for line in lines:\n try:\n api.update_status(line)\n logger.info(\"Tweeting!\")\n time.sleep(SECONDS)\n\n except tweepy.TweepError as err:\n logger.error(err)","def postTweet(self, userId: int, tweetId: int) -> None:\n self.cnt += 1\n self.posts[userId].append((self.cnt, tweetId))","def tweet(message):\n auth = load_twitter_auth()\n key = environ['TWITTER_ACCESS_KEY']\n secret = environ['TWITTER_ACCESS_SECRET']\n auth.set_access_token(key, secret)\n api = tweepy.API(auth)\n api.update_status(message)\n print(message)","def send_tweet(tweet_text):\n twitter.update_status(status = tweet_text)","def send_tweet(tweet_text):\n twitter.update_status(status=tweet_text)","def send_tweet(tweet_text):\n twitter.update_status(status=tweet_text)","def send_tweet(tweet_text):\n twitter.update_status(status=tweet_text)","def postTweet(self, userId: int, tweetId: int) -> None:\n self.users.add(userId)\n self.user_post[userId].append((tweetId, self.time))\n self.time += 1","def handler(event,context):\n tweet = setup_and_get_tweet()\n send_tweet(tweet)","def answer_to_tweets(api, tweets):\n\n try:\n last_tweet_id = 0\n for tweet in tweets:\n print(\"Sending an answer to tweet {}: '{}'\".format(tweet[\"id\"],\n tweet[\"text\"]))\n api.statuses.update(status=TARGET_TWEET_ANSWER,\n in_reply_to_status_id=tweet[\"id\"])\n last_tweet_id = tweet[\"id\"]\n time.sleep(1) # do not exceed Twitter limits\n finally:\n update_last_tweet_id(last_tweet_id)","def post_tweet(instance, created, raw, **kwargs):\n if created and not raw:\n _twitter.statuses.update(status='%s %s' % (\n instance.title,\n instance.url,\n ))","def post(self, request):\n if request.user.is_authenticated:\n if not request.user.consumer_key and not request.user.consumer_secret and not request.user.oauth_token and \\\n not request.user.oauth_token_secret:\n return Response({\"message\": \"Kindly supply the twitter authentication keys in the admin dashboard\"},\n status=status.HTTP_400_BAD_REQUEST)\n else:\n tweets = request.data.get('tweets', None)\n if tweets is not None:\n api = load_api(request)\n try:\n api.update_status(tweets)\n except tweepy.TweepError as e:\n return Response({\"message\": e.args[0][0]['message']}, status=status.HTTP_400_BAD_REQUEST)\n return Response({\"message\": \"Your tweets has been updated\"}, status=status.HTTP_201_CREATED)","def postTweet(self, userId: int, tweetId: int) -> None:\n if userId not in self.users.keys():\n self.users[userId] = user()\n self.users[userId].tweets.append(tweetId)\n self.tweetTime[tweetId] = self.time\n self.time += 1","def post_to_twitter(content) -> None:\n logging.error(f'No function registered to handle posting type: {type(content)} to twitter')\n pass","def add_tweet():\n if not request.json or 'author_id' not in request.json or 'text' not in request.json:\n abort(400)\n\n db = get_db()\n\n author_id = request.json.get('author_id')\n text = request.json.get('text')\n pub_date = int(time.time())\n\n db.execute('''insert into message (author_id, text, pub_date) values (?, ?, ?)''', (author_id, text, pub_date))\n db.commit()\n flash('Message recorded succesfully')\n message = {\"author_id\": author_id, \"text\": text, \"pub_date\": pub_date}\n return jsonify({'message': message}), 201","def postTweet(self, userId, tweetId):\r\n self.timestamp += 1\r\n self.tweets_by_user[userId].append((self.timestamp, tweetId))","def publish_tweet(self, tweet):\n\n self.api.update_status(tweet)","def tweet(self):\n self.__refresh_local_tweets()\n\n if not self.tweets:\n return\n\n tweet_obj = self.tweets[0]\n\n # upload picture\n media_id = self.__upload_media(tweet_obj[\"img\"])\n\n # tweet with text, and image\n if not media_id:\n return\n self.__post_status(tweet_obj[\"text\"], media_id)\n\n self.tweets.remove(tweet_obj)\n self.tweeted.append(tweet_obj)\n self.__update_local_tweets()","def write_post(id, args):\n graph = facebook.GraphAPI(id) \n graph.put_object(parent_object='me', connection_name = 'feed', **args)","async def add_tweet(self, tid=None): \n try:\n data=json.loads(self.request.body.decode('utf-8'))\n except: \n print(\"No data body!\")\n\n #print(\"Coordinates: {}\".format(data[\"coordinates\"]))\n if \"place\" in data:\n print(\"Place: {}\".format(data[\"place\"]))\n\n #print(\"User location: {}\".format(data[\"user\"][\"location\"]))\n #print(\"User lang: {}\".format(data[\"user\"][\"lang\"]))\n t=Tweet()\n t.tweet_id = tid\n t = self.fill_tweet(t, data)\n tweet_cache.append(t.to_dict())\n if \"retweeted_status\" in data:\n t.retweeted_status=data[\"retweeted_status\"]\n # \n # save the tweet\n #\n t.upsert()\n #\n # now handle the retweet\n #\n if \"retweeted_status\" in data:\n # this is a retweet so\n # do it once more for the original tweet\n tr=Tweet()\n tr.tweet_id = data[\"retweeted_status\"][\"id_str\"]\n tr = self.fill_tweet(tr, data[\"retweeted_status\"])\n tweet_cache.append(tr.to_dict())\n #tr.upsert()\n #r=requests.get(\"https://publish.twitter.com/oembed?url=https://twitter.com/Interior/status/\"+ t.tweet_id )\n #await self.fire_callbacks(r.json())\n #print(t.to_json(),file=ofile)\n #\n # get the embed html from twitter oembed API\n #\n r=requests.get(\"https://publish.twitter.com/oembed?url=https://twitter.com/Interior/status/\"+ t.tweet_id )\n #print(r.json())\n \n #print(self.__class__.callbacks)\n await self.fire_callbacks(r.json())\n #self.success(message=\"Added tweet id: {} \".format(str(id)), data=t.to_json(), format=\"json\", pure=True)","def postTweet(self, userId: int, tweetId: int) -> None:\n if userId not in self.users:\n self._create_user(userId)\n self.users_tweet[userId].appendleft((self.uid, tweetId))\n self.uid += 1","def post_to_twitter(worker_responses):\n for worker_response in worker_responses:\n print get_tweet_text(worker_response)","def tweet(chains):\n\n # Use Python os.environ to get at environmental variables\n # Note: you must run `source secrets.sh` before running this file\n # to make sure these environmental variables are set.\n\n api = twitter.Api(\n consumer_key=os.environ['TWITTER_CONSUMER_KEY'],\n consumer_secret=os.environ['TWITTER_CONSUMER_SECRET'],\n access_token_key=os.environ['TWITTER_ACCESS_TOKEN_KEY'],\n access_token_secret=os.environ['TWITTER_ACCESS_TOKEN_SECRET'])\n\n # print api.VerifyCredentials()\n\n user_choice = None\n while not (user_choice == 'q' or user_choice == 'Q'):\n status = api.PostUpdate(make_text(chains))\n #status = api.PostUpdate(\"Something random\")\n\n print status.text\n user_choice = raw_input(\"Enter to tweet again [q to quit] > \")","def postTweet(self, userId, tweetId):\n if not self.user_pool[userId].user_id:\n user = UserInfo()\n user.user_id = userId\n self.user_pool[userId] = user\n self.time += 1\n tw_info = (tweetId, self.time) # 保存一个和时间戳\n self.twitter_pool[userId].append(tw_info)","async def tweet_menu(self, ctx, post_list: list,\n message: discord.Message=None,\n page=0, timeout: int=30):\n s = post_list[page]\n colour =\\\n ''.join([randchoice('0123456789ABCDEF')\n for x in range(6)])\n colour = int(colour, 16)\n created_at = s.created_at\n created_at = created_at.strftime(\"%Y-%m-%d %H:%M:%S\")\n post_url =\\\n \"https://twitter.com/{}/status/{}\".format(s.user.screen_name, s.id)\n desc = \"Created at: {}\".format(created_at)\n em = discord.Embed(title=\"Tweet by {}\".format(s.user.name),\n colour=discord.Colour(value=colour),\n url=post_url,\n description=desc)\n em.add_field(name=\"Text\", value=s.text)\n em.add_field(name=\"Retweet count\", value=str(s.retweet_count))\n if hasattr(s, \"extended_entities\"):\n em.set_image(url=s.extended_entities[\"media\"][0][\"media_url\"] + \":thumb\")\n if not message:\n message =\\\n await self.bot.send_message(ctx.message.channel, embed=em)\n await self.bot.add_reaction(message, \"⬅\")\n await self.bot.add_reaction(message, \"❌\")\n await self.bot.add_reaction(message, \"➡\")\n else:\n message = await self.bot.edit_message(message, embed=em)\n react = await self.bot.wait_for_reaction(\n message=message, user=ctx.message.author, timeout=timeout,\n emoji=[\"➡\", \"⬅\", \"❌\"]\n )\n if react is None:\n await self.bot.remove_reaction(message, \"⬅\", self.bot.user)\n await self.bot.remove_reaction(message, \"❌\", self.bot.user)\n await self.bot.remove_reaction(message, \"➡\", self.bot.user)\n return None\n reacts = {v: k for k, v in numbs.items()}\n react = reacts[react.reaction.emoji]\n if react == \"next\":\n next_page = 0\n if page == len(post_list) - 1:\n next_page = 0 # Loop around to the first item\n else:\n next_page = page + 1\n return await self.tweet_menu(ctx, post_list, message=message,\n page=next_page, timeout=timeout)\n elif react == \"back\":\n next_page = 0\n if page == 0:\n next_page = len(post_list) - 1 # Loop around to the last item\n else:\n next_page = page - 1\n return await self.tweet_menu(ctx, post_list, message=message,\n page=next_page, timeout=timeout)\n else:\n return await\\\n self.bot.delete_message(message)","def tweet(text):\n # Twitter authentication\n auth = tweepy.OAuthHandler(C_KEY, C_SECRET)\n auth.set_access_token(A_TOKEN, A_TOKEN_SECRET)\n api = tweepy.API(auth)\n\n # Send the tweet and log success or failure\n try:\n api.update_status(text)\n except tweepy.error.TweepError as e:\n log(e.message)\n print(e.message)\n else:\n log(\"Tweeted: \" + text)\n print(\"Tweeted: \" + text)","def add_tweet():\r\n tweet = models.Tweet(text_content=request.json['content'], username=request.json['username'],\r\n timestamp=datetime.datetime.now())\r\n db.session.add(tweet)\r\n db.session.commit()\r\n\r\n return {'id': tweet.id}","async def make_tweet(tweet: str = Query(...),\n # attachment_url: Optional[str] = Query(None, alias=\"link of tweet to quote\", regex=\"https://twitter.com/([\\w_]+)/status/([\\d]+)\"),\n # in_reply_to: Optional[int] = Query(None, alias=\"link of tweet to reply to\", regex=\"https://twitter.com/([\\w_]+)/status/([\\d]+)\"), \n user: User = Depends(get_current_user),\n session: Session = Depends(get_db)\n )-> TweetSchema:\n if not user.active:\n raise HTTPException(401, detail=\"Your account seems to be inactive, please login with twitter to make tweets\")\n # if in_reply_to:\n # regex = re.match(\"https://twitter.com/(?P<username>[\\w]+)/status/(?P<id>[\\d]+)\", in_reply_to)\n # status_id = regex.group(\"id\")\n url = \"https://api.twitter.com/1.1/statuses/update.json\"\n params = dict(status=tweet,\n # attachment_url=attachment_url,\n # in_reply_to_status_id=status_id,\n )\n auth = user.get_oauth1_token()\n\n r = requests.post(url, params=params, auth=auth)\n if not r.ok:\n raise HTTPException(400, detail={\"message\":\"Something went wrong with Twitter, please try again or contact me @redDevv\",\n \"error from twitter\": r.text})\n tweet = r.json()\n\n new_tweet = Tweet(**tweet)\n user.tweets.append(new_tweet)\n user.requests_made += 1\n\n session.commit()\n return tweet","def tweet(text):\n # Twitter authentication\n auth = tweepy.OAuthHandler(C_KEY, C_SECRET)\n auth.set_access_token(A_TOKEN, A_TOKEN_SECRET)\n api = tweepy.API(auth)\n\n # Send the tweet and log success or failure\n try:\n api.update_status(text)\n except tweepy.error.TweepError as e:\n log(e.message)\n else:\n log(\"Tweeted: \" + text)","def post(self, request, *args, **kwargs):\n form = self.form_class(data=request.POST, user=request.user)\n\n if form.is_valid():\n instance = form.save()\n\n # Deal with posting twitter status\n posted_status = False\n if instance.category != get_default_category():\n # Create tweeted message and post status\n tweeted_message = \"RT:<%s>%s#Custom#%s\" % (instance.created_by.username, instance.message, instance.category)\n api = twitter.Api(consumer_key=settings.TWITTER_CONSUMER_KEY, consumer_secret=settings.TWITTER_CONSUMER_SECRET,\n access_token_key=settings.TWITTER_USER_OAUTH_TOKEN, access_token_secret=settings.TWITTER_USER_OAUTH_TOKEN_SECRET)\n api.PostUpdate(status=tweeted_message)\n\n # Save time published and update postedStatus\n instance.published_on = timezone.now()\n instance.save()\n posteds_status = True\n\n return render(request, 'tweets/index.html', {'form': self.form_class(user=request.user), 'success': True, 'posted_status': posted_status})\n return render(request, 'tweets/index.html', {'form': form})","def postTweet(self, userId: int, tweetId: int) -> None:\n self.tweets[userId].appendleft((next(self.timer), tweetId))","def send_tweet(tweet_text, uuid):\n try:\n query = {} # API call to twitter-service\n query['app_name'] = 'webcamd'\n query['uuid'] = uuid\n query['tweet_text'] = tweet_text\n query['hashtag_arg'] = 'metminiwx' # do not supply the #\n query['lat'] = 51.4151 # FIXME - put in definitions.py Stockcross\n query['lon'] = -1.3776 # Stockcross\n\n status_code, response_dict = cumulus_comms.call_rest_api(get_env.get_twitter_service_endpoint() + '/send_text', query)\n\n if response_dict['status'] == 'OK' :\n tweet_len = response_dict['tweet_len'].__str__()\n print('Tweet sent OK, tweet_len=' + tweet_len + ', uuid=' + uuid.__str__())\n else:\n print(response_dict['status'])\n\n except Exception as e:\n print('Error : send_tweet() : ' + e.__str__())","def sending_process(self, quote, movie_poster_url, movie_name):\n file_name, file_type = download_poster(movie_poster_url)\n media_upload = async_upload.VideoTweet(file_name, oauth)\n media_id = media_upload.upload_init(file_type)\n media_upload.upload_append()\n try:\n media_upload.upload_finalize()\n except Exception as e:\n print('Media Upload Error', str(e))\n return self.run()\n\n send_tweet(media_id, quote, movie_name)","def postTweet(self, userId, tweetId):\n self.time += 1\n self.tweets[userId] = self.tweets.get(userId, []) + [(-self.time, tweetId)]","def tweet_user(self, target, msg=None):\n self.log.debug(\"Tweeting %s\" % target.hunted.screen_name)\n tweet = \"@%s: %s\" % (target.hunted.screen_name,\n random.sample(self.tweets, 1)[0])\n tweet = tweet [:140]\n self.api.update_status(tweet)\n target.status = Target.FOLLOWER\n target.save()","def reply_to_tweets():\n last_seen_id = retrieve_last_seen_id(FILE_NAME)\n mentions = api.mentions_timeline(\n last_seen_id,\n tweet_mode='extended')\n\n for mention in reversed(mentions):\n print(str(mention.id) + ' - ' + mention.full_text, flush=True)\n last_seen_id = mention.id\n store_last_seen_id(last_seen_id, FILE_NAME)\n for i in range(len(keywords)):\n if keywords[i] in mention.full_text.lower():\n print(\"responding back to: \" + '@' +\n mention.user.screen_name, flush=True)\n api.update_status('@' + mention.user.screen_name + ' ' +\n salts[i], mention.id)","async def tweet_feeder(self): \n try:\n data=json.loads(self.request.body.decode('utf-8'))\n except: \n print(\"No data body!\")\n\n t=Tweet()\n t.tweet_id = data[\"tweet_id\"]\n t.text=data[\"text\"]\n #\n # update the hashtags cache\n #\n try:\n t.hashtags=data[\"hashtags\"] \n for htag in t.hashtags:\n #print(\"adding to hashtags: {} to cache:\".format(htag[\"text\"], ))\n if htag[\"text\"] in hash_cache:\n hash_cache[htag[\"text\"]] += 1\n else:\n hash_cache[htag[\"text\"]] = 1\n except:\n t.hashtags=[]\n \n #\n # update the user cache\n #\n try:\n user_id = \"@\" + data[\"user_screenname\"]\n if user_id in user_cache:\n user_cache[user_id] += 1\n else:\n user_cache[user_id] = 1\n except:\n print(\" ERR No User: should never happen\")\n\n try:\n t.user_screenname=data[\"user_screenname\"]\n except:\n t.user_screenname=\"\"\n try:\n t.profile_image_url_https = data[\"profile_image_url_https\"]\n except:\n t.profile_image_url_https = \"\"\n #\n # update the tweets cache\n #\n try:\n t.timestamp = data[\"timestamp\"]\n except:\n t.timestamp = datetime.datetime.utcnow()\n tweet_cache.append(t.to_dict())\n \n #\n # get the embed html from twitter oembed API\n #\n r=requests.get(\"https://publish.twitter.com/oembed?url=https://twitter.com/Interior/status/\"+ t.tweet_id )\n #print(r.json())\n \n #print(self.__class__.callbacks)\n await self.fire_callbacks(r.json())\n #self.success(message=\"Added tweet id: {} \".format(str(id)), data=t.to_json(), format=\"json\", pure=True)","def reply_to_tweet():\n\n print('retrieving and replying to tweets...')\n all_mentions = api.mentions_timeline()\n\n # The content of the reply that the bot will send.\n rap_message = ' yo yo yo yo'\n\n for mention in reversed(all_mentions):\n\n # print(str(mention.id) + '-' + mention.text)\n\n if 'rap for me' in mention.text.lower():\n # checks if the bot received a request to deliver a rap\n print('received a request')\n print('dropping a new single...')\n # Checks if the latest mention came from the same person.\n if mention.id == mention.id[0]:\n # Posts a tweet saying the bot is 'too tired' and won't generate a new rap.\n api.update_status('@' + mention.user.screen_name + ' yo sorry I am too tired right now')\n else:\n # Posts a tweet with the rap to the user.\n api.update_status('@' + mention.user.screen_name + rap_message, mention.id)\n print('single dropped.')","def tweet(chopped_string):\n\n status = api.PostUpdate(chopped_string)\n print status.text","def send_tweet(in_list):\n\n with open('credentials.json') as json_file:\n creds = json.load(json_file)\n\n twit_creds = creds['twitter']\n consumer_key = twit_creds['consumer_key']\n consumer_secret = twit_creds['consumer_secret']\n access_token = twit_creds['access_token']\n access_token_secret = twit_creds['access_token_secret']\n\n for dev in in_list:\n to_tweet = f\"New #Aberdeen AQ device found. ID = {dev}. See it on a map: http://uk.maps.luftdaten.info/#9/57.3406/-1.9226 \"\n # tweet the message\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, access_token_secret)\n tweepyapi = tweepy.API(auth)\n tweepyapi.update_status(to_tweet)\n # print(\"Tweeted\")","def like_tweet(tweet_id):\n twitter.create_favorite(id=tweet_id)","def postTweet(self, userId: 'int', tweetId: 'int') -> 'None':\n self.tweets[userId].appendleft((next(self.timer), tweetId))","def on_tweet(self, tweet):\n pass","def bridgy_twitter(location):\n r = send_mention(\n 'http://' + DOMAIN_NAME +'/e/' + location,\n 'https://brid.gy/publish/twitter',\n endpoint='https://brid.gy/publish/webmention'\n )\n location = 'http://' + DOMAIN_NAME +'/e/' + location\n syndication = r.json()\n app.logger.info(syndication)\n data = get_bare_file('data/' + location.split('/e/')[1]+\".md\")\n if data['syndication'] == 'None':\n data['syndication'] = syndication['url']+\",\"\n else:\n data['syndication'] += syndication['url']+\",\"\n entry_re_write(data)","def postTweet(self, userId, tweetId):\n if userId in self.tweets:\n self.tweets[userId].append([-self.time, tweetId])\n else:\n self.tweets[userId] = [[-self.time, tweetId]]\n self.time += 1","def IceT(sc, event):\n request = urllib2.Request(\n 'http://icetsvu.tumblr.com/random')\n result = urllib2.urlopen(request)\n sc.api_call('chat.postMessage', as_user='true',\n channel=event['channel'], text=result.geturl())","def twitter(self):\n message = \"\"\n count = self.collection.count()\n\n twitter = Twitter(auth = OAuth(self.access_key, self.access_secret, self.consumer_key, self.consumer_secret))\n for keyword in self.twitter_keywords:\n query = twitter.search.tweets(q = keyword)\n for result in query['statuses']:\n try:\n data = {\"id\": count+1, \"source\": \"twitter\", \"timestamp\": datetime.now()}\n data['tweet'] = result['text']\n data['name'] = result[\"user\"][\"screen_name\"]\n data['url'] = \"https://twitter.com/\" + data[\"name\"] + \"/status/\" + str(result['id'])\n data['search_string'] = keyword\n try:\n dataid = self.collection.insert(data)\n except DuplicateKeyError as e:\n continue\n count += 1\n\n # Slack push notification\n length = 82 - len(data['url'])\n message += \"\\nURL: \" + data['url'] + \" search string: \".rjust(length) + keyword\n\n except Exception as e:\n print(e)\n pass\n \n if message:\n print(self.G + \"[+] Twitter\" + self.B + message)\n self.message += \"\\n*Twitter*:\\n```\"\n self.message += message\n self.message += \"\\n```\"\n\n return","async def batphone(self, ctx, *, message: add_est_timestamp = None):\n\n if not message:\n return ctx.send(f\"\"\"{ctx.author.mention} I'm already doing 90% of the work. \n Do you want me to come up with the message too?\"\"\")\n\n status = twitterapi.post_tweet(message)\n\n embed = discord.Embed(title='Batphone',\n url=f'https://twitter.com/AmtrakEq/status/{status.id}',\n description=message,\n colour=discord.Colour.red())\n embed.set_image(url=gifs.get_one_gif(\"thomas the train\"))\n embed.set_author(name=ctx.author.display_name, icon_url=ctx.author.avatar_url)\n\n await ctx.bot.batphone_channel.send(f'@everyone {status.text}', embed=embed)\n await ctx.message.delete()","def _upload_to_twitter(self):\n if self._twitter:\n strip_file = self.create_strip(resolution_ratio=0.5)\n f = open(strip_file)\n self._twitter.request('statuses/update_with_media', {'status': self._twitter_text}, {'media[]': f.read()})\n f.close()\n os.remove(strip_file)","async def reply_tweet(reply: str,\n in_reply_to: str = Query(None, alias=\"link of tweet\", regex=\"https://twitter.com/([\\w_]+)/status/([\\d]+)\"),\n status_id: int = Query(None, alias=\"id of tweet\"),\n user: User = Depends(get_current_user),\n session: Session = Depends(get_db)\n )-> TweetSchema:\n if not user.active:\n raise HTTPException(401, detail=\"Your account seems to be inactive, please login with twitter to make tweets\")\n if not (in_reply_to or status_id):\n raise HTTPException(400, detail=\"Please enter either a Tweet ID or link to reply to\")\n\n if in_reply_to:\n regex = re.match(\"https://twitter.com/(?P<username>[\\w]+)/status/(?P<id>[\\d]+)\", in_reply_to)\n status_id = regex.group(\"id\")\n\n url = \"https://api.twitter.com/1.1/statuses/update.json\"\n params = dict(status=reply,\n in_reply_to_status_id=status_id,\n auto_populate_reply_metadata=True\n )\n auth = user.get_oauth1_token()\n\n r = requests.post(url, params=params, auth=auth)\n if not r.ok:\n raise HTTPException(400, detail={\"message\":\"Something went wrong with Twitter, please try again or contact me @redDevv\",\n \"error from twitter\": r.text})\n tweet = r.json()\n\n new_tweet = Tweet(**tweet)\n user.tweets.append(new_tweet)\n user.requests_made += 1\n\n session.commit()\n return tweet","def send_tweet(auth, tweet, in_reply_to=None):\n\tif isinstance(tweet, list):\n\t\t# It's a thread of tweets\n\t\tprev = ret = None\n\t\tfor part in tweet:\n\t\t\tif not part: continue\n\t\t\tinfo = send_tweet(auth, part, in_reply_to=prev)\n\t\t\tif \"error\" in info: return info\n\t\t\tif not ret: ret = info # Return the info for the *first* tweet sent\n\t\t\tprev = info[\"tweet_id\"]\n\t\treturn ret or {\"error\": \"Can't send a thread of nothing but empty tweets\"}\n\ttwitter = OAuth1Session(config.TWITTER_CLIENT_ID, config.TWITTER_CLIENT_SECRET, auth[0], auth[1])\n\tresp = twitter.post(\"https://api.twitter.com/1.1/statuses/update.json\",\n\t\tdata={\"status\": tweet, \"in_reply_to_status_id\": in_reply_to})\n\tif resp.status_code != 200:\n\t\tprint(\"Unknown response from Twitter\")\n\t\tprint(resp.status_code)\n\t\tprint(\"---\")\n\t\tprint(resp.json())\n\t\tprint(\"---\")\n\t\ttry:\n\t\t\t# TODO: Report these to the front end somehow even if asynchronous\n\t\t\treturn {\"error\": \"Unable to send tweet: \" + resp.json()[\"errors\"][0][\"message\"]}\n\t\texcept LookupError:\n\t\t\treturn {\"error\": \"Unknown error response from Twitter (see server console)\"}\n\tr = resp.json()\n\turl = \"https://twitter.com/%s/status/%s\" % (r[\"user\"][\"screen_name\"], r[\"id_str\"])\n\treturn {\"screen_name\": r[\"user\"][\"screen_name\"], \"tweet_id\": r[\"id\"], \"url\": url}","def RT(ID, name):\r\n \"\"\"Takes a ID and username parameter\"\"\"\r\n \"\"\"Once tweeted log is updated in overall and to date tweetlog\"\"\"\r\n \r\n config = config_create()\r\n print(\"RT\")\r\n #Tid = int(float(ID))\r\n Tweetusername = config.get('Auth', 'botname')\r\n #TweetText = 'https://twitter.com/'+Tweetusername+'/status/'+ID\r\n #ReTweet = 'Hi I am ComicTweetBot!('+tim+') I Retweet Comics! Use #comicretweetbot '+TweetText\r\n x2 = config.get('Latest_Log', 'currenttweetlog')\r\n x3 = config.get('Latest_Log', 'overalllog')\r\n CONSUMER_KEY = config.get('Auth', 'CONSUMER_KEY') \r\n CONSUMER_SECRET = config.get('Auth', 'CONSUMER_SECRET')\r\n ACCESS_KEY = config.get('Auth', 'ACCESS_KEY')\r\n ACCESS_SECRET = config.get('Auth', 'ACCESS_SECRET')\r\n api = Twython(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_KEY, ACCESS_SECRET)\r\n tMax = int(float(config.get('Tweet_Delay', 'Max')))\r\n tMin = int(float(config.get('Tweet_Delay', 'Min')))\r\n tStep = int(float(config.get('Tweet_Delay', 'Step')))\r\n Log = open(x2, 'w')\r\n enterlog = ID+' '+name+ '\\n'\r\n Log.write(enterlog)\r\n Log2 = open(x3, 'w')\r\n Log2.write(ID+'\\n')\r\n #api.update_status(status= ReTweet)\r\n api.retweet(id = ID)\r\n api.create_favorite(id=ID, include_entities = True)\r\n #randomize the time for sleep 1.5mins to 5 mins\r\n rant = random.randrange(tMin, tMax, tStep)\r\n time.sleep(rant)","def pushTwitterUsers(twits):\n rightNow = datetime.now().isoformat()\n for twit in twits:\n twit['last_scraped'] = rightNow\n \n renderedTwits = [ renderTwitterUser(twit) for twit in twits ]\n pushRenderedTwits2Neo.delay(renderedTwits)\n pushRenderedTwits2Cass.delay(renderedTwits)\n #return True","def postTweet(self, userId: int, tweetId: int) -> None:\n # Time Complexity: O(1)\n if userId not in self.tweets:\n self.tweets[userId] = []\n\n self.tweets[userId].append((-self.timestamp, tweetId))\n self.timestamp += 1","def TweetHandler(self):\n self.response.out.write('<br/><br/>Tweeting<br/>')\n self.response.out.write('this info will be tweeted:<br/>')\n # oldest non-tweeted and prepared\n oldest_changeset = Changeset.all().order('created_at').filter('is_tweeted =', False).filter('is_prepared =', True).fetch(1)\n if not oldest_changeset:\n self.response.out.write('nothing to tweet')\n return\n else:\n c = oldest_changeset[0]\n \n config = get_config()\n\n # do not tweet from localhost\n if not 'localhost' in self.request.url:\n auth = tweepy.OAuthHandler(config[\"consumer_key\"], config[\"consumer_secret\"])\n auth_data = OAuthAccessToken.all().filter('specifier =', config[\"twitter_username\"]).fetch(1)[0]\n auth.set_access_token(auth_data.oauth_token, auth_data.oauth_token_secret)\n self.response.out.write('<br/>tweeting with oauth:<br/>')\n api = tweepy.API(auth)\n self.response.out.write(\"id: %d\" % c.id)\n self.response.out.write(\"user: %s\" % c.user)\n self.response.out.write(\"comment: %s\" % c.comment)\n self.response.out.write(\"tweet: %s\" % c.tweet)\n try:\n api.update_status(c.tweet)\n except tweepy.error.TweepError, e: \n self.response.out.write( 'failed: %s' % e.reason )\n if \"Status is a duplicate\" in e.reason:\n c.is_tweeted = True\n c.put()\n return\n else:\n self.response.out.write('<br/>localhost - nothing actually tweeted:')\n\n self.response.out.write('<br/>%s' % c.tweet)\n\n c.is_tweeted = True\n c.put()","def send_tweet(self):\n \n ## Check the quality/score\n quality = self.sunsetwx_response['features'][0]['properties']['quality']\n score = self.sunsetwx_response['features'][0]['properties']['quality_percent']\n \n ## For great ones... compose a status\n if quality == 'Great':\n \n local_time_str = self.time_converted.strftime(\"%I:%M %p\")\n if self.type == 'sunrise':\n time_of_day_str = 'tomorrow morning'\n elif self.type == 'sunset':\n time_of_day_str = 'this evening'\n status = f'Looks like there will be a great {self.type} in {self.location} {time_of_day_str}! Check it out at {local_time_str}.'\n \n ## Post about the great ones\n api.update_status(status=status)\n \n ## Update the log regardless\n self.update_log_record(datetime.today().strftime(\"%Y-%m-%d\"), score)","async def twitter(self, ctx, *, emoji: str):\n await self.get_emoji(ctx, \"twitter\", emoji)","def tweet_results(dl):\n\n TWT = twt.get_api()\n try:\n if(DEBUG):\n print(\"=====Mock Posting=====\")\n print(MSG.format(ISP, dl, ISP_DL))\n print(\"=====End=====\", flush=True)\n else:\n TWT.update_status(MSG.format(ISP, dl, ISP_DL))\n except:\n print(\"error posting to twitter\", flush=True)","def postTweet(self, userId: int, tweetId: int) -> None:\n self.timeStamp -= 1\n self.tweetTimeLine[userId] = self.tweetTimeLine.get(userId, []) + [[self.timeStamp, tweetId]]","def tumblrPost(body,tags=None,title=None):\t\n\tglobal settings\n\tpost_address = \"http://api.tumblr.com/v2/blog/\"+settings['blog']+\"/post\"\n\tdata = {\"type\":\"text\",\"state\":settings['state'],\"body\" : body, \"oauth_token\":settings['oauth_token']}\n\tif tags != None:\n\t\tdata['tags'] = str(tags)\n\tif title != None:\n\t\tdata['title'] = str(title)\n\tconsumer = oauth.Consumer(settings['consumer_key'], settings['consumer_secret'])\n\ttoken = oauth.Token(settings['oauth_token'], settings['oauth_token_secret'])\n\tclient = oauth.Client(consumer,token)\n\tresp, content = client.request(post_address, \"POST\", urllib.urlencode(data))\n\tjs = json.loads(content)\n \tif js['meta']['status'] != 201: #something wrong\n\t\tprint js['meta']['msg']\n\t\tprint js","def post_to_telegraph(a_title: str, content: str) -> str:\n post_client = TelegraphPoster(use_api=True)\n auth_name = \"Leech Zone\"\n post_client.create_api_token(auth_name)\n post_page = post_client.post(\n title=a_title,\n author=auth_name,\n author_url=\"t.me/OtakuTalk\",\n text=content,\n )\n return post_page[\"url\"]","def retweet(tweet):\n\n twitter.PostRetweet(tweet.id, trim_user=False)\n\n return","def _connect_twitter_api(self):\r\n auth = tweepy.OAuthHandler(CovidBot.CONSUMER_KEY,\r\n CovidBot.CONSUMER_SECRET)\r\n auth.set_access_token(CovidBot.ACCESS_TOKEN,\r\n CovidBot.ACCESS_TOKEN_SECRET)\r\n self.api = tweepy.API(auth)\r\n logging.info(\"Twitter successfully authenticated\")","def insert_tweet(status):\n status['replies'] = []\n return db.tweets.insert(status)","def tweet_it(string, credentials, image=None):\n if len(string) <= 0:\n return\n\n # Create and authorise an app with (read and) write access at:\n # https://dev.twitter.com/apps/new\n # Store credentials in YAML file\n auth = twitter.OAuth(\n credentials[\"access_token\"],\n credentials[\"access_token_secret\"],\n credentials[\"consumer_key\"],\n credentials[\"consumer_secret\"],\n )\n t = twitter.Twitter(auth=auth)\n\n print(\"TWEETING THIS:\\n\" + string)\n\n if args.test:\n print(\"(Test mode, not actually tweeting)\")\n else:\n\n if image:\n print(\"Upload image\")\n\n # Send images along with your tweets.\n # First just read images from the web or from files the regular way\n with open(image, \"rb\") as imagefile:\n imagedata = imagefile.read()\n t_up = twitter.Twitter(domain=\"upload.twitter.com\", auth=auth)\n id_img = t_up.media.upload(media=imagedata)[\"media_id_string\"]\n\n result = t.statuses.update(status=string, media_ids=id_img)\n else:\n result = t.statuses.update(status=string)\n\n url = (\n \"http://twitter.com/\"\n + result[\"user\"][\"screen_name\"]\n + \"/status/\"\n + result[\"id_str\"]\n )\n print(\"Tweeted:\\n\" + url)\n if not args.no_web:\n webbrowser.open(url, new=2) # 2 = open in a new tab, if possible","def add_tweet_reply(tweet_id, user, text):\n reply = {'user': user, 'text': text}\n return db.tweets.update(\n {'id_str': tweet_id}, {'$push': {'replies': reply}}, True)","def publish_twitter(event, event_url):\n return self.twitter.statuses.update(status='%s: %s' %(event, event_url))","def put_tweet(tweet_id):\n if not request.get_json() or 'tweet' not in request.get_json():\n raise exceptions.HttpError(message=\"No tweet info in body\")\n put_tweet = Tweet(\n id=tweet_id,\n name=None,\n tweet=request.get_json()[\"tweet\"],\n created_at=None,\n type='original'\n )\n tweet = Storage.put_tweet(tweet_id, tweet=put_tweet)\n return jsonify(tweet.to_dict()), 201","def twitter(self, twitter):\n\n self._twitter = twitter","def on_data(self, data):\n\n t = json.loads(data) \n tweet = {\n 'text': t['text'],\n 'username': t['user']['screen_name'],\n 'followers_count': t['user']['followers_count']\n }\n\n logging.critical(f'\\n\\n\\nTWEET INCOMING: {tweet[\"text\"]}\\n\\n\\n')\n tweet_collection.insert({'username' : tweet['username'],'followers_count' : tweet['followers_count'], 'text' : tweet['text']})","async def meme(self, ctx, subreddit='dankmemes'): #TODO fix gif playback\n credentials = cfload.configSectionMap(\"Reddit API\")\n\n await ctx.message.add_reaction(\"\\U0000231B\") # hourglass done (not actually done)\n\n r = praw.Reddit(client_id=credentials['client_id'],\n client_secret=credentials['client_secret'],\n user_agent=credentials['user_agent'],\n username=credentials['username'],\n password=credentials['password'])\n try:\n sub = r.subreddit(subreddit)\n if sub.over18:\n return await ctx.message.add_reaction(\"\\U0001F6AB\") # Prohibited\n n = 100\n posts = sub.hot(limit=n)\n rand = random.randint(0, n)\n for (i, post) in enumerate(posts): # TODO try random.choice() for the enumeration\n if i == rand:\n embed = discord.Embed(\n title=post.title, #TODO add subreddit link somewhere, maybe use add fields\n url='http://www.reddit.com' + post.permalink,\n # description=post.name,\n colour=discord.Colour(0xe7d066)\n )\n if post.url != 'https://www.reddit.com' + post.permalink: # It's an image post\n embed.set_image(url=post.url)\n embed.set_author(\n name='u/' + str(post.author),\n url='http://www.reddit.com/user/' + str(post.author),\n icon_url=post.author.icon_img\n )\n if post.selftext is not '': #If the post is a text post\n description = post.selftext[:1021] + '...' if len(post.selftext) > 1024 else post.selftext\n embed.add_field(\n name=str(post.score) + ' points',\n value=description\n )\n else: #If the post is a link post\n embed.add_field(\n name='Score:',\n value=post.score,\n inline=True\n )\n embed.add_field(\n name='Comments:',\n value=str(len(post.comments)),\n inline=True\n )\n embed.set_footer(\n text='r/' + str(post.subreddit),\n icon_url='https://styles.redditmedia.com/t5_6/styles/communityIcon_a8uzjit9bwr21.png'\n )\n\n await ctx.send(embed=embed)\n\n except Exception as e:\n await ctx.message.add_reaction(\"\\U0000274C\") # Cross mark\n log.error('Exception in /meme:', e)\n finally:\n await ctx.message.remove_reaction('\\U0000231B', ctx.me)","def t_auth():\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\n auth.set_access_token(access_token, token_secret)\n return tweepy.API(auth)","def like_tweet(self, tag):\n self.bot.get('https://twitter.com/search?q=' + tag + '&src=typed')\n self.__wait(3, 3)\n for i in range(1, 3):\n self.bot.execute_script('window.scrollTo(0,document.body.scrollHeight)')\n self.__wait(2, 3)\n tweets = self.bot.find_elements_by_tag_name('article')\n\n links = []\n for tweet in tweets:\n sub_links = tweet.find_elements_by_tag_name('a')\n links += [sub_link.get_attribute('href')\n for sub_link in sub_links if 'status' in sub_link.get_attribute('href')]\n\n print('Started to like {} tweets'.format(len(links)))\n\n for link in links:\n self.bot.get(link)\n self.__wait(3, 5)\n likes = self.bot.find_elements_by_css_selector('div[data-testid=\"like\"')\n for like in likes:\n like.click()\n self.__wait(3, 5)","def send_fixtures_tweets(tweet1, tweet2, tweet3):\n\n # Authorises Twitter API connection\n api = twitter_auth()\n\n # Checks if tweet has already been made today\n get_tweet = api.user_timeline(count=1,tweet_mode=\"extended\")\n last_tweet = get_tweet[0].full_text\n tweet = tweet1[:-1]\n if last_tweet == tweet:\n return print('Tweet already sent')\n \n # Sends tweets to timeline, depending on how many tweets created\n # Multiple tweets sent as a thread by responding to previous tweet\n if tweet3:\n first_tweet = api.update_status(tweet1)\n first_id = first_tweet.id\n second_tweet = api.update_status(tweet2, first_id)\n second_id = second_tweet.id\n api.update_status(tweet3, second_id)\n return print('Successfully sent tweet(s)')\n elif tweet2:\n first_tweet = api.update_status(tweet1)\n first_id = first_tweet.id\n api.update_status(tweet2, first_id)\n return print('Successfully sent tweet(s)')\n else:\n api.update_status(tweet1)\n return print('Successfully sent tweet(s)')","def postTweet(self, userId, tweetId):\n if userId not in self.user_tweets:\n self.user_tweets[userId] = []\n \n self.user_tweets[userId].insert(0, (tweetId, self.buildSortId()))\n self.user_tweets[userId] = self.user_tweets[userId][:10]","def like_post(self,id):\n try:\n data = self.api.create_favorite(id)\n if isinstance(data,tweepy.models.Status):\n if hasattr(data,'_json'): \n return json.dumps(data._json)\n except tweepy.error.TweepError as e:\n print(e.__dict__)\n if e.__dict__['api_code']==139:\n data = unlike_post(id)\n return data","def handler(event, context):\n send_tweet(random.choice(potential_tweets))","def handler(event, context):\n send_tweet(random.choice(potential_tweets))","def tweet(self, tweet, at=None):\n if tweet.strip() == \"\":\n return\n\n num_tweets, tweets = self._divide_tweet(tweet, at)\n if num_tweets > 0:\n # replace @'s with #'s and convert unicode emojis before tweeting\n [self.api.update_status(tw.replace(\"@\", \"#\").encode(\"utf-8\")) for tw in tweets]\n self.log(f\"Tweeted: {' '.join(tweets)}\")\n return tweets[0]","async def post_do_action(post, action, curator, reaction):\n try:\n authorperm = construct_authorperm(post[\"author\"], post[\"permlink\"])\n link = \"https://steemit.com/\"+authorperm\n if post[\"author\"] in blacklist:\n await loop.create_task(send_discord(\"WARNING: Author is blacklisted \"+link, logchannel))\n return\n elif action == \"tf100\":\n try:\n post.upvote(weight=100, voter=postaccount)\n await loop.create_task(send_discord(link, upvotechannel))\n continent_code = get_location(post['body'], \"continentcode\")\n if continent_code == \"AF\" or continent_code == \"OC\" or continent_code == \"AN\":\n await loop.create_task(send_discord(link, australiaoceaniaafrica))\n elif continent_code == \"AS\":\n await loop.create_task(send_discord(link, asia))\n elif continent_code == \"EU\":\n await loop.create_task(send_discord(link, europe))\n elif continent_code == \"SA\" or continent_code == \"NA\":\n await loop.create_task(send_discord(link, america))\n elif \"food\" in post['body'] or \" eat\" in post['body'] or \"restaurant\" in post['body']:\n await loop.create_task(send_discord(link, foodoftheworld))\n elif \"advice\" in post['body'] or \"budget\" in post['body'] or \"learn\" in post['body']:\n await loop.create_task(send_discord(link, traveladvice))\n else:\n await loop.create_task(send_discord(link, nocategory))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆙\")\n except Exception as error:\n if not \"skip_transaction_dupe_check\" in repr(error):\n logger.warning(\"Could not vote with 100%\"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not vote with 100% on \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n return\n await asyncio.sleep(4)\n try:\n post.resteem(identifier=authorperm, account=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🔄\")\n except Exception as error:\n logger.warning(\"Could not resteem post \"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not resteem \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n await asyncio.sleep(4)\n try:\n post.reply(resteemtext.format(curator), author=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🔤\")\n except Exception as error:\n logger.warning(\"Could not comment on resteem post \"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not comment on resteem post \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n elif action == \"tf50\":\n try:\n post.upvote(weight=50, voter=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆗\")\n await loop.create_task(send_discord(link, honourchannel))\n except Exception as error:\n logger.warning(\"Could not vote with 50%\"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not vote with 50% on \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n return\n await asyncio.sleep(4)\n try:\n post.reply(honourtext.format(curator), author=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🔤\")\n except Exception as error:\n logger.warning(\"Could not comment on honour post \"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not comment on honour post \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n elif action == \"coop100\":\n try:\n post.upvote(weight=100, voter=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🚻\")\n except Exception as error:\n logger.warning(\"Could not vote with 100% on cooperation post \"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not vote with 100% on cooperation post \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n return\n elif action == \"ad10\":\n try:\n post.upvote(weight=10, voter=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🔟\")\n except Exception as error:\n logger.warning(\"Could not vote on ad post \"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not vote with 10% on ad post \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n return\n await asyncio.sleep(4)\n try:\n post.reply(advotetext.format(curator), author=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🔤\")\n except Exception as error:\n logger.warning(\"Could not comment on ad post \"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not comment on ad post \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n elif action == \"short0\":\n try: \n post.reply(manualshorttext.format(post[\"author\"]), author=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🔤\")\n except Exception as error:\n logger.warning(\"Could not comment on short post \"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not comment on short post \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n elif action == \"lang0\":\n try: \n post.reply(manuallangtext.format(post[\"author\"]), author=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🔤\")\n except Exception as error:\n logger.warning(\"Could not comment on non-English post \"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not comment on non-English post \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n elif action == \"copyright0\":\n try: \n post.reply(copyrighttext.format(post[\"author\"]), author=postaccount)\n if not reaction == None:\n await bot.add_reaction(reaction, \"🔤\")\n except Exception as error:\n logger.warning(\"Could not comment on copyright post \"+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not comment on copyright post \"+link+\" Exception: \"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")\n if not reaction == None:\n try:\n await bot.remove_reaction(reaction, \"⏳\", bot.user)\n except Exception as error:\n logger.warning(\"Could not remove hourglass reaction\"+repr(error))\n await asyncio.sleep(3)\n except Exception as error:\n logger.warning(\"Could not execute action for post \"+str(post)+repr(error))\n try:\n await loop.create_task(send_discord(\"Could not execute action on post \"+str(post)+\" Exception:\"+repr(error), logchannel))\n if not reaction == None:\n await bot.add_reaction(reaction, \"🆘\")\n except:\n logger.warning(\"Could not send message to Discord\")","def handler(event,context):\n send_tweet(random.choice(potential_tweets))","def post(owner_id=None, friends_only=None, from_group=None, message=None,\\\n attachments=None, services=None, signed=None, publish_date=None,\\\n lat=None, long=None, place_id=None, post_id=None, guid=None, mark_as_ads=None):\n params = {\n 'owner_id': owner_id,\n 'friends_only': friends_only,\n 'from_group': from_group,\n 'message': message,\n 'attachments': attachments,\n 'services': services,\n 'signed': signed,\n 'publish_date': publish_date,\n 'lat': lat,\n 'long': long,\n 'place_id': place_id,\n 'post_id': post_id,\n 'guid': guid,\n 'mark_as_ads': mark_as_ads\n }\n result = call('wall.post', **params)\n return parse_response(result)","def twitter_post_status():\n # Can be overriden in GET request\n question_cadence_minutes = \\\n int(request.args.get('question_cadence_minutes', 60 * 6))\n post_to_twitter = request.args.get('post_to_twitter', False)\n \n next_question = Question.get_next_question()\n if next_question is not None \\\n and __is_time_for_new_question(question_cadence_minutes):\n current_question = Question.get_current_question()\n \n if post_to_twitter != False:\n try:\n twitter_api = TwitterAPI()\n status = twitter_api.update_status(next_question.question_text)\n next_question.twitterid = str(status.id)\n next_question.put()\n except TweepError as e:\n pass #TODO: do something - message to monitoring?\n\n if current_question is not None:\n # Update overall state scores\n State.update_state_scores_for_completed_question(current_question)\n \n # Update overall question scores\n Question.tally_college_and_vote_scores(current_question)\n\n # Update end of question user sway scores\n users = User.get_all()\n for user in users:\n __attribute_sway_points_for_user(current_question, user)\n current_question.end_time = datetime.datetime.now()\n current_question.put()\n \n next_question.start_time = datetime.datetime.now()\n next_question.put()\n\n return 'Posted new status [%s]' % next_question.question_text, 200\n\n return 'New question not ready', 200","def add_tweet(self, tweet):\r\n self.tweets.append(tweet)","def retweet(tweet_id):\n r = requests.post(twitter_api_base + \"/statuses/retweet/\" +\n tweet_id + \".json\",\n auth=oauth_credentials)\n if r.status_code != 200:\n print(\"Attempted to retweet tweet %s\" % tweet_id)\n received_error(r)\n else:\n print(\"Successfully retweeted tweet %s.\" % tweet_id)"],"string":"[\n \"def post_to_twitter(tweet):\\n auth = tweepy.OAuthHandler(\\n os.environ['BLADAMADUR_CONSUMER_KEY'],\\n os.environ['BLADAMADUR_CONSUMER_SECRET'])\\n auth.set_access_token(\\n os.environ['BLADAMADUR_ACCESS_TOKEN'],\\n os.environ['BLADAMADUR_ACCESS_TOKEN_SECRET'])\\n api = tweepy.API(auth)\\n\\n api.update_status(tweet)\",\n \"def post_to_twitter(sender, instance, **kwargs):\\n\\n if instance.pk: #only post the tweet if it's a new record. \\n return False \\n \\n accounts = TwitterAccount.objects.all()\\n \\n for account in accounts:\\n bittle = Bittle.objects.bitlify(instance.get_absolute_url())\\n mesg = \\\"%s: %s\\\" % (\\\"New Blog Post\\\", bittle.shortUrl)\\n username = account.username\\n password = account.get_password()\\n try:\\n twitter_api = twitter.Api(username, password)\\n twitter_api.PostUpdate(mesg)\\n except urllib2.HttpError, ex:\\n print str(ex)\\n return False\",\n \"def tweet(api, message):\\n status = api.PostUpdate(message)\",\n \"def post_tweet():\\n if not request.get_json() or 'tweet' not in request.get_json():\\n raise exceptions.HttpError(message=\\\"No tweet info in body\\\")\\n\\n post_tweet = Tweet(\\n id=None,\\n name=None,\\n tweet=request.get_json()[\\\"tweet\\\"],\\n created_at=None,\\n type = 'original'\\n )\\n\\n tweet = Storage.post_tweet(tweet=post_tweet)\\n return jsonify(tweet.to_dict()), 201\",\n \"def send_tweet(media_id, quote, movie_name):\\n\\n tweet = '{} - {}'.format(quote, movie_name)\\n request_data = {\\n 'status': tweet,\\n 'media_ids': media_id\\n }\\n\\n requests.post(url=constants.POST_TWEET_URL, data=request_data, auth=oauth)\",\n \"def post_tweet(self, message):\\n twitter = TwitterAPI(\\n # os.environ[\\\"consumerKey\\\"],\\n # os.environ[\\\"consumerSecret\\\"],\\n # os.environ[\\\"accessToken\\\"],\\n # os.environ[\\\"accessTokenSecret\\\"],\\n self.twitter_creds[\\\"consumerKey\\\"],\\n self.twitter_creds[\\\"consumerSecret\\\"],\\n self.twitter_creds[\\\"accessToken\\\"],\\n self.twitter_creds[\\\"accessTokenSecret\\\"],\\n )\\n\\n request = twitter.request(\\\"statuses/update\\\", {\\\"status\\\": message})\\n\\n status_code = request.status_code\\n if status_code == 200:\\n rootLogger.info(\\\"Successfully tweeted: {}\\\".format(message))\\n else:\\n rootLogger.error(\\\"HTTP status code: {} -- unsuccessfully tweeted: {}\\\".format(status_code, message))\",\n \"def tweet(self, message: str) -> None:\\n\\n # YOUR CODE HERE\\n tweet = Tweet(self.userid, date.today(), message)\\n self.tweets.append(tweet)\",\n \"async def tweet():\\n with logger.contextualize(request_id=str(uuid.uuid4())):\\n tweets = generate()\\n upload(tweets)\",\n \"def post_to_tweets(data, url):\\n\\n print(\\\"here,\\\", url)\\n\\n albums = find_all_images(data['content'])\\n text = strip_text(data['content'])\\n\\n \\\"\\\"\\\"Where applicable, the images are associated with the text. This means, that to make an appropriate thread the\\n conversion from a post to tweets should take into account how words relate to images in a spacial way. For this\\n reason, we convert to tweets in batches.\\\"\\\"\\\"\\n\\n cfg = get_keys() # grab keys\\n api = get_api(cfg) # setup API\\n in_reply_to = None\\n twitter_url = 'https://twitter.com'\\n\\n # for idx, caption in enumerate(text):\\n # if idx > 0:\\n # url_img = None\\n # caption = re.findall(r\\\"[\\\\w']+|[.!?;]\\\\ \\\", caption)\\n # text[idx] = text_to_tweets(caption, url_img)\\n\\n try:\\n if data['in_reply_to'] is not None: # if post is reply ...\\n for reply in data['in_reply_to']:\\n if reply[:len(twitter_url)] == twitter_url: # if the URL points to twitter ...\\n in_reply_to = reply.split('/')[-1:] # ... get the status id\\n except KeyError:\\n pass\\n\\n url = 'https://' + DOMAIN_NAME + url\\n\\n tweets = text_to_tweets(text, url=url) # process string into tweet thread\\n\\n # try and parse a lat lng.\\n try:\\n lat, lng = data['geo'][4:].split(\\\",\\\")\\n except KeyError:\\n lat, lng = None, None\\n\\n # post the first tweet so that we have a status id to start the thread\\n status = api.update_status(status=tweets[0].pop(0), in_reply_to_status_id=in_reply_to)\\n first_id = status.id # the id which points to origin of thread\\n\\n for album_group in text:\\n try:\\n media = album_group.pop(0) # get the corresponding album\\n for tweet in album_group:\\n status = api.update_with_media(filename=media, status=tweet, in_reply_to_status_id=status.id, lat=lat, long=lng)\\n media = None\\n except IndexError: # if we're out of albums...\\n pass\\n return 'http://twitter.com/{name}/status/{id}'.format(name=status.user.screen_name, id=first_id, lat=lat, lng=lng)\",\n \"def post_to_twitter(sender, instance, *args, **kwargs):\\n\\n # avoid to post the same object twice\\n if not kwargs.get('created'):\\n return False\\n\\n # check if there's a twitter account configured\\n import tweepy\\n try:\\n consumer_key = os.environ.get('TWITTER_CONSUMER_KEY')\\n consumer_secret = os.environ.get('TWITTER_CONSUMER_SECRET')\\n access_key = os.environ.get('TWITTER_ACCESS_KEY')\\n access_secret = os.environ.get('TWITTER_ACCESS_SECRET')\\n except AttributeError:\\n print 'WARNING: Twitter account not configured.'\\n return False\\n\\n # create the twitter message\\n try:\\n text = instance.get_twitter_message()\\n except AttributeError:\\n text = unicode(instance)\\n\\n mesg = u'%s' % (text)\\n if len(mesg) > TWITTER_MAXLENGTH:\\n size = len(mesg + '...') - TWITTER_MAXLENGTH\\n mesg = u'%s...' % (text[:-size])\\n\\n try:\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_key, access_secret)\\n api = tweepy.API(auth)\\n api.update_status(mesg)\\n except urllib2.HTTPError, ex:\\n print 'ERROR:', str(ex)\\n return False\",\n \"def send_tweet(data):\\n # Fill in the values noted in previous step here\\n cfg = get_keys() # grab keys\\n api = get_api(cfg) # setup API\\n in_reply_to = None\\n twitter_url = 'https://twitter.com'\\n if data['in_reply_to'] is not None: # if post is reply ...\\n for reply in data['in_reply_to']:\\n if reply[:len(twitter_url)] == twitter_url: # if the URL points to twitter ...\\n in_reply_to = reply.split('/')[-1:] # ... get the status id\\n url = 'https://' + DOMAIN_NAME + data['url']\\n tweets = post_to_tweets(data=data['content'], url=url) # process string into tweet thread\\n # post the first tweet so that we have a status id to start the thread\\n status = api.update_status(status=tweets.pop(0), in_reply_to_status_id=in_reply_to)\\n first_id = status.id # the id which points to origin of thread\\n try:\\n lat,lng = data['geo'][4:].split(\\\",\\\")\\n except KeyError:\\n lat, lng = None, None\\n for tweet in tweets:\\n status = api.update_status(status=tweet, in_reply_to_status_id=status.id)\\n return 'http://twitter.com/{name}/status/{id}'.format(name=status.user.screen_name, id=first_id, lat=lat, lng=lng)\",\n \"def command_tweet(self, bot, update):\\n\\n bot.sendChatAction(update.message.chat_id, action='typing')\\n\\n tweet = ext.get_last_tweet(self.config['twitter'])\\n\\n for url in tweet.get('images', []):\\n self.send_photo_url(bot, update, url)\\n\\n messages = [\\n u'{text}',\\n '[@{user[screen_name]}](https://twitter.com/{user[screen_name]}) '\\n '- {ago}'\\n ]\\n\\n for msg in messages:\\n self.send_message(bot, update, msg.format(**tweet))\",\n \"def tweet(self, message):\\n if self.api_key == \\\"\\\":\\n return False\\n ts = TagStripper()\\n ts.feed(message)\\n params = urllib.urlencode(\\n {'api_key': self.api_key,\\n 'status': ts.get_collected_data()})\\n\\n headers = {\\\"Content-type\\\": \\\"application/x-www-form-urlencoded\\\",\\n \\\"Accept\\\": \\\"text/plain\\\"}\\n\\n conn = httplib.HTTPConnection(\\\"api.thingspeak.com:80\\\")\\n\\n try:\\n conn.request(\\\"POST\\\",\\n \\\"/apps/thingtweet/1/statuses/update\\\",\\n params,\\n headers)\\n\\n response = conn.getresponse()\\n data = response.read()\\n conn.close()\\n return True, ts.get_collected_data()\\n except httplib.HTTPException as http_exception:\\n return False, http_exception.message\",\n \"def tweet(user):\\n api = get_api(user)\\n msg = 'I used hackt to follow @hackerschool batches on twitter. You can too at http://bit.ly/hs_hackt'\\n\\n try:\\n api.PostUpdate(msg)\\n except twitter.TwitterError as error:\\n return {'msg': error.message[0]['message']}\",\n \"def postTweet(self, userId: int, tweetId: int) -> None:\\n ts = time.time()\\n self.posts[userId].append((ts, tweetId))\",\n \"def tweet(api):\\n logger.info(\\\"Tweeting content\\\")\\n urls = get_article('the_onion.txt')\\n lines = content_list(urls)\\n\\n for line in lines:\\n try:\\n api.update_status(line)\\n logger.info(\\\"Tweeting!\\\")\\n time.sleep(SECONDS)\\n\\n except tweepy.TweepError as err:\\n logger.error(err)\",\n \"def postTweet(self, userId: int, tweetId: int) -> None:\\n self.cnt += 1\\n self.posts[userId].append((self.cnt, tweetId))\",\n \"def tweet(message):\\n auth = load_twitter_auth()\\n key = environ['TWITTER_ACCESS_KEY']\\n secret = environ['TWITTER_ACCESS_SECRET']\\n auth.set_access_token(key, secret)\\n api = tweepy.API(auth)\\n api.update_status(message)\\n print(message)\",\n \"def send_tweet(tweet_text):\\n twitter.update_status(status = tweet_text)\",\n \"def send_tweet(tweet_text):\\n twitter.update_status(status=tweet_text)\",\n \"def send_tweet(tweet_text):\\n twitter.update_status(status=tweet_text)\",\n \"def send_tweet(tweet_text):\\n twitter.update_status(status=tweet_text)\",\n \"def postTweet(self, userId: int, tweetId: int) -> None:\\n self.users.add(userId)\\n self.user_post[userId].append((tweetId, self.time))\\n self.time += 1\",\n \"def handler(event,context):\\n tweet = setup_and_get_tweet()\\n send_tweet(tweet)\",\n \"def answer_to_tweets(api, tweets):\\n\\n try:\\n last_tweet_id = 0\\n for tweet in tweets:\\n print(\\\"Sending an answer to tweet {}: '{}'\\\".format(tweet[\\\"id\\\"],\\n tweet[\\\"text\\\"]))\\n api.statuses.update(status=TARGET_TWEET_ANSWER,\\n in_reply_to_status_id=tweet[\\\"id\\\"])\\n last_tweet_id = tweet[\\\"id\\\"]\\n time.sleep(1) # do not exceed Twitter limits\\n finally:\\n update_last_tweet_id(last_tweet_id)\",\n \"def post_tweet(instance, created, raw, **kwargs):\\n if created and not raw:\\n _twitter.statuses.update(status='%s %s' % (\\n instance.title,\\n instance.url,\\n ))\",\n \"def post(self, request):\\n if request.user.is_authenticated:\\n if not request.user.consumer_key and not request.user.consumer_secret and not request.user.oauth_token and \\\\\\n not request.user.oauth_token_secret:\\n return Response({\\\"message\\\": \\\"Kindly supply the twitter authentication keys in the admin dashboard\\\"},\\n status=status.HTTP_400_BAD_REQUEST)\\n else:\\n tweets = request.data.get('tweets', None)\\n if tweets is not None:\\n api = load_api(request)\\n try:\\n api.update_status(tweets)\\n except tweepy.TweepError as e:\\n return Response({\\\"message\\\": e.args[0][0]['message']}, status=status.HTTP_400_BAD_REQUEST)\\n return Response({\\\"message\\\": \\\"Your tweets has been updated\\\"}, status=status.HTTP_201_CREATED)\",\n \"def postTweet(self, userId: int, tweetId: int) -> None:\\n if userId not in self.users.keys():\\n self.users[userId] = user()\\n self.users[userId].tweets.append(tweetId)\\n self.tweetTime[tweetId] = self.time\\n self.time += 1\",\n \"def post_to_twitter(content) -> None:\\n logging.error(f'No function registered to handle posting type: {type(content)} to twitter')\\n pass\",\n \"def add_tweet():\\n if not request.json or 'author_id' not in request.json or 'text' not in request.json:\\n abort(400)\\n\\n db = get_db()\\n\\n author_id = request.json.get('author_id')\\n text = request.json.get('text')\\n pub_date = int(time.time())\\n\\n db.execute('''insert into message (author_id, text, pub_date) values (?, ?, ?)''', (author_id, text, pub_date))\\n db.commit()\\n flash('Message recorded succesfully')\\n message = {\\\"author_id\\\": author_id, \\\"text\\\": text, \\\"pub_date\\\": pub_date}\\n return jsonify({'message': message}), 201\",\n \"def postTweet(self, userId, tweetId):\\r\\n self.timestamp += 1\\r\\n self.tweets_by_user[userId].append((self.timestamp, tweetId))\",\n \"def publish_tweet(self, tweet):\\n\\n self.api.update_status(tweet)\",\n \"def tweet(self):\\n self.__refresh_local_tweets()\\n\\n if not self.tweets:\\n return\\n\\n tweet_obj = self.tweets[0]\\n\\n # upload picture\\n media_id = self.__upload_media(tweet_obj[\\\"img\\\"])\\n\\n # tweet with text, and image\\n if not media_id:\\n return\\n self.__post_status(tweet_obj[\\\"text\\\"], media_id)\\n\\n self.tweets.remove(tweet_obj)\\n self.tweeted.append(tweet_obj)\\n self.__update_local_tweets()\",\n \"def write_post(id, args):\\n graph = facebook.GraphAPI(id) \\n graph.put_object(parent_object='me', connection_name = 'feed', **args)\",\n \"async def add_tweet(self, tid=None): \\n try:\\n data=json.loads(self.request.body.decode('utf-8'))\\n except: \\n print(\\\"No data body!\\\")\\n\\n #print(\\\"Coordinates: {}\\\".format(data[\\\"coordinates\\\"]))\\n if \\\"place\\\" in data:\\n print(\\\"Place: {}\\\".format(data[\\\"place\\\"]))\\n\\n #print(\\\"User location: {}\\\".format(data[\\\"user\\\"][\\\"location\\\"]))\\n #print(\\\"User lang: {}\\\".format(data[\\\"user\\\"][\\\"lang\\\"]))\\n t=Tweet()\\n t.tweet_id = tid\\n t = self.fill_tweet(t, data)\\n tweet_cache.append(t.to_dict())\\n if \\\"retweeted_status\\\" in data:\\n t.retweeted_status=data[\\\"retweeted_status\\\"]\\n # \\n # save the tweet\\n #\\n t.upsert()\\n #\\n # now handle the retweet\\n #\\n if \\\"retweeted_status\\\" in data:\\n # this is a retweet so\\n # do it once more for the original tweet\\n tr=Tweet()\\n tr.tweet_id = data[\\\"retweeted_status\\\"][\\\"id_str\\\"]\\n tr = self.fill_tweet(tr, data[\\\"retweeted_status\\\"])\\n tweet_cache.append(tr.to_dict())\\n #tr.upsert()\\n #r=requests.get(\\\"https://publish.twitter.com/oembed?url=https://twitter.com/Interior/status/\\\"+ t.tweet_id )\\n #await self.fire_callbacks(r.json())\\n #print(t.to_json(),file=ofile)\\n #\\n # get the embed html from twitter oembed API\\n #\\n r=requests.get(\\\"https://publish.twitter.com/oembed?url=https://twitter.com/Interior/status/\\\"+ t.tweet_id )\\n #print(r.json())\\n \\n #print(self.__class__.callbacks)\\n await self.fire_callbacks(r.json())\\n #self.success(message=\\\"Added tweet id: {} \\\".format(str(id)), data=t.to_json(), format=\\\"json\\\", pure=True)\",\n \"def postTweet(self, userId: int, tweetId: int) -> None:\\n if userId not in self.users:\\n self._create_user(userId)\\n self.users_tweet[userId].appendleft((self.uid, tweetId))\\n self.uid += 1\",\n \"def post_to_twitter(worker_responses):\\n for worker_response in worker_responses:\\n print get_tweet_text(worker_response)\",\n \"def tweet(chains):\\n\\n # Use Python os.environ to get at environmental variables\\n # Note: you must run `source secrets.sh` before running this file\\n # to make sure these environmental variables are set.\\n\\n api = twitter.Api(\\n consumer_key=os.environ['TWITTER_CONSUMER_KEY'],\\n consumer_secret=os.environ['TWITTER_CONSUMER_SECRET'],\\n access_token_key=os.environ['TWITTER_ACCESS_TOKEN_KEY'],\\n access_token_secret=os.environ['TWITTER_ACCESS_TOKEN_SECRET'])\\n\\n # print api.VerifyCredentials()\\n\\n user_choice = None\\n while not (user_choice == 'q' or user_choice == 'Q'):\\n status = api.PostUpdate(make_text(chains))\\n #status = api.PostUpdate(\\\"Something random\\\")\\n\\n print status.text\\n user_choice = raw_input(\\\"Enter to tweet again [q to quit] > \\\")\",\n \"def postTweet(self, userId, tweetId):\\n if not self.user_pool[userId].user_id:\\n user = UserInfo()\\n user.user_id = userId\\n self.user_pool[userId] = user\\n self.time += 1\\n tw_info = (tweetId, self.time) # 保存一个和时间戳\\n self.twitter_pool[userId].append(tw_info)\",\n \"async def tweet_menu(self, ctx, post_list: list,\\n message: discord.Message=None,\\n page=0, timeout: int=30):\\n s = post_list[page]\\n colour =\\\\\\n ''.join([randchoice('0123456789ABCDEF')\\n for x in range(6)])\\n colour = int(colour, 16)\\n created_at = s.created_at\\n created_at = created_at.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n post_url =\\\\\\n \\\"https://twitter.com/{}/status/{}\\\".format(s.user.screen_name, s.id)\\n desc = \\\"Created at: {}\\\".format(created_at)\\n em = discord.Embed(title=\\\"Tweet by {}\\\".format(s.user.name),\\n colour=discord.Colour(value=colour),\\n url=post_url,\\n description=desc)\\n em.add_field(name=\\\"Text\\\", value=s.text)\\n em.add_field(name=\\\"Retweet count\\\", value=str(s.retweet_count))\\n if hasattr(s, \\\"extended_entities\\\"):\\n em.set_image(url=s.extended_entities[\\\"media\\\"][0][\\\"media_url\\\"] + \\\":thumb\\\")\\n if not message:\\n message =\\\\\\n await self.bot.send_message(ctx.message.channel, embed=em)\\n await self.bot.add_reaction(message, \\\"⬅\\\")\\n await self.bot.add_reaction(message, \\\"❌\\\")\\n await self.bot.add_reaction(message, \\\"➡\\\")\\n else:\\n message = await self.bot.edit_message(message, embed=em)\\n react = await self.bot.wait_for_reaction(\\n message=message, user=ctx.message.author, timeout=timeout,\\n emoji=[\\\"➡\\\", \\\"⬅\\\", \\\"❌\\\"]\\n )\\n if react is None:\\n await self.bot.remove_reaction(message, \\\"⬅\\\", self.bot.user)\\n await self.bot.remove_reaction(message, \\\"❌\\\", self.bot.user)\\n await self.bot.remove_reaction(message, \\\"➡\\\", self.bot.user)\\n return None\\n reacts = {v: k for k, v in numbs.items()}\\n react = reacts[react.reaction.emoji]\\n if react == \\\"next\\\":\\n next_page = 0\\n if page == len(post_list) - 1:\\n next_page = 0 # Loop around to the first item\\n else:\\n next_page = page + 1\\n return await self.tweet_menu(ctx, post_list, message=message,\\n page=next_page, timeout=timeout)\\n elif react == \\\"back\\\":\\n next_page = 0\\n if page == 0:\\n next_page = len(post_list) - 1 # Loop around to the last item\\n else:\\n next_page = page - 1\\n return await self.tweet_menu(ctx, post_list, message=message,\\n page=next_page, timeout=timeout)\\n else:\\n return await\\\\\\n self.bot.delete_message(message)\",\n \"def tweet(text):\\n # Twitter authentication\\n auth = tweepy.OAuthHandler(C_KEY, C_SECRET)\\n auth.set_access_token(A_TOKEN, A_TOKEN_SECRET)\\n api = tweepy.API(auth)\\n\\n # Send the tweet and log success or failure\\n try:\\n api.update_status(text)\\n except tweepy.error.TweepError as e:\\n log(e.message)\\n print(e.message)\\n else:\\n log(\\\"Tweeted: \\\" + text)\\n print(\\\"Tweeted: \\\" + text)\",\n \"def add_tweet():\\r\\n tweet = models.Tweet(text_content=request.json['content'], username=request.json['username'],\\r\\n timestamp=datetime.datetime.now())\\r\\n db.session.add(tweet)\\r\\n db.session.commit()\\r\\n\\r\\n return {'id': tweet.id}\",\n \"async def make_tweet(tweet: str = Query(...),\\n # attachment_url: Optional[str] = Query(None, alias=\\\"link of tweet to quote\\\", regex=\\\"https://twitter.com/([\\\\w_]+)/status/([\\\\d]+)\\\"),\\n # in_reply_to: Optional[int] = Query(None, alias=\\\"link of tweet to reply to\\\", regex=\\\"https://twitter.com/([\\\\w_]+)/status/([\\\\d]+)\\\"), \\n user: User = Depends(get_current_user),\\n session: Session = Depends(get_db)\\n )-> TweetSchema:\\n if not user.active:\\n raise HTTPException(401, detail=\\\"Your account seems to be inactive, please login with twitter to make tweets\\\")\\n # if in_reply_to:\\n # regex = re.match(\\\"https://twitter.com/(?P<username>[\\\\w]+)/status/(?P<id>[\\\\d]+)\\\", in_reply_to)\\n # status_id = regex.group(\\\"id\\\")\\n url = \\\"https://api.twitter.com/1.1/statuses/update.json\\\"\\n params = dict(status=tweet,\\n # attachment_url=attachment_url,\\n # in_reply_to_status_id=status_id,\\n )\\n auth = user.get_oauth1_token()\\n\\n r = requests.post(url, params=params, auth=auth)\\n if not r.ok:\\n raise HTTPException(400, detail={\\\"message\\\":\\\"Something went wrong with Twitter, please try again or contact me @redDevv\\\",\\n \\\"error from twitter\\\": r.text})\\n tweet = r.json()\\n\\n new_tweet = Tweet(**tweet)\\n user.tweets.append(new_tweet)\\n user.requests_made += 1\\n\\n session.commit()\\n return tweet\",\n \"def tweet(text):\\n # Twitter authentication\\n auth = tweepy.OAuthHandler(C_KEY, C_SECRET)\\n auth.set_access_token(A_TOKEN, A_TOKEN_SECRET)\\n api = tweepy.API(auth)\\n\\n # Send the tweet and log success or failure\\n try:\\n api.update_status(text)\\n except tweepy.error.TweepError as e:\\n log(e.message)\\n else:\\n log(\\\"Tweeted: \\\" + text)\",\n \"def post(self, request, *args, **kwargs):\\n form = self.form_class(data=request.POST, user=request.user)\\n\\n if form.is_valid():\\n instance = form.save()\\n\\n # Deal with posting twitter status\\n posted_status = False\\n if instance.category != get_default_category():\\n # Create tweeted message and post status\\n tweeted_message = \\\"RT:<%s>%s#Custom#%s\\\" % (instance.created_by.username, instance.message, instance.category)\\n api = twitter.Api(consumer_key=settings.TWITTER_CONSUMER_KEY, consumer_secret=settings.TWITTER_CONSUMER_SECRET,\\n access_token_key=settings.TWITTER_USER_OAUTH_TOKEN, access_token_secret=settings.TWITTER_USER_OAUTH_TOKEN_SECRET)\\n api.PostUpdate(status=tweeted_message)\\n\\n # Save time published and update postedStatus\\n instance.published_on = timezone.now()\\n instance.save()\\n posteds_status = True\\n\\n return render(request, 'tweets/index.html', {'form': self.form_class(user=request.user), 'success': True, 'posted_status': posted_status})\\n return render(request, 'tweets/index.html', {'form': form})\",\n \"def postTweet(self, userId: int, tweetId: int) -> None:\\n self.tweets[userId].appendleft((next(self.timer), tweetId))\",\n \"def send_tweet(tweet_text, uuid):\\n try:\\n query = {} # API call to twitter-service\\n query['app_name'] = 'webcamd'\\n query['uuid'] = uuid\\n query['tweet_text'] = tweet_text\\n query['hashtag_arg'] = 'metminiwx' # do not supply the #\\n query['lat'] = 51.4151 # FIXME - put in definitions.py Stockcross\\n query['lon'] = -1.3776 # Stockcross\\n\\n status_code, response_dict = cumulus_comms.call_rest_api(get_env.get_twitter_service_endpoint() + '/send_text', query)\\n\\n if response_dict['status'] == 'OK' :\\n tweet_len = response_dict['tweet_len'].__str__()\\n print('Tweet sent OK, tweet_len=' + tweet_len + ', uuid=' + uuid.__str__())\\n else:\\n print(response_dict['status'])\\n\\n except Exception as e:\\n print('Error : send_tweet() : ' + e.__str__())\",\n \"def sending_process(self, quote, movie_poster_url, movie_name):\\n file_name, file_type = download_poster(movie_poster_url)\\n media_upload = async_upload.VideoTweet(file_name, oauth)\\n media_id = media_upload.upload_init(file_type)\\n media_upload.upload_append()\\n try:\\n media_upload.upload_finalize()\\n except Exception as e:\\n print('Media Upload Error', str(e))\\n return self.run()\\n\\n send_tweet(media_id, quote, movie_name)\",\n \"def postTweet(self, userId, tweetId):\\n self.time += 1\\n self.tweets[userId] = self.tweets.get(userId, []) + [(-self.time, tweetId)]\",\n \"def tweet_user(self, target, msg=None):\\n self.log.debug(\\\"Tweeting %s\\\" % target.hunted.screen_name)\\n tweet = \\\"@%s: %s\\\" % (target.hunted.screen_name,\\n random.sample(self.tweets, 1)[0])\\n tweet = tweet [:140]\\n self.api.update_status(tweet)\\n target.status = Target.FOLLOWER\\n target.save()\",\n \"def reply_to_tweets():\\n last_seen_id = retrieve_last_seen_id(FILE_NAME)\\n mentions = api.mentions_timeline(\\n last_seen_id,\\n tweet_mode='extended')\\n\\n for mention in reversed(mentions):\\n print(str(mention.id) + ' - ' + mention.full_text, flush=True)\\n last_seen_id = mention.id\\n store_last_seen_id(last_seen_id, FILE_NAME)\\n for i in range(len(keywords)):\\n if keywords[i] in mention.full_text.lower():\\n print(\\\"responding back to: \\\" + '@' +\\n mention.user.screen_name, flush=True)\\n api.update_status('@' + mention.user.screen_name + ' ' +\\n salts[i], mention.id)\",\n \"async def tweet_feeder(self): \\n try:\\n data=json.loads(self.request.body.decode('utf-8'))\\n except: \\n print(\\\"No data body!\\\")\\n\\n t=Tweet()\\n t.tweet_id = data[\\\"tweet_id\\\"]\\n t.text=data[\\\"text\\\"]\\n #\\n # update the hashtags cache\\n #\\n try:\\n t.hashtags=data[\\\"hashtags\\\"] \\n for htag in t.hashtags:\\n #print(\\\"adding to hashtags: {} to cache:\\\".format(htag[\\\"text\\\"], ))\\n if htag[\\\"text\\\"] in hash_cache:\\n hash_cache[htag[\\\"text\\\"]] += 1\\n else:\\n hash_cache[htag[\\\"text\\\"]] = 1\\n except:\\n t.hashtags=[]\\n \\n #\\n # update the user cache\\n #\\n try:\\n user_id = \\\"@\\\" + data[\\\"user_screenname\\\"]\\n if user_id in user_cache:\\n user_cache[user_id] += 1\\n else:\\n user_cache[user_id] = 1\\n except:\\n print(\\\" ERR No User: should never happen\\\")\\n\\n try:\\n t.user_screenname=data[\\\"user_screenname\\\"]\\n except:\\n t.user_screenname=\\\"\\\"\\n try:\\n t.profile_image_url_https = data[\\\"profile_image_url_https\\\"]\\n except:\\n t.profile_image_url_https = \\\"\\\"\\n #\\n # update the tweets cache\\n #\\n try:\\n t.timestamp = data[\\\"timestamp\\\"]\\n except:\\n t.timestamp = datetime.datetime.utcnow()\\n tweet_cache.append(t.to_dict())\\n \\n #\\n # get the embed html from twitter oembed API\\n #\\n r=requests.get(\\\"https://publish.twitter.com/oembed?url=https://twitter.com/Interior/status/\\\"+ t.tweet_id )\\n #print(r.json())\\n \\n #print(self.__class__.callbacks)\\n await self.fire_callbacks(r.json())\\n #self.success(message=\\\"Added tweet id: {} \\\".format(str(id)), data=t.to_json(), format=\\\"json\\\", pure=True)\",\n \"def reply_to_tweet():\\n\\n print('retrieving and replying to tweets...')\\n all_mentions = api.mentions_timeline()\\n\\n # The content of the reply that the bot will send.\\n rap_message = ' yo yo yo yo'\\n\\n for mention in reversed(all_mentions):\\n\\n # print(str(mention.id) + '-' + mention.text)\\n\\n if 'rap for me' in mention.text.lower():\\n # checks if the bot received a request to deliver a rap\\n print('received a request')\\n print('dropping a new single...')\\n # Checks if the latest mention came from the same person.\\n if mention.id == mention.id[0]:\\n # Posts a tweet saying the bot is 'too tired' and won't generate a new rap.\\n api.update_status('@' + mention.user.screen_name + ' yo sorry I am too tired right now')\\n else:\\n # Posts a tweet with the rap to the user.\\n api.update_status('@' + mention.user.screen_name + rap_message, mention.id)\\n print('single dropped.')\",\n \"def tweet(chopped_string):\\n\\n status = api.PostUpdate(chopped_string)\\n print status.text\",\n \"def send_tweet(in_list):\\n\\n with open('credentials.json') as json_file:\\n creds = json.load(json_file)\\n\\n twit_creds = creds['twitter']\\n consumer_key = twit_creds['consumer_key']\\n consumer_secret = twit_creds['consumer_secret']\\n access_token = twit_creds['access_token']\\n access_token_secret = twit_creds['access_token_secret']\\n\\n for dev in in_list:\\n to_tweet = f\\\"New #Aberdeen AQ device found. ID = {dev}. See it on a map: http://uk.maps.luftdaten.info/#9/57.3406/-1.9226 \\\"\\n # tweet the message\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, access_token_secret)\\n tweepyapi = tweepy.API(auth)\\n tweepyapi.update_status(to_tweet)\\n # print(\\\"Tweeted\\\")\",\n \"def like_tweet(tweet_id):\\n twitter.create_favorite(id=tweet_id)\",\n \"def postTweet(self, userId: 'int', tweetId: 'int') -> 'None':\\n self.tweets[userId].appendleft((next(self.timer), tweetId))\",\n \"def on_tweet(self, tweet):\\n pass\",\n \"def bridgy_twitter(location):\\n r = send_mention(\\n 'http://' + DOMAIN_NAME +'/e/' + location,\\n 'https://brid.gy/publish/twitter',\\n endpoint='https://brid.gy/publish/webmention'\\n )\\n location = 'http://' + DOMAIN_NAME +'/e/' + location\\n syndication = r.json()\\n app.logger.info(syndication)\\n data = get_bare_file('data/' + location.split('/e/')[1]+\\\".md\\\")\\n if data['syndication'] == 'None':\\n data['syndication'] = syndication['url']+\\\",\\\"\\n else:\\n data['syndication'] += syndication['url']+\\\",\\\"\\n entry_re_write(data)\",\n \"def postTweet(self, userId, tweetId):\\n if userId in self.tweets:\\n self.tweets[userId].append([-self.time, tweetId])\\n else:\\n self.tweets[userId] = [[-self.time, tweetId]]\\n self.time += 1\",\n \"def IceT(sc, event):\\n request = urllib2.Request(\\n 'http://icetsvu.tumblr.com/random')\\n result = urllib2.urlopen(request)\\n sc.api_call('chat.postMessage', as_user='true',\\n channel=event['channel'], text=result.geturl())\",\n \"def twitter(self):\\n message = \\\"\\\"\\n count = self.collection.count()\\n\\n twitter = Twitter(auth = OAuth(self.access_key, self.access_secret, self.consumer_key, self.consumer_secret))\\n for keyword in self.twitter_keywords:\\n query = twitter.search.tweets(q = keyword)\\n for result in query['statuses']:\\n try:\\n data = {\\\"id\\\": count+1, \\\"source\\\": \\\"twitter\\\", \\\"timestamp\\\": datetime.now()}\\n data['tweet'] = result['text']\\n data['name'] = result[\\\"user\\\"][\\\"screen_name\\\"]\\n data['url'] = \\\"https://twitter.com/\\\" + data[\\\"name\\\"] + \\\"/status/\\\" + str(result['id'])\\n data['search_string'] = keyword\\n try:\\n dataid = self.collection.insert(data)\\n except DuplicateKeyError as e:\\n continue\\n count += 1\\n\\n # Slack push notification\\n length = 82 - len(data['url'])\\n message += \\\"\\\\nURL: \\\" + data['url'] + \\\" search string: \\\".rjust(length) + keyword\\n\\n except Exception as e:\\n print(e)\\n pass\\n \\n if message:\\n print(self.G + \\\"[+] Twitter\\\" + self.B + message)\\n self.message += \\\"\\\\n*Twitter*:\\\\n```\\\"\\n self.message += message\\n self.message += \\\"\\\\n```\\\"\\n\\n return\",\n \"async def batphone(self, ctx, *, message: add_est_timestamp = None):\\n\\n if not message:\\n return ctx.send(f\\\"\\\"\\\"{ctx.author.mention} I'm already doing 90% of the work. \\n Do you want me to come up with the message too?\\\"\\\"\\\")\\n\\n status = twitterapi.post_tweet(message)\\n\\n embed = discord.Embed(title='Batphone',\\n url=f'https://twitter.com/AmtrakEq/status/{status.id}',\\n description=message,\\n colour=discord.Colour.red())\\n embed.set_image(url=gifs.get_one_gif(\\\"thomas the train\\\"))\\n embed.set_author(name=ctx.author.display_name, icon_url=ctx.author.avatar_url)\\n\\n await ctx.bot.batphone_channel.send(f'@everyone {status.text}', embed=embed)\\n await ctx.message.delete()\",\n \"def _upload_to_twitter(self):\\n if self._twitter:\\n strip_file = self.create_strip(resolution_ratio=0.5)\\n f = open(strip_file)\\n self._twitter.request('statuses/update_with_media', {'status': self._twitter_text}, {'media[]': f.read()})\\n f.close()\\n os.remove(strip_file)\",\n \"async def reply_tweet(reply: str,\\n in_reply_to: str = Query(None, alias=\\\"link of tweet\\\", regex=\\\"https://twitter.com/([\\\\w_]+)/status/([\\\\d]+)\\\"),\\n status_id: int = Query(None, alias=\\\"id of tweet\\\"),\\n user: User = Depends(get_current_user),\\n session: Session = Depends(get_db)\\n )-> TweetSchema:\\n if not user.active:\\n raise HTTPException(401, detail=\\\"Your account seems to be inactive, please login with twitter to make tweets\\\")\\n if not (in_reply_to or status_id):\\n raise HTTPException(400, detail=\\\"Please enter either a Tweet ID or link to reply to\\\")\\n\\n if in_reply_to:\\n regex = re.match(\\\"https://twitter.com/(?P<username>[\\\\w]+)/status/(?P<id>[\\\\d]+)\\\", in_reply_to)\\n status_id = regex.group(\\\"id\\\")\\n\\n url = \\\"https://api.twitter.com/1.1/statuses/update.json\\\"\\n params = dict(status=reply,\\n in_reply_to_status_id=status_id,\\n auto_populate_reply_metadata=True\\n )\\n auth = user.get_oauth1_token()\\n\\n r = requests.post(url, params=params, auth=auth)\\n if not r.ok:\\n raise HTTPException(400, detail={\\\"message\\\":\\\"Something went wrong with Twitter, please try again or contact me @redDevv\\\",\\n \\\"error from twitter\\\": r.text})\\n tweet = r.json()\\n\\n new_tweet = Tweet(**tweet)\\n user.tweets.append(new_tweet)\\n user.requests_made += 1\\n\\n session.commit()\\n return tweet\",\n \"def send_tweet(auth, tweet, in_reply_to=None):\\n\\tif isinstance(tweet, list):\\n\\t\\t# It's a thread of tweets\\n\\t\\tprev = ret = None\\n\\t\\tfor part in tweet:\\n\\t\\t\\tif not part: continue\\n\\t\\t\\tinfo = send_tweet(auth, part, in_reply_to=prev)\\n\\t\\t\\tif \\\"error\\\" in info: return info\\n\\t\\t\\tif not ret: ret = info # Return the info for the *first* tweet sent\\n\\t\\t\\tprev = info[\\\"tweet_id\\\"]\\n\\t\\treturn ret or {\\\"error\\\": \\\"Can't send a thread of nothing but empty tweets\\\"}\\n\\ttwitter = OAuth1Session(config.TWITTER_CLIENT_ID, config.TWITTER_CLIENT_SECRET, auth[0], auth[1])\\n\\tresp = twitter.post(\\\"https://api.twitter.com/1.1/statuses/update.json\\\",\\n\\t\\tdata={\\\"status\\\": tweet, \\\"in_reply_to_status_id\\\": in_reply_to})\\n\\tif resp.status_code != 200:\\n\\t\\tprint(\\\"Unknown response from Twitter\\\")\\n\\t\\tprint(resp.status_code)\\n\\t\\tprint(\\\"---\\\")\\n\\t\\tprint(resp.json())\\n\\t\\tprint(\\\"---\\\")\\n\\t\\ttry:\\n\\t\\t\\t# TODO: Report these to the front end somehow even if asynchronous\\n\\t\\t\\treturn {\\\"error\\\": \\\"Unable to send tweet: \\\" + resp.json()[\\\"errors\\\"][0][\\\"message\\\"]}\\n\\t\\texcept LookupError:\\n\\t\\t\\treturn {\\\"error\\\": \\\"Unknown error response from Twitter (see server console)\\\"}\\n\\tr = resp.json()\\n\\turl = \\\"https://twitter.com/%s/status/%s\\\" % (r[\\\"user\\\"][\\\"screen_name\\\"], r[\\\"id_str\\\"])\\n\\treturn {\\\"screen_name\\\": r[\\\"user\\\"][\\\"screen_name\\\"], \\\"tweet_id\\\": r[\\\"id\\\"], \\\"url\\\": url}\",\n \"def RT(ID, name):\\r\\n \\\"\\\"\\\"Takes a ID and username parameter\\\"\\\"\\\"\\r\\n \\\"\\\"\\\"Once tweeted log is updated in overall and to date tweetlog\\\"\\\"\\\"\\r\\n \\r\\n config = config_create()\\r\\n print(\\\"RT\\\")\\r\\n #Tid = int(float(ID))\\r\\n Tweetusername = config.get('Auth', 'botname')\\r\\n #TweetText = 'https://twitter.com/'+Tweetusername+'/status/'+ID\\r\\n #ReTweet = 'Hi I am ComicTweetBot!('+tim+') I Retweet Comics! Use #comicretweetbot '+TweetText\\r\\n x2 = config.get('Latest_Log', 'currenttweetlog')\\r\\n x3 = config.get('Latest_Log', 'overalllog')\\r\\n CONSUMER_KEY = config.get('Auth', 'CONSUMER_KEY') \\r\\n CONSUMER_SECRET = config.get('Auth', 'CONSUMER_SECRET')\\r\\n ACCESS_KEY = config.get('Auth', 'ACCESS_KEY')\\r\\n ACCESS_SECRET = config.get('Auth', 'ACCESS_SECRET')\\r\\n api = Twython(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_KEY, ACCESS_SECRET)\\r\\n tMax = int(float(config.get('Tweet_Delay', 'Max')))\\r\\n tMin = int(float(config.get('Tweet_Delay', 'Min')))\\r\\n tStep = int(float(config.get('Tweet_Delay', 'Step')))\\r\\n Log = open(x2, 'w')\\r\\n enterlog = ID+' '+name+ '\\\\n'\\r\\n Log.write(enterlog)\\r\\n Log2 = open(x3, 'w')\\r\\n Log2.write(ID+'\\\\n')\\r\\n #api.update_status(status= ReTweet)\\r\\n api.retweet(id = ID)\\r\\n api.create_favorite(id=ID, include_entities = True)\\r\\n #randomize the time for sleep 1.5mins to 5 mins\\r\\n rant = random.randrange(tMin, tMax, tStep)\\r\\n time.sleep(rant)\",\n \"def pushTwitterUsers(twits):\\n rightNow = datetime.now().isoformat()\\n for twit in twits:\\n twit['last_scraped'] = rightNow\\n \\n renderedTwits = [ renderTwitterUser(twit) for twit in twits ]\\n pushRenderedTwits2Neo.delay(renderedTwits)\\n pushRenderedTwits2Cass.delay(renderedTwits)\\n #return True\",\n \"def postTweet(self, userId: int, tweetId: int) -> None:\\n # Time Complexity: O(1)\\n if userId not in self.tweets:\\n self.tweets[userId] = []\\n\\n self.tweets[userId].append((-self.timestamp, tweetId))\\n self.timestamp += 1\",\n \"def TweetHandler(self):\\n self.response.out.write('<br/><br/>Tweeting<br/>')\\n self.response.out.write('this info will be tweeted:<br/>')\\n # oldest non-tweeted and prepared\\n oldest_changeset = Changeset.all().order('created_at').filter('is_tweeted =', False).filter('is_prepared =', True).fetch(1)\\n if not oldest_changeset:\\n self.response.out.write('nothing to tweet')\\n return\\n else:\\n c = oldest_changeset[0]\\n \\n config = get_config()\\n\\n # do not tweet from localhost\\n if not 'localhost' in self.request.url:\\n auth = tweepy.OAuthHandler(config[\\\"consumer_key\\\"], config[\\\"consumer_secret\\\"])\\n auth_data = OAuthAccessToken.all().filter('specifier =', config[\\\"twitter_username\\\"]).fetch(1)[0]\\n auth.set_access_token(auth_data.oauth_token, auth_data.oauth_token_secret)\\n self.response.out.write('<br/>tweeting with oauth:<br/>')\\n api = tweepy.API(auth)\\n self.response.out.write(\\\"id: %d\\\" % c.id)\\n self.response.out.write(\\\"user: %s\\\" % c.user)\\n self.response.out.write(\\\"comment: %s\\\" % c.comment)\\n self.response.out.write(\\\"tweet: %s\\\" % c.tweet)\\n try:\\n api.update_status(c.tweet)\\n except tweepy.error.TweepError, e: \\n self.response.out.write( 'failed: %s' % e.reason )\\n if \\\"Status is a duplicate\\\" in e.reason:\\n c.is_tweeted = True\\n c.put()\\n return\\n else:\\n self.response.out.write('<br/>localhost - nothing actually tweeted:')\\n\\n self.response.out.write('<br/>%s' % c.tweet)\\n\\n c.is_tweeted = True\\n c.put()\",\n \"def send_tweet(self):\\n \\n ## Check the quality/score\\n quality = self.sunsetwx_response['features'][0]['properties']['quality']\\n score = self.sunsetwx_response['features'][0]['properties']['quality_percent']\\n \\n ## For great ones... compose a status\\n if quality == 'Great':\\n \\n local_time_str = self.time_converted.strftime(\\\"%I:%M %p\\\")\\n if self.type == 'sunrise':\\n time_of_day_str = 'tomorrow morning'\\n elif self.type == 'sunset':\\n time_of_day_str = 'this evening'\\n status = f'Looks like there will be a great {self.type} in {self.location} {time_of_day_str}! Check it out at {local_time_str}.'\\n \\n ## Post about the great ones\\n api.update_status(status=status)\\n \\n ## Update the log regardless\\n self.update_log_record(datetime.today().strftime(\\\"%Y-%m-%d\\\"), score)\",\n \"async def twitter(self, ctx, *, emoji: str):\\n await self.get_emoji(ctx, \\\"twitter\\\", emoji)\",\n \"def tweet_results(dl):\\n\\n TWT = twt.get_api()\\n try:\\n if(DEBUG):\\n print(\\\"=====Mock Posting=====\\\")\\n print(MSG.format(ISP, dl, ISP_DL))\\n print(\\\"=====End=====\\\", flush=True)\\n else:\\n TWT.update_status(MSG.format(ISP, dl, ISP_DL))\\n except:\\n print(\\\"error posting to twitter\\\", flush=True)\",\n \"def postTweet(self, userId: int, tweetId: int) -> None:\\n self.timeStamp -= 1\\n self.tweetTimeLine[userId] = self.tweetTimeLine.get(userId, []) + [[self.timeStamp, tweetId]]\",\n \"def tumblrPost(body,tags=None,title=None):\\t\\n\\tglobal settings\\n\\tpost_address = \\\"http://api.tumblr.com/v2/blog/\\\"+settings['blog']+\\\"/post\\\"\\n\\tdata = {\\\"type\\\":\\\"text\\\",\\\"state\\\":settings['state'],\\\"body\\\" : body, \\\"oauth_token\\\":settings['oauth_token']}\\n\\tif tags != None:\\n\\t\\tdata['tags'] = str(tags)\\n\\tif title != None:\\n\\t\\tdata['title'] = str(title)\\n\\tconsumer = oauth.Consumer(settings['consumer_key'], settings['consumer_secret'])\\n\\ttoken = oauth.Token(settings['oauth_token'], settings['oauth_token_secret'])\\n\\tclient = oauth.Client(consumer,token)\\n\\tresp, content = client.request(post_address, \\\"POST\\\", urllib.urlencode(data))\\n\\tjs = json.loads(content)\\n \\tif js['meta']['status'] != 201: #something wrong\\n\\t\\tprint js['meta']['msg']\\n\\t\\tprint js\",\n \"def post_to_telegraph(a_title: str, content: str) -> str:\\n post_client = TelegraphPoster(use_api=True)\\n auth_name = \\\"Leech Zone\\\"\\n post_client.create_api_token(auth_name)\\n post_page = post_client.post(\\n title=a_title,\\n author=auth_name,\\n author_url=\\\"t.me/OtakuTalk\\\",\\n text=content,\\n )\\n return post_page[\\\"url\\\"]\",\n \"def retweet(tweet):\\n\\n twitter.PostRetweet(tweet.id, trim_user=False)\\n\\n return\",\n \"def _connect_twitter_api(self):\\r\\n auth = tweepy.OAuthHandler(CovidBot.CONSUMER_KEY,\\r\\n CovidBot.CONSUMER_SECRET)\\r\\n auth.set_access_token(CovidBot.ACCESS_TOKEN,\\r\\n CovidBot.ACCESS_TOKEN_SECRET)\\r\\n self.api = tweepy.API(auth)\\r\\n logging.info(\\\"Twitter successfully authenticated\\\")\",\n \"def insert_tweet(status):\\n status['replies'] = []\\n return db.tweets.insert(status)\",\n \"def tweet_it(string, credentials, image=None):\\n if len(string) <= 0:\\n return\\n\\n # Create and authorise an app with (read and) write access at:\\n # https://dev.twitter.com/apps/new\\n # Store credentials in YAML file\\n auth = twitter.OAuth(\\n credentials[\\\"access_token\\\"],\\n credentials[\\\"access_token_secret\\\"],\\n credentials[\\\"consumer_key\\\"],\\n credentials[\\\"consumer_secret\\\"],\\n )\\n t = twitter.Twitter(auth=auth)\\n\\n print(\\\"TWEETING THIS:\\\\n\\\" + string)\\n\\n if args.test:\\n print(\\\"(Test mode, not actually tweeting)\\\")\\n else:\\n\\n if image:\\n print(\\\"Upload image\\\")\\n\\n # Send images along with your tweets.\\n # First just read images from the web or from files the regular way\\n with open(image, \\\"rb\\\") as imagefile:\\n imagedata = imagefile.read()\\n t_up = twitter.Twitter(domain=\\\"upload.twitter.com\\\", auth=auth)\\n id_img = t_up.media.upload(media=imagedata)[\\\"media_id_string\\\"]\\n\\n result = t.statuses.update(status=string, media_ids=id_img)\\n else:\\n result = t.statuses.update(status=string)\\n\\n url = (\\n \\\"http://twitter.com/\\\"\\n + result[\\\"user\\\"][\\\"screen_name\\\"]\\n + \\\"/status/\\\"\\n + result[\\\"id_str\\\"]\\n )\\n print(\\\"Tweeted:\\\\n\\\" + url)\\n if not args.no_web:\\n webbrowser.open(url, new=2) # 2 = open in a new tab, if possible\",\n \"def add_tweet_reply(tweet_id, user, text):\\n reply = {'user': user, 'text': text}\\n return db.tweets.update(\\n {'id_str': tweet_id}, {'$push': {'replies': reply}}, True)\",\n \"def publish_twitter(event, event_url):\\n return self.twitter.statuses.update(status='%s: %s' %(event, event_url))\",\n \"def put_tweet(tweet_id):\\n if not request.get_json() or 'tweet' not in request.get_json():\\n raise exceptions.HttpError(message=\\\"No tweet info in body\\\")\\n put_tweet = Tweet(\\n id=tweet_id,\\n name=None,\\n tweet=request.get_json()[\\\"tweet\\\"],\\n created_at=None,\\n type='original'\\n )\\n tweet = Storage.put_tweet(tweet_id, tweet=put_tweet)\\n return jsonify(tweet.to_dict()), 201\",\n \"def twitter(self, twitter):\\n\\n self._twitter = twitter\",\n \"def on_data(self, data):\\n\\n t = json.loads(data) \\n tweet = {\\n 'text': t['text'],\\n 'username': t['user']['screen_name'],\\n 'followers_count': t['user']['followers_count']\\n }\\n\\n logging.critical(f'\\\\n\\\\n\\\\nTWEET INCOMING: {tweet[\\\"text\\\"]}\\\\n\\\\n\\\\n')\\n tweet_collection.insert({'username' : tweet['username'],'followers_count' : tweet['followers_count'], 'text' : tweet['text']})\",\n \"async def meme(self, ctx, subreddit='dankmemes'): #TODO fix gif playback\\n credentials = cfload.configSectionMap(\\\"Reddit API\\\")\\n\\n await ctx.message.add_reaction(\\\"\\\\U0000231B\\\") # hourglass done (not actually done)\\n\\n r = praw.Reddit(client_id=credentials['client_id'],\\n client_secret=credentials['client_secret'],\\n user_agent=credentials['user_agent'],\\n username=credentials['username'],\\n password=credentials['password'])\\n try:\\n sub = r.subreddit(subreddit)\\n if sub.over18:\\n return await ctx.message.add_reaction(\\\"\\\\U0001F6AB\\\") # Prohibited\\n n = 100\\n posts = sub.hot(limit=n)\\n rand = random.randint(0, n)\\n for (i, post) in enumerate(posts): # TODO try random.choice() for the enumeration\\n if i == rand:\\n embed = discord.Embed(\\n title=post.title, #TODO add subreddit link somewhere, maybe use add fields\\n url='http://www.reddit.com' + post.permalink,\\n # description=post.name,\\n colour=discord.Colour(0xe7d066)\\n )\\n if post.url != 'https://www.reddit.com' + post.permalink: # It's an image post\\n embed.set_image(url=post.url)\\n embed.set_author(\\n name='u/' + str(post.author),\\n url='http://www.reddit.com/user/' + str(post.author),\\n icon_url=post.author.icon_img\\n )\\n if post.selftext is not '': #If the post is a text post\\n description = post.selftext[:1021] + '...' if len(post.selftext) > 1024 else post.selftext\\n embed.add_field(\\n name=str(post.score) + ' points',\\n value=description\\n )\\n else: #If the post is a link post\\n embed.add_field(\\n name='Score:',\\n value=post.score,\\n inline=True\\n )\\n embed.add_field(\\n name='Comments:',\\n value=str(len(post.comments)),\\n inline=True\\n )\\n embed.set_footer(\\n text='r/' + str(post.subreddit),\\n icon_url='https://styles.redditmedia.com/t5_6/styles/communityIcon_a8uzjit9bwr21.png'\\n )\\n\\n await ctx.send(embed=embed)\\n\\n except Exception as e:\\n await ctx.message.add_reaction(\\\"\\\\U0000274C\\\") # Cross mark\\n log.error('Exception in /meme:', e)\\n finally:\\n await ctx.message.remove_reaction('\\\\U0000231B', ctx.me)\",\n \"def t_auth():\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, token_secret)\\n return tweepy.API(auth)\",\n \"def like_tweet(self, tag):\\n self.bot.get('https://twitter.com/search?q=' + tag + '&src=typed')\\n self.__wait(3, 3)\\n for i in range(1, 3):\\n self.bot.execute_script('window.scrollTo(0,document.body.scrollHeight)')\\n self.__wait(2, 3)\\n tweets = self.bot.find_elements_by_tag_name('article')\\n\\n links = []\\n for tweet in tweets:\\n sub_links = tweet.find_elements_by_tag_name('a')\\n links += [sub_link.get_attribute('href')\\n for sub_link in sub_links if 'status' in sub_link.get_attribute('href')]\\n\\n print('Started to like {} tweets'.format(len(links)))\\n\\n for link in links:\\n self.bot.get(link)\\n self.__wait(3, 5)\\n likes = self.bot.find_elements_by_css_selector('div[data-testid=\\\"like\\\"')\\n for like in likes:\\n like.click()\\n self.__wait(3, 5)\",\n \"def send_fixtures_tweets(tweet1, tweet2, tweet3):\\n\\n # Authorises Twitter API connection\\n api = twitter_auth()\\n\\n # Checks if tweet has already been made today\\n get_tweet = api.user_timeline(count=1,tweet_mode=\\\"extended\\\")\\n last_tweet = get_tweet[0].full_text\\n tweet = tweet1[:-1]\\n if last_tweet == tweet:\\n return print('Tweet already sent')\\n \\n # Sends tweets to timeline, depending on how many tweets created\\n # Multiple tweets sent as a thread by responding to previous tweet\\n if tweet3:\\n first_tweet = api.update_status(tweet1)\\n first_id = first_tweet.id\\n second_tweet = api.update_status(tweet2, first_id)\\n second_id = second_tweet.id\\n api.update_status(tweet3, second_id)\\n return print('Successfully sent tweet(s)')\\n elif tweet2:\\n first_tweet = api.update_status(tweet1)\\n first_id = first_tweet.id\\n api.update_status(tweet2, first_id)\\n return print('Successfully sent tweet(s)')\\n else:\\n api.update_status(tweet1)\\n return print('Successfully sent tweet(s)')\",\n \"def postTweet(self, userId, tweetId):\\n if userId not in self.user_tweets:\\n self.user_tweets[userId] = []\\n \\n self.user_tweets[userId].insert(0, (tweetId, self.buildSortId()))\\n self.user_tweets[userId] = self.user_tweets[userId][:10]\",\n \"def like_post(self,id):\\n try:\\n data = self.api.create_favorite(id)\\n if isinstance(data,tweepy.models.Status):\\n if hasattr(data,'_json'): \\n return json.dumps(data._json)\\n except tweepy.error.TweepError as e:\\n print(e.__dict__)\\n if e.__dict__['api_code']==139:\\n data = unlike_post(id)\\n return data\",\n \"def handler(event, context):\\n send_tweet(random.choice(potential_tweets))\",\n \"def handler(event, context):\\n send_tweet(random.choice(potential_tweets))\",\n \"def tweet(self, tweet, at=None):\\n if tweet.strip() == \\\"\\\":\\n return\\n\\n num_tweets, tweets = self._divide_tweet(tweet, at)\\n if num_tweets > 0:\\n # replace @'s with #'s and convert unicode emojis before tweeting\\n [self.api.update_status(tw.replace(\\\"@\\\", \\\"#\\\").encode(\\\"utf-8\\\")) for tw in tweets]\\n self.log(f\\\"Tweeted: {' '.join(tweets)}\\\")\\n return tweets[0]\",\n \"async def post_do_action(post, action, curator, reaction):\\n try:\\n authorperm = construct_authorperm(post[\\\"author\\\"], post[\\\"permlink\\\"])\\n link = \\\"https://steemit.com/\\\"+authorperm\\n if post[\\\"author\\\"] in blacklist:\\n await loop.create_task(send_discord(\\\"WARNING: Author is blacklisted \\\"+link, logchannel))\\n return\\n elif action == \\\"tf100\\\":\\n try:\\n post.upvote(weight=100, voter=postaccount)\\n await loop.create_task(send_discord(link, upvotechannel))\\n continent_code = get_location(post['body'], \\\"continentcode\\\")\\n if continent_code == \\\"AF\\\" or continent_code == \\\"OC\\\" or continent_code == \\\"AN\\\":\\n await loop.create_task(send_discord(link, australiaoceaniaafrica))\\n elif continent_code == \\\"AS\\\":\\n await loop.create_task(send_discord(link, asia))\\n elif continent_code == \\\"EU\\\":\\n await loop.create_task(send_discord(link, europe))\\n elif continent_code == \\\"SA\\\" or continent_code == \\\"NA\\\":\\n await loop.create_task(send_discord(link, america))\\n elif \\\"food\\\" in post['body'] or \\\" eat\\\" in post['body'] or \\\"restaurant\\\" in post['body']:\\n await loop.create_task(send_discord(link, foodoftheworld))\\n elif \\\"advice\\\" in post['body'] or \\\"budget\\\" in post['body'] or \\\"learn\\\" in post['body']:\\n await loop.create_task(send_discord(link, traveladvice))\\n else:\\n await loop.create_task(send_discord(link, nocategory))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆙\\\")\\n except Exception as error:\\n if not \\\"skip_transaction_dupe_check\\\" in repr(error):\\n logger.warning(\\\"Could not vote with 100%\\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not vote with 100% on \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n return\\n await asyncio.sleep(4)\\n try:\\n post.resteem(identifier=authorperm, account=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🔄\\\")\\n except Exception as error:\\n logger.warning(\\\"Could not resteem post \\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not resteem \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n await asyncio.sleep(4)\\n try:\\n post.reply(resteemtext.format(curator), author=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🔤\\\")\\n except Exception as error:\\n logger.warning(\\\"Could not comment on resteem post \\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not comment on resteem post \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n elif action == \\\"tf50\\\":\\n try:\\n post.upvote(weight=50, voter=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆗\\\")\\n await loop.create_task(send_discord(link, honourchannel))\\n except Exception as error:\\n logger.warning(\\\"Could not vote with 50%\\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not vote with 50% on \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n return\\n await asyncio.sleep(4)\\n try:\\n post.reply(honourtext.format(curator), author=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🔤\\\")\\n except Exception as error:\\n logger.warning(\\\"Could not comment on honour post \\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not comment on honour post \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n elif action == \\\"coop100\\\":\\n try:\\n post.upvote(weight=100, voter=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🚻\\\")\\n except Exception as error:\\n logger.warning(\\\"Could not vote with 100% on cooperation post \\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not vote with 100% on cooperation post \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n return\\n elif action == \\\"ad10\\\":\\n try:\\n post.upvote(weight=10, voter=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🔟\\\")\\n except Exception as error:\\n logger.warning(\\\"Could not vote on ad post \\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not vote with 10% on ad post \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n return\\n await asyncio.sleep(4)\\n try:\\n post.reply(advotetext.format(curator), author=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🔤\\\")\\n except Exception as error:\\n logger.warning(\\\"Could not comment on ad post \\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not comment on ad post \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n elif action == \\\"short0\\\":\\n try: \\n post.reply(manualshorttext.format(post[\\\"author\\\"]), author=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🔤\\\")\\n except Exception as error:\\n logger.warning(\\\"Could not comment on short post \\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not comment on short post \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n elif action == \\\"lang0\\\":\\n try: \\n post.reply(manuallangtext.format(post[\\\"author\\\"]), author=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🔤\\\")\\n except Exception as error:\\n logger.warning(\\\"Could not comment on non-English post \\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not comment on non-English post \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n elif action == \\\"copyright0\\\":\\n try: \\n post.reply(copyrighttext.format(post[\\\"author\\\"]), author=postaccount)\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🔤\\\")\\n except Exception as error:\\n logger.warning(\\\"Could not comment on copyright post \\\"+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not comment on copyright post \\\"+link+\\\" Exception: \\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\\n if not reaction == None:\\n try:\\n await bot.remove_reaction(reaction, \\\"⏳\\\", bot.user)\\n except Exception as error:\\n logger.warning(\\\"Could not remove hourglass reaction\\\"+repr(error))\\n await asyncio.sleep(3)\\n except Exception as error:\\n logger.warning(\\\"Could not execute action for post \\\"+str(post)+repr(error))\\n try:\\n await loop.create_task(send_discord(\\\"Could not execute action on post \\\"+str(post)+\\\" Exception:\\\"+repr(error), logchannel))\\n if not reaction == None:\\n await bot.add_reaction(reaction, \\\"🆘\\\")\\n except:\\n logger.warning(\\\"Could not send message to Discord\\\")\",\n \"def handler(event,context):\\n send_tweet(random.choice(potential_tweets))\",\n \"def post(owner_id=None, friends_only=None, from_group=None, message=None,\\\\\\n attachments=None, services=None, signed=None, publish_date=None,\\\\\\n lat=None, long=None, place_id=None, post_id=None, guid=None, mark_as_ads=None):\\n params = {\\n 'owner_id': owner_id,\\n 'friends_only': friends_only,\\n 'from_group': from_group,\\n 'message': message,\\n 'attachments': attachments,\\n 'services': services,\\n 'signed': signed,\\n 'publish_date': publish_date,\\n 'lat': lat,\\n 'long': long,\\n 'place_id': place_id,\\n 'post_id': post_id,\\n 'guid': guid,\\n 'mark_as_ads': mark_as_ads\\n }\\n result = call('wall.post', **params)\\n return parse_response(result)\",\n \"def twitter_post_status():\\n # Can be overriden in GET request\\n question_cadence_minutes = \\\\\\n int(request.args.get('question_cadence_minutes', 60 * 6))\\n post_to_twitter = request.args.get('post_to_twitter', False)\\n \\n next_question = Question.get_next_question()\\n if next_question is not None \\\\\\n and __is_time_for_new_question(question_cadence_minutes):\\n current_question = Question.get_current_question()\\n \\n if post_to_twitter != False:\\n try:\\n twitter_api = TwitterAPI()\\n status = twitter_api.update_status(next_question.question_text)\\n next_question.twitterid = str(status.id)\\n next_question.put()\\n except TweepError as e:\\n pass #TODO: do something - message to monitoring?\\n\\n if current_question is not None:\\n # Update overall state scores\\n State.update_state_scores_for_completed_question(current_question)\\n \\n # Update overall question scores\\n Question.tally_college_and_vote_scores(current_question)\\n\\n # Update end of question user sway scores\\n users = User.get_all()\\n for user in users:\\n __attribute_sway_points_for_user(current_question, user)\\n current_question.end_time = datetime.datetime.now()\\n current_question.put()\\n \\n next_question.start_time = datetime.datetime.now()\\n next_question.put()\\n\\n return 'Posted new status [%s]' % next_question.question_text, 200\\n\\n return 'New question not ready', 200\",\n \"def add_tweet(self, tweet):\\r\\n self.tweets.append(tweet)\",\n \"def retweet(tweet_id):\\n r = requests.post(twitter_api_base + \\\"/statuses/retweet/\\\" +\\n tweet_id + \\\".json\\\",\\n auth=oauth_credentials)\\n if r.status_code != 200:\\n print(\\\"Attempted to retweet tweet %s\\\" % tweet_id)\\n received_error(r)\\n else:\\n print(\\\"Successfully retweeted tweet %s.\\\" % tweet_id)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7384305","0.73712504","0.697456","0.6869901","0.6778252","0.6729129","0.6716007","0.670674","0.6551957","0.65180176","0.6512323","0.6452721","0.643159","0.641381","0.63216686","0.6315954","0.6310251","0.629947","0.6298899","0.6287242","0.6287242","0.6287242","0.62863624","0.6283822","0.6236139","0.6226788","0.62011003","0.61905867","0.61902094","0.6189605","0.6152396","0.6136027","0.61254704","0.6122172","0.6096267","0.6089115","0.6073876","0.6073036","0.60645044","0.6053261","0.6042424","0.60286945","0.60209644","0.60107595","0.5979969","0.5973544","0.5961225","0.595949","0.5933321","0.5920473","0.59176534","0.5913861","0.5913745","0.5889962","0.5888236","0.5883279","0.58789396","0.58763826","0.58651","0.58480036","0.58318955","0.58009595","0.5789073","0.57694817","0.57600987","0.57580477","0.5748202","0.5712139","0.5680894","0.56572336","0.5635731","0.5632974","0.5627755","0.5624875","0.56217027","0.5621564","0.55941856","0.55885524","0.55533445","0.5547723","0.5540609","0.5534709","0.5533108","0.55264926","0.5522672","0.5521101","0.55155814","0.54870343","0.54846627","0.5483669","0.54745764","0.5461638","0.5461638","0.54584527","0.54555535","0.54526854","0.5440905","0.5435158","0.5414757","0.5412116"],"string":"[\n \"0.7384305\",\n \"0.73712504\",\n \"0.697456\",\n \"0.6869901\",\n \"0.6778252\",\n \"0.6729129\",\n \"0.6716007\",\n \"0.670674\",\n \"0.6551957\",\n \"0.65180176\",\n \"0.6512323\",\n \"0.6452721\",\n \"0.643159\",\n \"0.641381\",\n \"0.63216686\",\n \"0.6315954\",\n \"0.6310251\",\n \"0.629947\",\n \"0.6298899\",\n \"0.6287242\",\n \"0.6287242\",\n \"0.6287242\",\n \"0.62863624\",\n \"0.6283822\",\n \"0.6236139\",\n \"0.6226788\",\n \"0.62011003\",\n \"0.61905867\",\n \"0.61902094\",\n \"0.6189605\",\n \"0.6152396\",\n \"0.6136027\",\n \"0.61254704\",\n \"0.6122172\",\n \"0.6096267\",\n \"0.6089115\",\n \"0.6073876\",\n \"0.6073036\",\n \"0.60645044\",\n \"0.6053261\",\n \"0.6042424\",\n \"0.60286945\",\n \"0.60209644\",\n \"0.60107595\",\n \"0.5979969\",\n \"0.5973544\",\n \"0.5961225\",\n \"0.595949\",\n \"0.5933321\",\n \"0.5920473\",\n \"0.59176534\",\n \"0.5913861\",\n \"0.5913745\",\n \"0.5889962\",\n \"0.5888236\",\n \"0.5883279\",\n \"0.58789396\",\n \"0.58763826\",\n \"0.58651\",\n \"0.58480036\",\n \"0.58318955\",\n \"0.58009595\",\n \"0.5789073\",\n \"0.57694817\",\n \"0.57600987\",\n \"0.57580477\",\n \"0.5748202\",\n \"0.5712139\",\n \"0.5680894\",\n \"0.56572336\",\n \"0.5635731\",\n \"0.5632974\",\n \"0.5627755\",\n \"0.5624875\",\n \"0.56217027\",\n \"0.5621564\",\n \"0.55941856\",\n \"0.55885524\",\n \"0.55533445\",\n \"0.5547723\",\n \"0.5540609\",\n \"0.5534709\",\n \"0.5533108\",\n \"0.55264926\",\n \"0.5522672\",\n \"0.5521101\",\n \"0.55155814\",\n \"0.54870343\",\n \"0.54846627\",\n \"0.5483669\",\n \"0.54745764\",\n \"0.5461638\",\n \"0.5461638\",\n \"0.54584527\",\n \"0.54555535\",\n \"0.54526854\",\n \"0.5440905\",\n \"0.5435158\",\n \"0.5414757\",\n \"0.5412116\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.687649"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":25996,"cells":{"query":{"kind":"string","value":"The name of this component."},"document":{"kind":"string","value":"def name(self):\n return \"component_manager\""},"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_component_name(self):\n return self._name","def name(self):\r\n return self.component.get(\"Name\", \"\")","def name(self):\r\n return self.component.get(\"Name\", \"\")","def get_name(self):\n return COMPONENT_LIST[self.index][0]","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\r\n return self._name","def name(self) -> str:\r\n return self._name","def name(self) -> str:\r\n return self._name","def name(self) -> str:\r\n return self._name","def name(self):\n return self.NAME","def get_name(self):\r\n return self.__name","def get_name(self):\r\n return self.__name","def get_name(self):\r\n return self.__name","def get_name(self):\r\n return self.__name","def get_name(self):\n return self.__name","def get_name(self):\n return self.__name","def get_name(self):\n return self.__name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def name(self) -> str:\n return self._name","def get_name(self):\n\n\t\treturn self.__name","def name ( self ) :\n return self.__name if self.__name else ''","def name (self):\n return self._name","def get_name(self):\n\t\treturn self.__name","def name(self):\n return str(self.name)","def name(self) -> str:\n pass","def name(self) -> str:\n pass","def name(self) -> str:\n pass","def name(self) -> str:\n pass","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name"],"string":"[\n \"def get_component_name(self):\\n return self._name\",\n \"def name(self):\\r\\n return self.component.get(\\\"Name\\\", \\\"\\\")\",\n \"def name(self):\\r\\n return self.component.get(\\\"Name\\\", \\\"\\\")\",\n \"def get_name(self):\\n return COMPONENT_LIST[self.index][0]\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\r\\n return self._name\",\n \"def name(self) -> str:\\r\\n return self._name\",\n \"def name(self) -> str:\\r\\n return self._name\",\n \"def name(self) -> str:\\r\\n return self._name\",\n \"def name(self):\\n return self.NAME\",\n \"def get_name(self):\\r\\n return self.__name\",\n \"def get_name(self):\\r\\n return self.__name\",\n \"def get_name(self):\\r\\n return self.__name\",\n \"def get_name(self):\\r\\n return self.__name\",\n \"def get_name(self):\\n return self.__name\",\n \"def get_name(self):\\n return self.__name\",\n \"def get_name(self):\\n return self.__name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def name(self) -> str:\\n return self._name\",\n \"def get_name(self):\\n\\n\\t\\treturn self.__name\",\n \"def name ( self ) :\\n return self.__name if self.__name else ''\",\n \"def name (self):\\n return self._name\",\n \"def get_name(self):\\n\\t\\treturn self.__name\",\n \"def name(self):\\n return str(self.name)\",\n \"def name(self) -> str:\\n pass\",\n \"def name(self) -> str:\\n pass\",\n \"def name(self) -> str:\\n pass\",\n \"def name(self) -> str:\\n pass\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.9065345","0.897935","0.897935","0.8652009","0.8357189","0.8357189","0.8357189","0.8357189","0.8357189","0.8357189","0.8357189","0.8357189","0.8357189","0.8357189","0.83296686","0.83296686","0.83296686","0.83296686","0.83296686","0.83296686","0.83296686","0.8306327","0.8306327","0.8306327","0.8306327","0.82921344","0.82808936","0.82808936","0.82808936","0.82808936","0.82769406","0.82769406","0.82769406","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.827214","0.8271397","0.8268488","0.8264404","0.8240844","0.8240318","0.82206786","0.82206786","0.82206786","0.82206786","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914","0.8209914"],"string":"[\n \"0.9065345\",\n \"0.897935\",\n \"0.897935\",\n \"0.8652009\",\n \"0.8357189\",\n \"0.8357189\",\n \"0.8357189\",\n \"0.8357189\",\n \"0.8357189\",\n \"0.8357189\",\n \"0.8357189\",\n \"0.8357189\",\n \"0.8357189\",\n \"0.8357189\",\n \"0.83296686\",\n \"0.83296686\",\n \"0.83296686\",\n \"0.83296686\",\n \"0.83296686\",\n \"0.83296686\",\n \"0.83296686\",\n \"0.8306327\",\n \"0.8306327\",\n \"0.8306327\",\n \"0.8306327\",\n \"0.82921344\",\n \"0.82808936\",\n \"0.82808936\",\n \"0.82808936\",\n \"0.82808936\",\n \"0.82769406\",\n \"0.82769406\",\n \"0.82769406\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.827214\",\n \"0.8271397\",\n \"0.8268488\",\n \"0.8264404\",\n \"0.8240844\",\n \"0.8240318\",\n \"0.82206786\",\n \"0.82206786\",\n \"0.82206786\",\n \"0.82206786\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\",\n \"0.8209914\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":25997,"cells":{"query":{"kind":"string","value":"Called by the simulation context."},"document":{"kind":"string","value":"def setup(self, configuration, lifecycle_manager):\n self.configuration = configuration\n self.lifecycle = lifecycle_manager\n\n self.lifecycle.add_constraint(\n self.get_components_by_type,\n restrict_during=[\"initialization\", \"population_creation\"],\n )\n self.lifecycle.add_constraint(\n self.get_component, restrict_during=[\"population_creation\"]\n )\n self.lifecycle.add_constraint(\n self.list_components, restrict_during=[\"initialization\"]\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 run(self):\n\t\t\n\t\tpass","def run(self): \r\n return","def make_simulation(self):\n pass","def run(self):\r\n pass","def RUN(self):","def postRun(self):\n pass","def _setup_simulation(self\n ) -> None:\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def perform(self):\n pass","def startSimulation(self):\n self.saveParameters()\n self.simulation.main()","def _run(self):\n raise NotImplementedError","def _run(self):\n raise NotImplementedError","def run(self):\n \n pass","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def process(self):\n pass","def post_execute(self):","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError # implement in subclass","def finished_sim(self):\n raise NotImplementedError(\n \"finished_sim function not reimplemented form base class\")","def proceed(self):\n pass","def process(self):","def process(self):","def process(self):","def perform(self):\n return","def perform(self):\n return","def initialise_sim(self):\n pass","def processing(self):\n pass","def run(self):\n raise NotImplementedError()","def run(self):\n raise NotImplementedError()","def perform(self):\n raise NotImplementedError","def run(self) -> None:\n log.critical('Not implemented')","def step(self):\n\n pass","def __call__( self ):\n pass","def on_run(self):\r\n\r\n\t\tpass","def __call__(self):\n\t\treturn","def _proceed(self):\n raise NotImplementedError","def execute(self):\n\t\tpass","def post_start(self):","def Start(self) :\n\t\t...","def fire(self):","def Run():\r\n pass","def run_simulation(self):\n self.market.market_session(True)\n return \"\"","def think(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def run(self):\n raise NotImplementedError(\"Subclasses mut override run()\")","def run_game_logic(self):\n pass","def Main():\n EnigmaSim = simulation() #Creates the simulation object\n EnigmaSim.Run() #Runs the simulation","def trial(self):\n pass","def _exe_(self):\n print(\"\\n Start simulation (using Pharlap) ...\")\n dic = \"data/sim/{dn}/{rad}/\".format(dn=self.event.strftime(\"%Y.%m.%d.%H.%M\"), rad=self.rad)\n self._copy_ne_()\n [self._compute_(case) for case in [\"bgc\", \"flare\"]]\n plotlib.plot_exp_rays(dic, self.event, self.bmnum, \"bgc\")\n plotlib.plot_exp_rays(dic, self.event, self.bmnum, \"flare\")\n self._compute_doppler_()\n rec = self._compute_velocity_()\n return rec","def fire(self):\n pass","def getSimulation(self):\r\n raise NotImplementedError()","def _step(self):\n pass","def pre_execute(self):","def execute(self):\r\n pass","def started(self):","def act(self):\n pass","def _exe_(self):\n print(\"\\n Start simulation (using Pharlap) ...\")\n dic = \"data/sim/{dn}/{rad}/\".format(dn=self.event.strftime(\"%Y.%m.%d.%H.%M\"), rad=self.rad)\n self._estimate_edens_()\n self._compute_()\n plotlib.plot_exp_rays(dic, self.event, self.bmnum, \"bgc\")\n plotlib.plot_exp_rays(dic, self.event, self.bmnum, \"flare\")\n if self.verbose: print(\"\\n Processing Doppler.\")\n self._compute_doppler_()\n rec = self._compute_velocity_()\n return rec","def run(self):\n raise NotImplementedError('Run method not implemented in %s' % type(self).__name__)","def execute(self):","def execute(self):","def execute(self):","def execute(self):","def run(self):\n self.tcex.log.trace('run')","def use(self):","def initialize_simulation(self) -> Simulation:\n pass","def step(self): \n self.reset_parameters()\n\n if np.random.uniform(0, 1) < self.model.churn_prob: self.exit_triggered = True \n if self.exit_triggered:\n self.exit()\n else:\n self.register_deposit(self.deposit_intent)\n self.register_contribution(self.contribution_intent)\n self.register_sponsorship(self.sponsor_intent)\n self.register_euro_exchange(self.euro_exchange_intent)\n self.register_teo_exchange(self.teo_exchange_intent)\n self.register_withdraw(self.withdraw_intent)"],"string":"[\n \"def run(self):\\n\\t\\t\\n\\t\\tpass\",\n \"def run(self): \\r\\n return\",\n \"def make_simulation(self):\\n pass\",\n \"def run(self):\\r\\n pass\",\n \"def RUN(self):\",\n \"def postRun(self):\\n pass\",\n \"def _setup_simulation(self\\n ) -> None:\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def perform(self):\\n pass\",\n \"def startSimulation(self):\\n self.saveParameters()\\n self.simulation.main()\",\n \"def _run(self):\\n raise NotImplementedError\",\n \"def _run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n \\n pass\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def process(self):\\n pass\",\n \"def post_execute(self):\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError # implement in subclass\",\n \"def finished_sim(self):\\n raise NotImplementedError(\\n \\\"finished_sim function not reimplemented form base class\\\")\",\n \"def proceed(self):\\n pass\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def perform(self):\\n return\",\n \"def perform(self):\\n return\",\n \"def initialise_sim(self):\\n pass\",\n \"def processing(self):\\n pass\",\n \"def run(self):\\n raise NotImplementedError()\",\n \"def run(self):\\n raise NotImplementedError()\",\n \"def perform(self):\\n raise NotImplementedError\",\n \"def run(self) -> None:\\n log.critical('Not implemented')\",\n \"def step(self):\\n\\n pass\",\n \"def __call__( self ):\\n pass\",\n \"def on_run(self):\\r\\n\\r\\n\\t\\tpass\",\n \"def __call__(self):\\n\\t\\treturn\",\n \"def _proceed(self):\\n raise NotImplementedError\",\n \"def execute(self):\\n\\t\\tpass\",\n \"def post_start(self):\",\n \"def Start(self) :\\n\\t\\t...\",\n \"def fire(self):\",\n \"def Run():\\r\\n pass\",\n \"def run_simulation(self):\\n self.market.market_session(True)\\n return \\\"\\\"\",\n \"def think(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def run(self):\\n raise NotImplementedError(\\\"Subclasses mut override run()\\\")\",\n \"def run_game_logic(self):\\n pass\",\n \"def Main():\\n EnigmaSim = simulation() #Creates the simulation object\\n EnigmaSim.Run() #Runs the simulation\",\n \"def trial(self):\\n pass\",\n \"def _exe_(self):\\n print(\\\"\\\\n Start simulation (using Pharlap) ...\\\")\\n dic = \\\"data/sim/{dn}/{rad}/\\\".format(dn=self.event.strftime(\\\"%Y.%m.%d.%H.%M\\\"), rad=self.rad)\\n self._copy_ne_()\\n [self._compute_(case) for case in [\\\"bgc\\\", \\\"flare\\\"]]\\n plotlib.plot_exp_rays(dic, self.event, self.bmnum, \\\"bgc\\\")\\n plotlib.plot_exp_rays(dic, self.event, self.bmnum, \\\"flare\\\")\\n self._compute_doppler_()\\n rec = self._compute_velocity_()\\n return rec\",\n \"def fire(self):\\n pass\",\n \"def getSimulation(self):\\r\\n raise NotImplementedError()\",\n \"def _step(self):\\n pass\",\n \"def pre_execute(self):\",\n \"def execute(self):\\r\\n pass\",\n \"def started(self):\",\n \"def act(self):\\n pass\",\n \"def _exe_(self):\\n print(\\\"\\\\n Start simulation (using Pharlap) ...\\\")\\n dic = \\\"data/sim/{dn}/{rad}/\\\".format(dn=self.event.strftime(\\\"%Y.%m.%d.%H.%M\\\"), rad=self.rad)\\n self._estimate_edens_()\\n self._compute_()\\n plotlib.plot_exp_rays(dic, self.event, self.bmnum, \\\"bgc\\\")\\n plotlib.plot_exp_rays(dic, self.event, self.bmnum, \\\"flare\\\")\\n if self.verbose: print(\\\"\\\\n Processing Doppler.\\\")\\n self._compute_doppler_()\\n rec = self._compute_velocity_()\\n return rec\",\n \"def run(self):\\n raise NotImplementedError('Run method not implemented in %s' % type(self).__name__)\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def run(self):\\n self.tcex.log.trace('run')\",\n \"def use(self):\",\n \"def initialize_simulation(self) -> Simulation:\\n pass\",\n \"def step(self): \\n self.reset_parameters()\\n\\n if np.random.uniform(0, 1) < self.model.churn_prob: self.exit_triggered = True \\n if self.exit_triggered:\\n self.exit()\\n else:\\n self.register_deposit(self.deposit_intent)\\n self.register_contribution(self.contribution_intent)\\n self.register_sponsorship(self.sponsor_intent)\\n self.register_euro_exchange(self.euro_exchange_intent)\\n self.register_teo_exchange(self.teo_exchange_intent)\\n self.register_withdraw(self.withdraw_intent)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70393395","0.69843966","0.69002396","0.68817323","0.67909","0.67798424","0.67723346","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.6762831","0.67441726","0.6702614","0.66251457","0.66251457","0.66178966","0.6604684","0.6604684","0.6604684","0.6604684","0.6604684","0.6604684","0.6604684","0.6604684","0.6604684","0.6604684","0.65901923","0.6536314","0.65114385","0.65114385","0.65114385","0.65114385","0.65114385","0.65114385","0.65114385","0.65114385","0.65114385","0.64300895","0.6382923","0.63742626","0.63703614","0.63703614","0.63703614","0.6360032","0.6360032","0.6337636","0.63368356","0.633321","0.633321","0.63002414","0.6286515","0.6285259","0.6284619","0.62738705","0.6241274","0.62375134","0.6225843","0.6209771","0.62041324","0.6201131","0.61939645","0.61931366","0.6181467","0.61805254","0.61805254","0.61805254","0.61805254","0.61805254","0.61739045","0.61695266","0.61626786","0.61593324","0.6159199","0.61352915","0.6134961","0.61336535","0.6131658","0.61153823","0.61120695","0.60842186","0.60762656","0.6066801","0.6063635","0.6063635","0.6063635","0.6063635","0.6061727","0.6061399","0.6058215","0.60506344"],"string":"[\n \"0.70393395\",\n \"0.69843966\",\n \"0.69002396\",\n \"0.68817323\",\n \"0.67909\",\n \"0.67798424\",\n \"0.67723346\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.6762831\",\n \"0.67441726\",\n \"0.6702614\",\n \"0.66251457\",\n \"0.66251457\",\n \"0.66178966\",\n \"0.6604684\",\n \"0.6604684\",\n \"0.6604684\",\n \"0.6604684\",\n \"0.6604684\",\n \"0.6604684\",\n \"0.6604684\",\n \"0.6604684\",\n \"0.6604684\",\n \"0.6604684\",\n \"0.65901923\",\n \"0.6536314\",\n \"0.65114385\",\n \"0.65114385\",\n \"0.65114385\",\n \"0.65114385\",\n \"0.65114385\",\n \"0.65114385\",\n \"0.65114385\",\n \"0.65114385\",\n \"0.65114385\",\n \"0.64300895\",\n \"0.6382923\",\n \"0.63742626\",\n \"0.63703614\",\n \"0.63703614\",\n \"0.63703614\",\n \"0.6360032\",\n \"0.6360032\",\n \"0.6337636\",\n \"0.63368356\",\n \"0.633321\",\n \"0.633321\",\n \"0.63002414\",\n \"0.6286515\",\n \"0.6285259\",\n \"0.6284619\",\n \"0.62738705\",\n \"0.6241274\",\n \"0.62375134\",\n \"0.6225843\",\n \"0.6209771\",\n \"0.62041324\",\n \"0.6201131\",\n \"0.61939645\",\n \"0.61931366\",\n \"0.6181467\",\n \"0.61805254\",\n \"0.61805254\",\n \"0.61805254\",\n \"0.61805254\",\n \"0.61805254\",\n \"0.61739045\",\n \"0.61695266\",\n \"0.61626786\",\n \"0.61593324\",\n \"0.6159199\",\n \"0.61352915\",\n \"0.6134961\",\n \"0.61336535\",\n \"0.6131658\",\n \"0.61153823\",\n \"0.61120695\",\n \"0.60842186\",\n \"0.60762656\",\n \"0.6066801\",\n \"0.6063635\",\n \"0.6063635\",\n \"0.6063635\",\n \"0.6063635\",\n \"0.6061727\",\n \"0.6061399\",\n \"0.6058215\",\n \"0.60506344\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":25998,"cells":{"query":{"kind":"string","value":"Registers new managers with the component manager. Managers are configured and setup before components."},"document":{"kind":"string","value":"def add_managers(self, managers: Union[List[Any], Tuple[Any]]):\n for m in self._flatten(managers):\n self.apply_configuration_defaults(m)\n self._managers.add(m)"},"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 setup_manager(self) -> None:\n\n #Clean out the process list.\n self.process_list.clear()\n for _ in range(self.num_processes):\n p = Process(target=self.multiprocessing_job,\n args=(self.process_job,))\n self.process_list.append(p)\n self.restart_required = False","def add_manager(self, agent):\n with self.simulation_mutex:\n self.get(\"manager_agents\")[agent.name] = agent","def setup(self, manager):\n self._manager = manager\n self._configured = True","def _configure_manager(self):\n self._manager = CloudDatabaseManager(self,\n resource_class=CloudDatabaseInstance, response_key=\"instance\",\n uri_base=\"instances\")\n self._flavor_manager = BaseManager(self,\n resource_class=CloudDatabaseFlavor, response_key=\"flavor\",\n uri_base=\"flavors\")\n self._backup_manager = CloudDatabaseBackupManager(self,\n resource_class=CloudDatabaseBackup, response_key=\"backup\",\n uri_base=\"backups\")","def SetManager(self, mgr):\r\n\r\n self.manager = mgr","def register_manager(self, update, context):\r\n new_manager_chat_id = update['message']['chat']['id']\r\n new_manager_name = update['message']['chat']['first_name']\r\n\r\n with open('managers.json') as obj:\r\n managers = json.load(obj)\r\n\r\n managers[new_manager_name] = new_manager_chat_id\r\n\r\n with open('managers.json', 'w') as obj:\r\n json.dump(managers, obj)\r\n\r\n context.bot.send_message(chat_id=update.message.chat_id, text=f'{new_manager_name} - {new_manager_chat_id}')","def setManager(self, manager=None):\n self._manager = manager","def register(self, events=[]):\n self.events = events\n if not self in manager.handler:\n manager.handler.append(self)","def setup_components(self, builder: \"Builder\"):\n self._setup_components(builder, self._managers + self._components)","def install_providers():\n host = env.host_string\n providers = get_providers(host)\n for provider in providers.values():\n if getattr(provider, 'manager', None) is not None:\n provider.manager.install()\n\n provider.install()","def startManager(self):\n\t\tlogging.info(\"----->>>The DeviceDataManager will be started\")\n\t\tself.sysPerfManager.startManager()\n\t\tself.sensorAdapterManager.startManager()\n\t\tif self.enableRedis:\n\t\t\tself.redisClient.connectClient()\n\t\t\n\t\tif self.enableMqtt:\n\t\t\tself.mqttClient.connectClient()","def set_up():\n ResourcesManager().set_up()\n LocatorUtil().load_locators()","def _init_pluginmanager(self):\n self.pluginmanager = PluginManager(logger=self.logger)\n self.logger.debug(\"Registering execution wide plugins:\")\n self.pluginmanager.load_default_run_plugins()\n self.pluginmanager.load_custom_run_plugins(self.args.plugin_path)\n self.logger.debug(\"Execution wide plugins loaded and registered.\")","def _setManager(self, mgr: \"StrategyManager\") -> None:","def getPackageManager(self) -> None:\n\t\tfor pkgmgr in config.SUPPORTED_PACKAGE_MGRS:\n\t\t\tif subprocess.run([\"which\", pkgmgr]).returncode == 0:\n\t\t\t\tself.package_manager = pkgmgr\n\t\t\t\treturn\n\t\tlogger.error(\"Supported package manager not found, aborting.\")\n\t\traise ValueError(\"Package manager unsupported\")","def RegisterParsers(cls, parser_classes):\n for parser_class in parser_classes:\n cls.RegisterParser(parser_class)","def configure_node_managers(config):\n host_names = get_compute_node_host_names(config)\n sysctl_settings = unflatten_dict_keys(config, 'sysctl_(.*)')\n sys_settings = unflatten_dict_keys(config, '(/sys/.*)')\n pjobs = [delayed(configure_node_manager)(host_name, sysctl_settings, sys_settings, config.get('transparent_hugepage_enabled')) for host_name in host_names]\n Parallel(n_jobs=len(pjobs))(pjobs)","def _configure_managers() -> Tuple[tff.simulation.FileCheckpointManager,\n List[tff.simulation.MetricsManager]]:\n root_output_dir = FLAGS.root_output_dir\n experiment_name = FLAGS.experiment_name\n utils_impl.create_directory_if_not_exists(root_output_dir)\n\n checkpoint_dir = os.path.join(root_output_dir, 'checkpoints', experiment_name)\n utils_impl.create_directory_if_not_exists(checkpoint_dir)\n checkpoint_manager = tff.simulation.FileCheckpointManager(\n checkpoint_dir, step=FLAGS.rounds_per_checkpoint)\n\n results_dir = os.path.join(root_output_dir, 'results', experiment_name)\n utils_impl.create_directory_if_not_exists(results_dir)\n csv_file = os.path.join(results_dir, 'experiment.metrics.csv')\n csv_manager = tff.simulation.CSVMetricsManager(csv_file)\n\n summary_dir = os.path.join(root_output_dir, 'logdir', experiment_name)\n tensorboard_manager = tff.simulation.TensorBoardManager(summary_dir)\n\n logging.info('Writing...')\n logging.info(' checkpoints to: %s', checkpoint_dir)\n logging.info(' CSV metrics to: %s', csv_file)\n logging.info(' TensorBoard summaries to: %s', summary_dir)\n\n return checkpoint_manager, [csv_manager, tensorboard_manager]","def register(self):\n self._register_dockyard()\n self._register_docker()","def register_execution_manager(self, execution_manager):\n self.execution_managers.append(execution_manager)","def init_managers(endpoints_file: Optional[Text]) -> None:","def test_register_dynamic_plugin_manager1(self):\n pass","def create_allcomponents(self):\n\n # we store all components in a list/hash which we iterate for startup/shutdown/dumps debugging, and which can be used to lookup components\n self.components = MDictList()\n\n # setup log manager helper early so that log manager can receive messages (and queue them until startup)\n self.createappendcomp('logmanager', mlogger.MewloLogManager)\n\n # now update site state (log manager should catch this)\n self.set_statelabel(mconst.DEF_SITESTATE_INITIALIZE_START)\n\n # create (non-db-persistent) site settings -- these are set by configuration at runtime\n self.settings = self.createappendcomp('settings', MewloSettings)\n\n # database manager\n self.createappendcomp('dbmanager', mdbmanager_sqlalchemy.MewloDatabaseManagerSqlA)\n\n # component registry\n self.createappendcomp('registrymanager', mregistry.MewloRegistryManager)\n\n # signal dispatcher\n self.createappendcomp('signalmanager', msignal.MewloSignalManager)\n\n # rbac permission manager\n self.createappendcomp('rbacmanager', mrbac.MewloRbacManager)\n\n # create persistent(db) pack settings\n self.createappendcomp('packsettings', mdbsettings_pack.MewloSettingsDb_Pack)\n\n # collection of mewlo addon packs\n self.createappendcomp('packmanager', mpackmanager.MewloPackManager)\n\n # site addon manager\n #self.createappendcomp('siteaddonmanager', msiteaddon.MewloSiteAddonManager)\n\n # route manager\n self.createappendcomp('routemanager', mroute.MewloRouteManager)\n\n # navnode manager\n self.createappendcomp('navnodemanager', mnav.NavNodeManager)\n\n # template manager\n self.createappendcomp('templatemanager', mtemplate.MewloTemplateManager)\n\n # asset and alias manager\n self.createappendcomp('assetmanager', massetmanager.MewloAssetManager)\n\n # template helper (this is available inside template/views and provides helper functions like navigation menus, etc.)\n self.createappendcomp('templatehelper', mtemplatehelper.MewloTemplateHelper)\n\n # session manager\n self.createappendcomp('sessionmanager', msessionmanager.MewloSessionManager)\n\n # verification manager\n self.createappendcomp('verificationmanager', mverificationmanager.MewloVerificationManager)\n\n # user manager\n self.createappendcomp('usermanager', musermanager.MewloUserManager)\n\n # mail manager\n self.createappendcomp('mailmanager', mmailmanager.MewloMailManager)","def manager(self, ckpt_manager):\n self.ckpt_manager = ckpt_manager","def _configure_manager(self):\n self._manager = CloudLoadBalancerManager(self,\n resource_class=CloudLoadBalancer,\n response_key=\"loadBalancer\", uri_base=\"loadbalancers\")","def manager():\n pass","def manufacturers(self, manufacturers):\n\n self._manufacturers = manufacturers","def addAllFactories(self) -> None:\n ...","def set_manager(self, manager=None):\n if not manager:\n manager = ScheduleManager()\n else:\n for task in self._tasks:\n if task.name in manager:\n error = \"Duplicate task name <{}>.\".format(task.name)\n raise TaskNameDuplicateError(error)\n\n for task in self._tasks:\n if task.manager:\n task.manager.unregister(name=task.name)\n manager.register(task)\n\n return manager","def register(self):\n if self.registered:\n return\n\n config = current_app.config.get('TERMINAL_CONFIGS', {})\n apps = config.get('apps', [])\n\n for app in apps:\n cls, mod = app.rsplit('.', maxsplit=1)\n imported = import_module(cls)\n instance = getattr(imported, mod)()\n\n if getattr(instance, 'name', None) is None:\n continue\n\n if getattr(instance, 'hidden', False):\n self.hidden[getattr(instance, 'name')] = instance\n else:\n self.apps[getattr(instance, 'name')] = instance\n\n self.__set_apps_aliases(getattr(instance, 'name'), getattr(instance, 'aliases'))\n\n self.registered = True","def add_manager_and_tools(self):\n # Create a new plot manager, add plots to the plot manager.\n # There is already a plot manager associated with the\n # curvedialog, just create a new one for simplicity.\n manager = plot.PlotManager(self)\n manager.add_plot(self.main_curve_dialog.get_plot())\n\n # Add a panel to the plot manager - this apparently is not\n # required to enable the tool linkage. Was in here based on\n # example code. If you add this back in it creates an invisible\n # widget over at least the 'play' button.\n #manager.add_panel(plot.PlotItemList(self))\n\n # Associate the toolbar with the plot manager, this is created\n # along with the qmainwindow toolbars\n curve_toolbar = self.addToolBar(\"Curve tools\")\n curve_toolbar.setIconSize(QtCore.QSize(36, 36))\n manager.add_toolbar(curve_toolbar, id(curve_toolbar))\n\n # If you do this, you get all of the other tools\n #manager.register_all_curve_tools()\n\n # Add the custom tool classes with wrapper signals\n self.select_tool = manager.add_tool(visualize.SelectSignalTool)\n self.zoom_tool = manager.add_tool(visualize.ZoomSignalTool)\n\n # Store a reference for use by the application\n self.curve_toolbar = curve_toolbar","def get_manager():\n return __manager__","def SetAuiManager(self, auiManager):\r\n \r\n self._auiManager = auiManager","def SetUpLayerManager(self):\n pass","def SetMasterManager(self, manager):\r\n\r\n self._masterManager = manager","def test_register_dynamic_plugin_manager(self):\n pass","def set_input_manager(self, inputmanager):\n self.__inputmanager = inputmanager","def start_running_manager(self) -> None:\n self.add_value(self._manager_running_attribute, '1')","def propertyManagers(self) -> Iterator[unicode]:\n ...","def setUp(self) -> None:\n self.manager = Manager()","def add(self, auto_on=False):\n if self._addr in LogManager._managers_by_addr:\n writer.just_info(f'ERROR: Adding `{self._addr}` manager failed - address already exists')\n return False\n LogManager._managers_by_addr[self._addr] = self\n if auto_on:\n if address.should_be_on(self._addr) == '+':\n self.on()\n else:\n self.off()\n refresh(only_aunts=True)\n return True","def load_bundles(self):\n path = os.path.join(self.user_directory, \"bundles\")\n for name in os.listdir(path):\n if not name.startswith(\"__\") and os.path.isdir(path + \"/\" + name):\n bundle = Bundle(self, name)\n self.bundles[name] = bundle\n for bundle in self.bundles.values():\n bundle.setup(self, self.loader)\n\n for model in self.models:\n type(model).extend(model)\n for model in self.models:\n self.data_connector.repository_manager.add_model(model)","def __initialize_plugin_manager(self, args, plugin_dir):\n\n try:\n self.__plugins.initialize(\n plugin_dir,\n args.add_plugin,\n args.enable_rules,\n args.disable_rules,\n self.__properties,\n self.__show_stack_trace,\n )\n except BadPluginError as this_exception:\n formatted_error = (\n f\"BadPluginError encountered while loading plugins:\\n{this_exception}\"\n )\n self.__handle_error(formatted_error, this_exception)","def managerMuestra(self):\n self.modelo.managerMuestra(self.buttons, self.buttonReleased)","def setup(self, configuration, lifecycle_manager):\n self.configuration = configuration\n self.lifecycle = lifecycle_manager\n\n self.lifecycle.add_constraint(\n self.get_components_by_type,\n restrict_during=[\"initialization\", \"population_creation\"],\n )\n self.lifecycle.add_constraint(\n self.get_component, restrict_during=[\"population_creation\"]\n )\n self.lifecycle.add_constraint(\n self.list_components, restrict_during=[\"initialization\"]\n )","def init_client_manager(ip, port, authkey):\n class ServerQueueManager(SyncManager):\n pass\n\n ServerQueueManager.register('get_trmanager_plmanager_queue')\n ServerQueueManager.register('get_player_trmanager_queue')\n\n manager = ServerQueueManager(address=(ip, port), authkey=authkey)\n print('Connecting queue to %s:%d ...' % (ip, port))\n manager.connect()\n\n print('Connected.')\n return manager","def __init__(self, **manager_commands):\n self.package = manager_commands","def manager(self, manager):\n if not manager:\n if self._manager is None:\n raise OperationFailError(\"Use ScheduleManager.register(Task)\"\n \" instead.\")\n if self.name in self._manager:\n raise OperationFailError(\"Use ScheduleManager.register(Task)\"\n \" instead.\")\n\n self._manager = None\n\n return\n\n if self.name not in manager:\n raise OperationFailError(\"Use ScheduleManager.register(Task)\"\n \" instead.\")\n if self is not manager.task(self.name):\n raise OperationFailError(\"Use ScheduleManager.register(Task)\"\n \" instead.\")\n\n self._manager = manager","def get_manager():\n\n return multiprocessing.Manager()","def __init__(self, event_manager):\n self.event_manager = event_manager\n self.loaded_plugins = {}\n self.log = logging.getLogger(\"PluginManager\")","def loadmodels(self):\n for emane_model in EMANE_MODELS:\n logger.info(\"loading emane model: (%s) %s - %s\",\n emane_model, emane_model.name, RegisterTlvs(emane_model.config_type))\n self._modelclsmap[emane_model.name] = emane_model\n self.session.add_config_object(emane_model.name, emane_model.config_type,\n emane_model.configure_emane)","def startup_allcomponents(self, eventlist):\n\n # walk the component list and ask each to register any db classes\n for key,obj in self.components.get_tuplelist():\n # pre startup - register database classes\n obj.prestartup_register(eventlist)\n\n # now that all database models have been registered with the system, finalize creation of models -- create all db tables, etc\n self.comp('dbmanager').create_tableandmapper_forallmodelclasses()\n\n # walk the component list and let each startup\n for key,obj in self.components.get_tuplelist():\n # start up the component\n obj.startup(eventlist)\n\n # walk the component list and let each do any post-startup\n for key,obj in self.components.get_tuplelist():\n # post startup\n obj.poststartup(eventlist)","def set_ingestion_and_expiration_managers(\n self, ingestion_manager, expiration_manager):\n self._ingestion_manager = ingestion_manager\n self._expiration_manager = expiration_manager","def addMembranePropertyManager(dispatcher, id, title=None, REQUEST=None):\n\n pmm = MembranePropertyManager(id, title)\n dispatcher._setObject(pmm.getId(), pmm)\n\n if REQUEST is not None:\n REQUEST[\"RESPONSE\"].redirect(\n \"%s/manage_workspace\"\n \"?manage_tabs_message=\"\n \"MembranePropertyManager+added.\" % dispatcher.absolute_url()\n )","def register_all_image_tools(self):\n self.register_standard_tools()\n self.add_separator_tool()\n self.register_image_tools()\n self.add_separator_tool()\n self.register_other_tools()\n self.add_separator_tool()\n self.get_default_tool().activate()","def store(self):\n\t\timport shelve\n\n\t\td = shelve.open(\".storedmanager\",writeback=True)\n\t\td[\"storedmanager\"] = self\n\n\t\td.close()","def run_manager(self) -> None:\n \n for p in self.process_list:\n try:\n p.daemon = True\n p.start()\n except:\n self.process_list.remove(p)\n p = Process(target=self.multiprocessing_job, args=(self.process_job,))\n p.daemon = True\n self.process_list.append(p)\n p.start()\n #Every 1 seconds, check for active Processes.\n while True:\n sleep(1)\n running = any(p.is_alive() for p in self.process_list)\n if not running or not active_children:\n self.restart_required = True\n break\n self.logger.info(self.name + \" has finished managing.\")","def register_packages(self, module_name, extra_package):\n self.creator_manager.register_packages(module_name, extra_package)","def updateNamespace(self):\n self.namespace['pipeline_manager'] = self","def OnFindManager(self, event):\r\n \r\n event.SetManager(self._owner_mgr)","def register_classes():\n DiffuseCompChain.register_class()\n CatalogCompChain.register_class()\n DiffuseAnalysisChain.register_class()","def setup(self):\n with self.session._objects_lock:\n for obj in self.session.objects.itervalues():\n if nodeutils.is_node(obj, NodeTypes.EMANE):\n self.addobj(obj)\n if len(self._objs) == 0:\n return EmaneManager.NOT_NEEDED\n if emane.VERSION == emane.EMANEUNK:\n raise ValueError, \"EMANE version not properly detected\"\n # control network bridge required for EMANE 0.9.2\n # - needs to be configured before checkdistributed() for distributed\n # - needs to exist when eventservice binds to it (initeventservice)\n if emane.VERSION > emane.EMANE091 and self.session.master:\n values = self.getconfig(None, \"emane\",\n self.emane_config.getdefaultvalues())[1]\n otadev = self.emane_config.valueof(\"otamanagerdevice\", values)\n netidx = self.session.get_control_net_index(otadev)\n if netidx < 0:\n msg = \"EMANE cannot be started. \" \\\n \"Invalid OTA device provided: %s. Check core.conf.\" % otadev\n logger.error(msg)\n return EmaneManager.NOT_READY\n\n ctrlnet = self.session.add_remove_control_net(net_index=netidx, remove=False, conf_required=False)\n self.distributedctrlnet(ctrlnet)\n eventdev = self.emane_config.valueof(\"eventservicedevice\", values)\n if eventdev != otadev:\n netidx = self.session.get_control_net_index(eventdev)\n if netidx < 0:\n msg = \"EMANE cannot be started.\" \\\n \"Invalid Event Service device provided: %s. Check core.conf.\" % eventdev\n logger.error(msg)\n return EmaneManager.NOT_READY\n\n ctrlnet = self.session.add_remove_control_net(net_index=netidx, remove=False, conf_required=False)\n self.distributedctrlnet(ctrlnet)\n\n if self.checkdistributed():\n # we are slave, but haven\"t received a platformid yet\n cfgval = self.getconfig(None, self.emane_config.name,\n self.emane_config.getdefaultvalues())[1]\n i = self.emane_config.getnames().index(\"platform_id_start\")\n if cfgval[i] == self.emane_config.getdefaultvalues()[i]:\n return EmaneManager.NOT_READY\n self.setnodemodels()\n return EmaneManager.SUCCESS","def initialize():\n manager.initialize()\n logs.exit_great_success()","def add(self, *components):\n for component in components:\n if component.container is not None:\n component.container.remove(component)\n component.container = self\n self._components.extend(components)","def register_models(self, *models, **kwargs):\n\n for model in models:\n self.register(model, **kwargs)","def register(mgr):\n mgr.set_lang_info(lang,\n silvercity_lexer=CSSLexer(),\n buf_class=CSSBuffer,\n langintel_class=CSSLangIntel,\n is_cpln_lang=True)","def addSiteManager(self):\n if zope.component.interfaces.ISite.providedBy(self.context):\n raise UserError(_('This is already a site'))\n\n # We don't want to store security proxies (we can't,\n # actually), so we have to remove proxies here before passing\n # the context to the SiteManager.\n bare = removeSecurityProxy(self.context)\n sm = LocalSiteManager(bare)\n self.context.setSiteManager(sm)\n self.request.response.redirect(\n \"++etc++site/@@SelectedManagementView.html\")","def update_manager(self):\n if self.name == \"observable\":\n self.fsm_manager.update_latent()\n else:\n self.fsm_manager.update_observable()","def plugin_manager() -> pluggy.PluginManager:\n _plugin_manager = pluggy.PluginManager(\"rasa\")\n _plugin_manager.add_hookspecs(sys.modules[\"rasa.plugin\"])\n _discover_plugins(_plugin_manager)\n\n return _plugin_manager","def use_manager(manager_name, environment):\n assert manager_name in environment.managers, (\n 'Manager {selected} was not created by this test run. '\n 'Available managers are: {available}'.format(\n selected=manager_name,\n available=', '.join(environment.managers.keys()),\n )\n )\n\n manager = environment.managers[manager_name]\n\n environment.add_cleanup(\n environment.cfy.profiles.delete,\n kwargs={\n 'profile_name': manager['ip'],\n },\n )\n\n environment.cfy.profiles.use(\n ip=manager['ip'],\n username=manager['username'],\n password=manager['password'],\n rest_certificate=manager['certificate_path'],\n )","def onStart(self):\n self.register_form(JobManager.id, JobManager,\n title=\"JobManager\", shortcut=\"^D\", name=\"JobManager\")\n self.register_form(SystemOverviewForm.id, SystemOverviewForm,\n title=\"System Overview\", shortcut=\"^O\", name=\"System Overview\")\n self.register_form(StateManagerForm.id, StateManagerForm,\n title=\"State Manager\", shortcut=\"^T\", name=\"State Manager\")\n self.register_form(ModuleRunnerForm.id, ModuleRunnerForm,\n title=\"Module Runner\", shortcut=\"^T\", name=\"Module Runner\")\n self.init_forms()","def register() -> None:\n plot_backend = _get_plot_backend(\"matplotlib\")\n plot_backend.register()","def test_register_component_with_invalid_type_only_manager():\n\n with pytest.raises(InvalidComponentTypeError):\n component = OnlyManagerMock()\n application_services.register_component(component)","def assign_store_manager(user_name: str, new_store_manager_name: str, store_name: str):\n\n user_name = auth.get_username_from_hash(user_name)\n permission_handler.is_permmited_to(user_name, Action.ADD_MANAGER.value, store_name)\n permission_handler.assign_store_employee(action.MANAGER_INITIAL_PERMISSIONS,\n new_store_manager_name,\n store_name)\n user_handler.assign_store_employee(user_name, new_store_manager_name, store_name)","def load_components(self, on_initialize=False):\n for name, component_data in self.components.items():\n start_on_initialize = component_data.get('on_initialize', False)\n if start_on_initialize == on_initialize:\n component_data.pop('on_initialize', None)\n\n # inject parent module in component\n if not component_data.get('options', None):\n component_data['options'] = {}\n\n component_data['options']['module'] = self\n component = RonObject.instanceObject(component_data)\n setattr(self, name, component)","async def reinit_manager(ctx):\n await ext_manager.reinit()\n await ctx.send(\"Successfully reinitialize.\")","def init_login_manager():\n login_manager = LoginManager()\n login_manager.init_app(app)\n return login_manager","def register ():\n dsf_geom_import.register ()\n dsf_morph_import.register ()\n dsf_morph_export.register ()\n dsf_uvset_import.register ()\n dsf_arm_import.register ()\n dsf_pose_import.register ()\n dsf_wm_import.register ()\n dsf_geom_export.register ()\n dsf_prop_export.register ()","def new_manager() -> SyncManager:\n return Manager()","def create_manager(\n pdb_hierarchy,\n geometry_restraints_manager,\n fmodel,\n wavelength,\n params,\n resolution_factor = 0.25,\n nproc = Auto,\n verbose = False,\n log = None,\n manager_class=None):\n connectivity = \\\n geometry_restraints_manager.shell_sym_tables[0].full_simple_connectivity()\n if (manager_class is None):\n manager_class = manager\n manager_obj = manager_class(\n fmodel = fmodel,\n pdb_hierarchy = pdb_hierarchy,\n xray_structure = fmodel.xray_structure,\n connectivity = connectivity,\n wavelength = wavelength,\n params = params,\n nproc = nproc,\n verbose = verbose,\n log = log)\n return manager_obj","def name(self):\n return \"component_manager\"","def manager_configs_list(self):\n _, body = self.request('/v1.1/managers/configs', 'GET')\n return body","def create(self, context, data, is_auto_import=False):\n db_session_event = 'create-resource_mgr'\n db_session = self.db_api.get_transactional_session(\n db_session_event)\n state_map = {eon_const.RESOURCE_MGR_STATE_KEY:\n eon_const.EON_RESOURCE_MANAGER_STATE_REGISTERED}\n property_list = []\n try:\n _validate_create(context, self.db_api, data,\n eon_const.EON_RESOURCE_MANAGER)\n resource_mgr_type = data.get('type')\n resource_mgr_driver = driver.load_resource_mgr_driver(\n resource_mgr_type)\n data = resource_mgr_driver.validate_create(context, data)\n\n LOG.info(\"Registering resource manager, context: %s\",\n logging.mask_password(data))\n db_resource_mgr_data = self.db_api.create_resource_manager(\n context, data, session=db_session)\n properties = resource_mgr_driver.get_properties(state_map)\n for property_key, property_value in properties.iteritems():\n property_list.append(\n self.db_api.create_resource_mgr_property(\n context, db_resource_mgr_data['id'],\n property_key, property_value, session=db_session)\n )\n resource_mgr_dict = _make_response(db_resource_mgr_data,\n property_list=property_list)\n resource_mgr_driver.update_vc_pass_through(context,\n resource_mgr_dict)\n self.db_api.commit_session(db_session_event, db_session)\n return resource_mgr_dict\n except (exception.AddressResolutionFailure,\n exception.InternalFailure,\n exception.ResourceExists,\n exception.UnsupportedVCenterVersion,\n exception.VCenterRegisterFailure\n ) as e:\n self.db_api.rollback_session('create-resource_mgr', db_session)\n msg = (_(\"Registering resource manager failed. Reason: '%s'\")\n % e.message)\n log_msg = ((\"Registering resource manager failed. Reason: '%s'\")\n % e.message)\n LOG.error(log_msg)\n raise exception.CreateException(msg=msg)\n except Exception as e:\n LOG.exception(e)\n self.db_api.rollback_session('create-resource_mgr', db_session)\n msg = (_(\"Registering resource manager failed. Reason: '%s'\")\n % e)\n log_msg = ((\"Registering resource manager failed. Reason: '%s'\")\n % e)\n LOG.error(log_msg)\n raise exception.CreateException(msg=msg)","def GetManager(self):\r\n\r\n return self.manager","def manager_factory(manager_type):\n return {\n 'web': WebManager,\n 'github': GitHubManager,\n 'apkdownloadmirror': ApkDownloadMirrorManager,\n 'apkplz': ApkPlzManager,\n }[manager_type]","def create_manager(self, username, tenancy):\n raise NotImplementedError","def initialize_location_strategies(self):\n locator_manager.register_locators(\"sf\", lex_locators)\n locator_manager.register_locators(\"text\", \"Salesforce.Locate Element by Text\")\n locator_manager.register_locators(\"title\", \"Salesforce.Locate Element by Title\")\n\n # This does the work of actually adding all of the above-registered\n # location strategies, plus any that were registered by keyword\n # libraries.\n locator_manager.add_location_strategies()","def __init__(self, decorated_object=None,\n\t\t\t\t # The following args will only be used if we need to\n\t\t\t\t # create a default PluginManager\n\t\t\t\t categories_filter=None, \n\t\t\t\t directories_list=None, \n\t\t\t\t plugin_info_ext=\"yapsy-plugin\"):\n\t\tif directories_list is None:\n\t\t\tdirectories_list = [os.path.dirname(__file__)]\n\t\tif categories_filter is None:\n\t\t\tcategories_filter = {\"Default\": IPlugin}\n\t\tif decorated_object is None:\n\t\t\tlog.debug(\"Creating a default PluginManager instance to be decorated.\")\n\t\t\tfrom yapsy.PluginManager import PluginManager\n\t\t\tdecorated_object = PluginManager(categories_filter, \n\t\t\t\t\t\t\t\t\t\t\t directories_list,\n\t\t\t\t\t\t\t\t\t\t\t plugin_info_ext)\n\t\tself._component = decorated_object","def register_router(self, router):\n for prefix, viewset, basename in router.registry:\n self.register(prefix, viewset, base_name=basename)","def manager_update(self, manager, config):\n self.request('/v1.1/managers/configs/%s' % manager, 'POST', body=config)","def install():\n ArticleDataProvider.register()\n ProductDataProvider.register()","def modules(self):\n return ModuleManager(self)","def register(self):\n\n RPCObjectsRegistry.add(self)","def add_providers(self):\n str_providers = PROVIDERS[0] # Providers, called by name\n live_providers = PROVIDERS[1] # Providers, provided as a live module\n for providers in PROVIDERS: # Iterate over the types of providers\n for provider in providers: # Iterate over all the methods\n # Inject those into faker, and swap the numpy instance\n self.fake.add_faker(self._swap_numpy(provider[0]), provider[1])","def cluster_manager(self):\n # Lazily instantiate the cluster manager the first time it is asked for.\n if not hasattr(self, '_cluster_manager'):\n if self._cluster_engine:\n self._cluster_manager = self._cluster_engine.create_manager(\n self._username,\n self._tenancy\n )\n else:\n self._cluster_manager = None\n # If there is still no cluster manager, clusters are not supported\n if not self._cluster_manager:\n raise errors.UnsupportedOperationError(\n 'Clusters are not supported for this tenancy.'\n )\n return self._cluster_manager","def register(self, obj):\r\n name = obj._component_name\r\n if name in self.components:\r\n raise ComponentAlreadyRegistered(\"Component already registered with name %s\" % name)\r\n\r\n self.components[obj._component_name] = obj","def setup_applications(self, configs):\n self.__applications = self.setup_components(configs, 'scale_client.applications')","def RegisterPlugins(cls, plugin_classes):\n for plugin_class in plugin_classes:\n cls.RegisterPlugin(plugin_class)","def get_manager(self, name):\n\n if name == \"control\":\n manager = self._control_manager\n elif name == \"alarm\":\n manager = self._alarm_manager\n elif name == \"state\":\n manager = self._machine_manager\n else:\n manager = self._function_manager\n\n return manager","def _load_services(self) -> None:\n # load default services\n self.service_errors = ServiceManager.load_locals()\n # load custom services\n service_paths = self.config.get(\"custom_services_dir\")\n logger.debug(\"custom service paths: %s\", service_paths)\n if service_paths is not None:\n for service_path in service_paths.split(\",\"):\n service_path = Path(service_path.strip())\n custom_service_errors = ServiceManager.add_services(service_path)\n self.service_errors.extend(custom_service_errors)\n # load default config services\n self.service_manager.load_locals()\n # load custom config services\n custom_dir = self.config.get(\"custom_config_services_dir\")\n if custom_dir is not None:\n custom_dir = Path(custom_dir)\n self.service_manager.load(custom_dir)"],"string":"[\n \"def setup_manager(self) -> None:\\n\\n #Clean out the process list.\\n self.process_list.clear()\\n for _ in range(self.num_processes):\\n p = Process(target=self.multiprocessing_job,\\n args=(self.process_job,))\\n self.process_list.append(p)\\n self.restart_required = False\",\n \"def add_manager(self, agent):\\n with self.simulation_mutex:\\n self.get(\\\"manager_agents\\\")[agent.name] = agent\",\n \"def setup(self, manager):\\n self._manager = manager\\n self._configured = True\",\n \"def _configure_manager(self):\\n self._manager = CloudDatabaseManager(self,\\n resource_class=CloudDatabaseInstance, response_key=\\\"instance\\\",\\n uri_base=\\\"instances\\\")\\n self._flavor_manager = BaseManager(self,\\n resource_class=CloudDatabaseFlavor, response_key=\\\"flavor\\\",\\n uri_base=\\\"flavors\\\")\\n self._backup_manager = CloudDatabaseBackupManager(self,\\n resource_class=CloudDatabaseBackup, response_key=\\\"backup\\\",\\n uri_base=\\\"backups\\\")\",\n \"def SetManager(self, mgr):\\r\\n\\r\\n self.manager = mgr\",\n \"def register_manager(self, update, context):\\r\\n new_manager_chat_id = update['message']['chat']['id']\\r\\n new_manager_name = update['message']['chat']['first_name']\\r\\n\\r\\n with open('managers.json') as obj:\\r\\n managers = json.load(obj)\\r\\n\\r\\n managers[new_manager_name] = new_manager_chat_id\\r\\n\\r\\n with open('managers.json', 'w') as obj:\\r\\n json.dump(managers, obj)\\r\\n\\r\\n context.bot.send_message(chat_id=update.message.chat_id, text=f'{new_manager_name} - {new_manager_chat_id}')\",\n \"def setManager(self, manager=None):\\n self._manager = manager\",\n \"def register(self, events=[]):\\n self.events = events\\n if not self in manager.handler:\\n manager.handler.append(self)\",\n \"def setup_components(self, builder: \\\"Builder\\\"):\\n self._setup_components(builder, self._managers + self._components)\",\n \"def install_providers():\\n host = env.host_string\\n providers = get_providers(host)\\n for provider in providers.values():\\n if getattr(provider, 'manager', None) is not None:\\n provider.manager.install()\\n\\n provider.install()\",\n \"def startManager(self):\\n\\t\\tlogging.info(\\\"----->>>The DeviceDataManager will be started\\\")\\n\\t\\tself.sysPerfManager.startManager()\\n\\t\\tself.sensorAdapterManager.startManager()\\n\\t\\tif self.enableRedis:\\n\\t\\t\\tself.redisClient.connectClient()\\n\\t\\t\\n\\t\\tif self.enableMqtt:\\n\\t\\t\\tself.mqttClient.connectClient()\",\n \"def set_up():\\n ResourcesManager().set_up()\\n LocatorUtil().load_locators()\",\n \"def _init_pluginmanager(self):\\n self.pluginmanager = PluginManager(logger=self.logger)\\n self.logger.debug(\\\"Registering execution wide plugins:\\\")\\n self.pluginmanager.load_default_run_plugins()\\n self.pluginmanager.load_custom_run_plugins(self.args.plugin_path)\\n self.logger.debug(\\\"Execution wide plugins loaded and registered.\\\")\",\n \"def _setManager(self, mgr: \\\"StrategyManager\\\") -> None:\",\n \"def getPackageManager(self) -> None:\\n\\t\\tfor pkgmgr in config.SUPPORTED_PACKAGE_MGRS:\\n\\t\\t\\tif subprocess.run([\\\"which\\\", pkgmgr]).returncode == 0:\\n\\t\\t\\t\\tself.package_manager = pkgmgr\\n\\t\\t\\t\\treturn\\n\\t\\tlogger.error(\\\"Supported package manager not found, aborting.\\\")\\n\\t\\traise ValueError(\\\"Package manager unsupported\\\")\",\n \"def RegisterParsers(cls, parser_classes):\\n for parser_class in parser_classes:\\n cls.RegisterParser(parser_class)\",\n \"def configure_node_managers(config):\\n host_names = get_compute_node_host_names(config)\\n sysctl_settings = unflatten_dict_keys(config, 'sysctl_(.*)')\\n sys_settings = unflatten_dict_keys(config, '(/sys/.*)')\\n pjobs = [delayed(configure_node_manager)(host_name, sysctl_settings, sys_settings, config.get('transparent_hugepage_enabled')) for host_name in host_names]\\n Parallel(n_jobs=len(pjobs))(pjobs)\",\n \"def _configure_managers() -> Tuple[tff.simulation.FileCheckpointManager,\\n List[tff.simulation.MetricsManager]]:\\n root_output_dir = FLAGS.root_output_dir\\n experiment_name = FLAGS.experiment_name\\n utils_impl.create_directory_if_not_exists(root_output_dir)\\n\\n checkpoint_dir = os.path.join(root_output_dir, 'checkpoints', experiment_name)\\n utils_impl.create_directory_if_not_exists(checkpoint_dir)\\n checkpoint_manager = tff.simulation.FileCheckpointManager(\\n checkpoint_dir, step=FLAGS.rounds_per_checkpoint)\\n\\n results_dir = os.path.join(root_output_dir, 'results', experiment_name)\\n utils_impl.create_directory_if_not_exists(results_dir)\\n csv_file = os.path.join(results_dir, 'experiment.metrics.csv')\\n csv_manager = tff.simulation.CSVMetricsManager(csv_file)\\n\\n summary_dir = os.path.join(root_output_dir, 'logdir', experiment_name)\\n tensorboard_manager = tff.simulation.TensorBoardManager(summary_dir)\\n\\n logging.info('Writing...')\\n logging.info(' checkpoints to: %s', checkpoint_dir)\\n logging.info(' CSV metrics to: %s', csv_file)\\n logging.info(' TensorBoard summaries to: %s', summary_dir)\\n\\n return checkpoint_manager, [csv_manager, tensorboard_manager]\",\n \"def register(self):\\n self._register_dockyard()\\n self._register_docker()\",\n \"def register_execution_manager(self, execution_manager):\\n self.execution_managers.append(execution_manager)\",\n \"def init_managers(endpoints_file: Optional[Text]) -> None:\",\n \"def test_register_dynamic_plugin_manager1(self):\\n pass\",\n \"def create_allcomponents(self):\\n\\n # we store all components in a list/hash which we iterate for startup/shutdown/dumps debugging, and which can be used to lookup components\\n self.components = MDictList()\\n\\n # setup log manager helper early so that log manager can receive messages (and queue them until startup)\\n self.createappendcomp('logmanager', mlogger.MewloLogManager)\\n\\n # now update site state (log manager should catch this)\\n self.set_statelabel(mconst.DEF_SITESTATE_INITIALIZE_START)\\n\\n # create (non-db-persistent) site settings -- these are set by configuration at runtime\\n self.settings = self.createappendcomp('settings', MewloSettings)\\n\\n # database manager\\n self.createappendcomp('dbmanager', mdbmanager_sqlalchemy.MewloDatabaseManagerSqlA)\\n\\n # component registry\\n self.createappendcomp('registrymanager', mregistry.MewloRegistryManager)\\n\\n # signal dispatcher\\n self.createappendcomp('signalmanager', msignal.MewloSignalManager)\\n\\n # rbac permission manager\\n self.createappendcomp('rbacmanager', mrbac.MewloRbacManager)\\n\\n # create persistent(db) pack settings\\n self.createappendcomp('packsettings', mdbsettings_pack.MewloSettingsDb_Pack)\\n\\n # collection of mewlo addon packs\\n self.createappendcomp('packmanager', mpackmanager.MewloPackManager)\\n\\n # site addon manager\\n #self.createappendcomp('siteaddonmanager', msiteaddon.MewloSiteAddonManager)\\n\\n # route manager\\n self.createappendcomp('routemanager', mroute.MewloRouteManager)\\n\\n # navnode manager\\n self.createappendcomp('navnodemanager', mnav.NavNodeManager)\\n\\n # template manager\\n self.createappendcomp('templatemanager', mtemplate.MewloTemplateManager)\\n\\n # asset and alias manager\\n self.createappendcomp('assetmanager', massetmanager.MewloAssetManager)\\n\\n # template helper (this is available inside template/views and provides helper functions like navigation menus, etc.)\\n self.createappendcomp('templatehelper', mtemplatehelper.MewloTemplateHelper)\\n\\n # session manager\\n self.createappendcomp('sessionmanager', msessionmanager.MewloSessionManager)\\n\\n # verification manager\\n self.createappendcomp('verificationmanager', mverificationmanager.MewloVerificationManager)\\n\\n # user manager\\n self.createappendcomp('usermanager', musermanager.MewloUserManager)\\n\\n # mail manager\\n self.createappendcomp('mailmanager', mmailmanager.MewloMailManager)\",\n \"def manager(self, ckpt_manager):\\n self.ckpt_manager = ckpt_manager\",\n \"def _configure_manager(self):\\n self._manager = CloudLoadBalancerManager(self,\\n resource_class=CloudLoadBalancer,\\n response_key=\\\"loadBalancer\\\", uri_base=\\\"loadbalancers\\\")\",\n \"def manager():\\n pass\",\n \"def manufacturers(self, manufacturers):\\n\\n self._manufacturers = manufacturers\",\n \"def addAllFactories(self) -> None:\\n ...\",\n \"def set_manager(self, manager=None):\\n if not manager:\\n manager = ScheduleManager()\\n else:\\n for task in self._tasks:\\n if task.name in manager:\\n error = \\\"Duplicate task name <{}>.\\\".format(task.name)\\n raise TaskNameDuplicateError(error)\\n\\n for task in self._tasks:\\n if task.manager:\\n task.manager.unregister(name=task.name)\\n manager.register(task)\\n\\n return manager\",\n \"def register(self):\\n if self.registered:\\n return\\n\\n config = current_app.config.get('TERMINAL_CONFIGS', {})\\n apps = config.get('apps', [])\\n\\n for app in apps:\\n cls, mod = app.rsplit('.', maxsplit=1)\\n imported = import_module(cls)\\n instance = getattr(imported, mod)()\\n\\n if getattr(instance, 'name', None) is None:\\n continue\\n\\n if getattr(instance, 'hidden', False):\\n self.hidden[getattr(instance, 'name')] = instance\\n else:\\n self.apps[getattr(instance, 'name')] = instance\\n\\n self.__set_apps_aliases(getattr(instance, 'name'), getattr(instance, 'aliases'))\\n\\n self.registered = True\",\n \"def add_manager_and_tools(self):\\n # Create a new plot manager, add plots to the plot manager.\\n # There is already a plot manager associated with the\\n # curvedialog, just create a new one for simplicity.\\n manager = plot.PlotManager(self)\\n manager.add_plot(self.main_curve_dialog.get_plot())\\n\\n # Add a panel to the plot manager - this apparently is not\\n # required to enable the tool linkage. Was in here based on\\n # example code. If you add this back in it creates an invisible\\n # widget over at least the 'play' button.\\n #manager.add_panel(plot.PlotItemList(self))\\n\\n # Associate the toolbar with the plot manager, this is created\\n # along with the qmainwindow toolbars\\n curve_toolbar = self.addToolBar(\\\"Curve tools\\\")\\n curve_toolbar.setIconSize(QtCore.QSize(36, 36))\\n manager.add_toolbar(curve_toolbar, id(curve_toolbar))\\n\\n # If you do this, you get all of the other tools\\n #manager.register_all_curve_tools()\\n\\n # Add the custom tool classes with wrapper signals\\n self.select_tool = manager.add_tool(visualize.SelectSignalTool)\\n self.zoom_tool = manager.add_tool(visualize.ZoomSignalTool)\\n\\n # Store a reference for use by the application\\n self.curve_toolbar = curve_toolbar\",\n \"def get_manager():\\n return __manager__\",\n \"def SetAuiManager(self, auiManager):\\r\\n \\r\\n self._auiManager = auiManager\",\n \"def SetUpLayerManager(self):\\n pass\",\n \"def SetMasterManager(self, manager):\\r\\n\\r\\n self._masterManager = manager\",\n \"def test_register_dynamic_plugin_manager(self):\\n pass\",\n \"def set_input_manager(self, inputmanager):\\n self.__inputmanager = inputmanager\",\n \"def start_running_manager(self) -> None:\\n self.add_value(self._manager_running_attribute, '1')\",\n \"def propertyManagers(self) -> Iterator[unicode]:\\n ...\",\n \"def setUp(self) -> None:\\n self.manager = Manager()\",\n \"def add(self, auto_on=False):\\n if self._addr in LogManager._managers_by_addr:\\n writer.just_info(f'ERROR: Adding `{self._addr}` manager failed - address already exists')\\n return False\\n LogManager._managers_by_addr[self._addr] = self\\n if auto_on:\\n if address.should_be_on(self._addr) == '+':\\n self.on()\\n else:\\n self.off()\\n refresh(only_aunts=True)\\n return True\",\n \"def load_bundles(self):\\n path = os.path.join(self.user_directory, \\\"bundles\\\")\\n for name in os.listdir(path):\\n if not name.startswith(\\\"__\\\") and os.path.isdir(path + \\\"/\\\" + name):\\n bundle = Bundle(self, name)\\n self.bundles[name] = bundle\\n for bundle in self.bundles.values():\\n bundle.setup(self, self.loader)\\n\\n for model in self.models:\\n type(model).extend(model)\\n for model in self.models:\\n self.data_connector.repository_manager.add_model(model)\",\n \"def __initialize_plugin_manager(self, args, plugin_dir):\\n\\n try:\\n self.__plugins.initialize(\\n plugin_dir,\\n args.add_plugin,\\n args.enable_rules,\\n args.disable_rules,\\n self.__properties,\\n self.__show_stack_trace,\\n )\\n except BadPluginError as this_exception:\\n formatted_error = (\\n f\\\"BadPluginError encountered while loading plugins:\\\\n{this_exception}\\\"\\n )\\n self.__handle_error(formatted_error, this_exception)\",\n \"def managerMuestra(self):\\n self.modelo.managerMuestra(self.buttons, self.buttonReleased)\",\n \"def setup(self, configuration, lifecycle_manager):\\n self.configuration = configuration\\n self.lifecycle = lifecycle_manager\\n\\n self.lifecycle.add_constraint(\\n self.get_components_by_type,\\n restrict_during=[\\\"initialization\\\", \\\"population_creation\\\"],\\n )\\n self.lifecycle.add_constraint(\\n self.get_component, restrict_during=[\\\"population_creation\\\"]\\n )\\n self.lifecycle.add_constraint(\\n self.list_components, restrict_during=[\\\"initialization\\\"]\\n )\",\n \"def init_client_manager(ip, port, authkey):\\n class ServerQueueManager(SyncManager):\\n pass\\n\\n ServerQueueManager.register('get_trmanager_plmanager_queue')\\n ServerQueueManager.register('get_player_trmanager_queue')\\n\\n manager = ServerQueueManager(address=(ip, port), authkey=authkey)\\n print('Connecting queue to %s:%d ...' % (ip, port))\\n manager.connect()\\n\\n print('Connected.')\\n return manager\",\n \"def __init__(self, **manager_commands):\\n self.package = manager_commands\",\n \"def manager(self, manager):\\n if not manager:\\n if self._manager is None:\\n raise OperationFailError(\\\"Use ScheduleManager.register(Task)\\\"\\n \\\" instead.\\\")\\n if self.name in self._manager:\\n raise OperationFailError(\\\"Use ScheduleManager.register(Task)\\\"\\n \\\" instead.\\\")\\n\\n self._manager = None\\n\\n return\\n\\n if self.name not in manager:\\n raise OperationFailError(\\\"Use ScheduleManager.register(Task)\\\"\\n \\\" instead.\\\")\\n if self is not manager.task(self.name):\\n raise OperationFailError(\\\"Use ScheduleManager.register(Task)\\\"\\n \\\" instead.\\\")\\n\\n self._manager = manager\",\n \"def get_manager():\\n\\n return multiprocessing.Manager()\",\n \"def __init__(self, event_manager):\\n self.event_manager = event_manager\\n self.loaded_plugins = {}\\n self.log = logging.getLogger(\\\"PluginManager\\\")\",\n \"def loadmodels(self):\\n for emane_model in EMANE_MODELS:\\n logger.info(\\\"loading emane model: (%s) %s - %s\\\",\\n emane_model, emane_model.name, RegisterTlvs(emane_model.config_type))\\n self._modelclsmap[emane_model.name] = emane_model\\n self.session.add_config_object(emane_model.name, emane_model.config_type,\\n emane_model.configure_emane)\",\n \"def startup_allcomponents(self, eventlist):\\n\\n # walk the component list and ask each to register any db classes\\n for key,obj in self.components.get_tuplelist():\\n # pre startup - register database classes\\n obj.prestartup_register(eventlist)\\n\\n # now that all database models have been registered with the system, finalize creation of models -- create all db tables, etc\\n self.comp('dbmanager').create_tableandmapper_forallmodelclasses()\\n\\n # walk the component list and let each startup\\n for key,obj in self.components.get_tuplelist():\\n # start up the component\\n obj.startup(eventlist)\\n\\n # walk the component list and let each do any post-startup\\n for key,obj in self.components.get_tuplelist():\\n # post startup\\n obj.poststartup(eventlist)\",\n \"def set_ingestion_and_expiration_managers(\\n self, ingestion_manager, expiration_manager):\\n self._ingestion_manager = ingestion_manager\\n self._expiration_manager = expiration_manager\",\n \"def addMembranePropertyManager(dispatcher, id, title=None, REQUEST=None):\\n\\n pmm = MembranePropertyManager(id, title)\\n dispatcher._setObject(pmm.getId(), pmm)\\n\\n if REQUEST is not None:\\n REQUEST[\\\"RESPONSE\\\"].redirect(\\n \\\"%s/manage_workspace\\\"\\n \\\"?manage_tabs_message=\\\"\\n \\\"MembranePropertyManager+added.\\\" % dispatcher.absolute_url()\\n )\",\n \"def register_all_image_tools(self):\\n self.register_standard_tools()\\n self.add_separator_tool()\\n self.register_image_tools()\\n self.add_separator_tool()\\n self.register_other_tools()\\n self.add_separator_tool()\\n self.get_default_tool().activate()\",\n \"def store(self):\\n\\t\\timport shelve\\n\\n\\t\\td = shelve.open(\\\".storedmanager\\\",writeback=True)\\n\\t\\td[\\\"storedmanager\\\"] = self\\n\\n\\t\\td.close()\",\n \"def run_manager(self) -> None:\\n \\n for p in self.process_list:\\n try:\\n p.daemon = True\\n p.start()\\n except:\\n self.process_list.remove(p)\\n p = Process(target=self.multiprocessing_job, args=(self.process_job,))\\n p.daemon = True\\n self.process_list.append(p)\\n p.start()\\n #Every 1 seconds, check for active Processes.\\n while True:\\n sleep(1)\\n running = any(p.is_alive() for p in self.process_list)\\n if not running or not active_children:\\n self.restart_required = True\\n break\\n self.logger.info(self.name + \\\" has finished managing.\\\")\",\n \"def register_packages(self, module_name, extra_package):\\n self.creator_manager.register_packages(module_name, extra_package)\",\n \"def updateNamespace(self):\\n self.namespace['pipeline_manager'] = self\",\n \"def OnFindManager(self, event):\\r\\n \\r\\n event.SetManager(self._owner_mgr)\",\n \"def register_classes():\\n DiffuseCompChain.register_class()\\n CatalogCompChain.register_class()\\n DiffuseAnalysisChain.register_class()\",\n \"def setup(self):\\n with self.session._objects_lock:\\n for obj in self.session.objects.itervalues():\\n if nodeutils.is_node(obj, NodeTypes.EMANE):\\n self.addobj(obj)\\n if len(self._objs) == 0:\\n return EmaneManager.NOT_NEEDED\\n if emane.VERSION == emane.EMANEUNK:\\n raise ValueError, \\\"EMANE version not properly detected\\\"\\n # control network bridge required for EMANE 0.9.2\\n # - needs to be configured before checkdistributed() for distributed\\n # - needs to exist when eventservice binds to it (initeventservice)\\n if emane.VERSION > emane.EMANE091 and self.session.master:\\n values = self.getconfig(None, \\\"emane\\\",\\n self.emane_config.getdefaultvalues())[1]\\n otadev = self.emane_config.valueof(\\\"otamanagerdevice\\\", values)\\n netidx = self.session.get_control_net_index(otadev)\\n if netidx < 0:\\n msg = \\\"EMANE cannot be started. \\\" \\\\\\n \\\"Invalid OTA device provided: %s. Check core.conf.\\\" % otadev\\n logger.error(msg)\\n return EmaneManager.NOT_READY\\n\\n ctrlnet = self.session.add_remove_control_net(net_index=netidx, remove=False, conf_required=False)\\n self.distributedctrlnet(ctrlnet)\\n eventdev = self.emane_config.valueof(\\\"eventservicedevice\\\", values)\\n if eventdev != otadev:\\n netidx = self.session.get_control_net_index(eventdev)\\n if netidx < 0:\\n msg = \\\"EMANE cannot be started.\\\" \\\\\\n \\\"Invalid Event Service device provided: %s. Check core.conf.\\\" % eventdev\\n logger.error(msg)\\n return EmaneManager.NOT_READY\\n\\n ctrlnet = self.session.add_remove_control_net(net_index=netidx, remove=False, conf_required=False)\\n self.distributedctrlnet(ctrlnet)\\n\\n if self.checkdistributed():\\n # we are slave, but haven\\\"t received a platformid yet\\n cfgval = self.getconfig(None, self.emane_config.name,\\n self.emane_config.getdefaultvalues())[1]\\n i = self.emane_config.getnames().index(\\\"platform_id_start\\\")\\n if cfgval[i] == self.emane_config.getdefaultvalues()[i]:\\n return EmaneManager.NOT_READY\\n self.setnodemodels()\\n return EmaneManager.SUCCESS\",\n \"def initialize():\\n manager.initialize()\\n logs.exit_great_success()\",\n \"def add(self, *components):\\n for component in components:\\n if component.container is not None:\\n component.container.remove(component)\\n component.container = self\\n self._components.extend(components)\",\n \"def register_models(self, *models, **kwargs):\\n\\n for model in models:\\n self.register(model, **kwargs)\",\n \"def register(mgr):\\n mgr.set_lang_info(lang,\\n silvercity_lexer=CSSLexer(),\\n buf_class=CSSBuffer,\\n langintel_class=CSSLangIntel,\\n is_cpln_lang=True)\",\n \"def addSiteManager(self):\\n if zope.component.interfaces.ISite.providedBy(self.context):\\n raise UserError(_('This is already a site'))\\n\\n # We don't want to store security proxies (we can't,\\n # actually), so we have to remove proxies here before passing\\n # the context to the SiteManager.\\n bare = removeSecurityProxy(self.context)\\n sm = LocalSiteManager(bare)\\n self.context.setSiteManager(sm)\\n self.request.response.redirect(\\n \\\"++etc++site/@@SelectedManagementView.html\\\")\",\n \"def update_manager(self):\\n if self.name == \\\"observable\\\":\\n self.fsm_manager.update_latent()\\n else:\\n self.fsm_manager.update_observable()\",\n \"def plugin_manager() -> pluggy.PluginManager:\\n _plugin_manager = pluggy.PluginManager(\\\"rasa\\\")\\n _plugin_manager.add_hookspecs(sys.modules[\\\"rasa.plugin\\\"])\\n _discover_plugins(_plugin_manager)\\n\\n return _plugin_manager\",\n \"def use_manager(manager_name, environment):\\n assert manager_name in environment.managers, (\\n 'Manager {selected} was not created by this test run. '\\n 'Available managers are: {available}'.format(\\n selected=manager_name,\\n available=', '.join(environment.managers.keys()),\\n )\\n )\\n\\n manager = environment.managers[manager_name]\\n\\n environment.add_cleanup(\\n environment.cfy.profiles.delete,\\n kwargs={\\n 'profile_name': manager['ip'],\\n },\\n )\\n\\n environment.cfy.profiles.use(\\n ip=manager['ip'],\\n username=manager['username'],\\n password=manager['password'],\\n rest_certificate=manager['certificate_path'],\\n )\",\n \"def onStart(self):\\n self.register_form(JobManager.id, JobManager,\\n title=\\\"JobManager\\\", shortcut=\\\"^D\\\", name=\\\"JobManager\\\")\\n self.register_form(SystemOverviewForm.id, SystemOverviewForm,\\n title=\\\"System Overview\\\", shortcut=\\\"^O\\\", name=\\\"System Overview\\\")\\n self.register_form(StateManagerForm.id, StateManagerForm,\\n title=\\\"State Manager\\\", shortcut=\\\"^T\\\", name=\\\"State Manager\\\")\\n self.register_form(ModuleRunnerForm.id, ModuleRunnerForm,\\n title=\\\"Module Runner\\\", shortcut=\\\"^T\\\", name=\\\"Module Runner\\\")\\n self.init_forms()\",\n \"def register() -> None:\\n plot_backend = _get_plot_backend(\\\"matplotlib\\\")\\n plot_backend.register()\",\n \"def test_register_component_with_invalid_type_only_manager():\\n\\n with pytest.raises(InvalidComponentTypeError):\\n component = OnlyManagerMock()\\n application_services.register_component(component)\",\n \"def assign_store_manager(user_name: str, new_store_manager_name: str, store_name: str):\\n\\n user_name = auth.get_username_from_hash(user_name)\\n permission_handler.is_permmited_to(user_name, Action.ADD_MANAGER.value, store_name)\\n permission_handler.assign_store_employee(action.MANAGER_INITIAL_PERMISSIONS,\\n new_store_manager_name,\\n store_name)\\n user_handler.assign_store_employee(user_name, new_store_manager_name, store_name)\",\n \"def load_components(self, on_initialize=False):\\n for name, component_data in self.components.items():\\n start_on_initialize = component_data.get('on_initialize', False)\\n if start_on_initialize == on_initialize:\\n component_data.pop('on_initialize', None)\\n\\n # inject parent module in component\\n if not component_data.get('options', None):\\n component_data['options'] = {}\\n\\n component_data['options']['module'] = self\\n component = RonObject.instanceObject(component_data)\\n setattr(self, name, component)\",\n \"async def reinit_manager(ctx):\\n await ext_manager.reinit()\\n await ctx.send(\\\"Successfully reinitialize.\\\")\",\n \"def init_login_manager():\\n login_manager = LoginManager()\\n login_manager.init_app(app)\\n return login_manager\",\n \"def register ():\\n dsf_geom_import.register ()\\n dsf_morph_import.register ()\\n dsf_morph_export.register ()\\n dsf_uvset_import.register ()\\n dsf_arm_import.register ()\\n dsf_pose_import.register ()\\n dsf_wm_import.register ()\\n dsf_geom_export.register ()\\n dsf_prop_export.register ()\",\n \"def new_manager() -> SyncManager:\\n return Manager()\",\n \"def create_manager(\\n pdb_hierarchy,\\n geometry_restraints_manager,\\n fmodel,\\n wavelength,\\n params,\\n resolution_factor = 0.25,\\n nproc = Auto,\\n verbose = False,\\n log = None,\\n manager_class=None):\\n connectivity = \\\\\\n geometry_restraints_manager.shell_sym_tables[0].full_simple_connectivity()\\n if (manager_class is None):\\n manager_class = manager\\n manager_obj = manager_class(\\n fmodel = fmodel,\\n pdb_hierarchy = pdb_hierarchy,\\n xray_structure = fmodel.xray_structure,\\n connectivity = connectivity,\\n wavelength = wavelength,\\n params = params,\\n nproc = nproc,\\n verbose = verbose,\\n log = log)\\n return manager_obj\",\n \"def name(self):\\n return \\\"component_manager\\\"\",\n \"def manager_configs_list(self):\\n _, body = self.request('/v1.1/managers/configs', 'GET')\\n return body\",\n \"def create(self, context, data, is_auto_import=False):\\n db_session_event = 'create-resource_mgr'\\n db_session = self.db_api.get_transactional_session(\\n db_session_event)\\n state_map = {eon_const.RESOURCE_MGR_STATE_KEY:\\n eon_const.EON_RESOURCE_MANAGER_STATE_REGISTERED}\\n property_list = []\\n try:\\n _validate_create(context, self.db_api, data,\\n eon_const.EON_RESOURCE_MANAGER)\\n resource_mgr_type = data.get('type')\\n resource_mgr_driver = driver.load_resource_mgr_driver(\\n resource_mgr_type)\\n data = resource_mgr_driver.validate_create(context, data)\\n\\n LOG.info(\\\"Registering resource manager, context: %s\\\",\\n logging.mask_password(data))\\n db_resource_mgr_data = self.db_api.create_resource_manager(\\n context, data, session=db_session)\\n properties = resource_mgr_driver.get_properties(state_map)\\n for property_key, property_value in properties.iteritems():\\n property_list.append(\\n self.db_api.create_resource_mgr_property(\\n context, db_resource_mgr_data['id'],\\n property_key, property_value, session=db_session)\\n )\\n resource_mgr_dict = _make_response(db_resource_mgr_data,\\n property_list=property_list)\\n resource_mgr_driver.update_vc_pass_through(context,\\n resource_mgr_dict)\\n self.db_api.commit_session(db_session_event, db_session)\\n return resource_mgr_dict\\n except (exception.AddressResolutionFailure,\\n exception.InternalFailure,\\n exception.ResourceExists,\\n exception.UnsupportedVCenterVersion,\\n exception.VCenterRegisterFailure\\n ) as e:\\n self.db_api.rollback_session('create-resource_mgr', db_session)\\n msg = (_(\\\"Registering resource manager failed. Reason: '%s'\\\")\\n % e.message)\\n log_msg = ((\\\"Registering resource manager failed. Reason: '%s'\\\")\\n % e.message)\\n LOG.error(log_msg)\\n raise exception.CreateException(msg=msg)\\n except Exception as e:\\n LOG.exception(e)\\n self.db_api.rollback_session('create-resource_mgr', db_session)\\n msg = (_(\\\"Registering resource manager failed. Reason: '%s'\\\")\\n % e)\\n log_msg = ((\\\"Registering resource manager failed. Reason: '%s'\\\")\\n % e)\\n LOG.error(log_msg)\\n raise exception.CreateException(msg=msg)\",\n \"def GetManager(self):\\r\\n\\r\\n return self.manager\",\n \"def manager_factory(manager_type):\\n return {\\n 'web': WebManager,\\n 'github': GitHubManager,\\n 'apkdownloadmirror': ApkDownloadMirrorManager,\\n 'apkplz': ApkPlzManager,\\n }[manager_type]\",\n \"def create_manager(self, username, tenancy):\\n raise NotImplementedError\",\n \"def initialize_location_strategies(self):\\n locator_manager.register_locators(\\\"sf\\\", lex_locators)\\n locator_manager.register_locators(\\\"text\\\", \\\"Salesforce.Locate Element by Text\\\")\\n locator_manager.register_locators(\\\"title\\\", \\\"Salesforce.Locate Element by Title\\\")\\n\\n # This does the work of actually adding all of the above-registered\\n # location strategies, plus any that were registered by keyword\\n # libraries.\\n locator_manager.add_location_strategies()\",\n \"def __init__(self, decorated_object=None,\\n\\t\\t\\t\\t # The following args will only be used if we need to\\n\\t\\t\\t\\t # create a default PluginManager\\n\\t\\t\\t\\t categories_filter=None, \\n\\t\\t\\t\\t directories_list=None, \\n\\t\\t\\t\\t plugin_info_ext=\\\"yapsy-plugin\\\"):\\n\\t\\tif directories_list is None:\\n\\t\\t\\tdirectories_list = [os.path.dirname(__file__)]\\n\\t\\tif categories_filter is None:\\n\\t\\t\\tcategories_filter = {\\\"Default\\\": IPlugin}\\n\\t\\tif decorated_object is None:\\n\\t\\t\\tlog.debug(\\\"Creating a default PluginManager instance to be decorated.\\\")\\n\\t\\t\\tfrom yapsy.PluginManager import PluginManager\\n\\t\\t\\tdecorated_object = PluginManager(categories_filter, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t directories_list,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t plugin_info_ext)\\n\\t\\tself._component = decorated_object\",\n \"def register_router(self, router):\\n for prefix, viewset, basename in router.registry:\\n self.register(prefix, viewset, base_name=basename)\",\n \"def manager_update(self, manager, config):\\n self.request('/v1.1/managers/configs/%s' % manager, 'POST', body=config)\",\n \"def install():\\n ArticleDataProvider.register()\\n ProductDataProvider.register()\",\n \"def modules(self):\\n return ModuleManager(self)\",\n \"def register(self):\\n\\n RPCObjectsRegistry.add(self)\",\n \"def add_providers(self):\\n str_providers = PROVIDERS[0] # Providers, called by name\\n live_providers = PROVIDERS[1] # Providers, provided as a live module\\n for providers in PROVIDERS: # Iterate over the types of providers\\n for provider in providers: # Iterate over all the methods\\n # Inject those into faker, and swap the numpy instance\\n self.fake.add_faker(self._swap_numpy(provider[0]), provider[1])\",\n \"def cluster_manager(self):\\n # Lazily instantiate the cluster manager the first time it is asked for.\\n if not hasattr(self, '_cluster_manager'):\\n if self._cluster_engine:\\n self._cluster_manager = self._cluster_engine.create_manager(\\n self._username,\\n self._tenancy\\n )\\n else:\\n self._cluster_manager = None\\n # If there is still no cluster manager, clusters are not supported\\n if not self._cluster_manager:\\n raise errors.UnsupportedOperationError(\\n 'Clusters are not supported for this tenancy.'\\n )\\n return self._cluster_manager\",\n \"def register(self, obj):\\r\\n name = obj._component_name\\r\\n if name in self.components:\\r\\n raise ComponentAlreadyRegistered(\\\"Component already registered with name %s\\\" % name)\\r\\n\\r\\n self.components[obj._component_name] = obj\",\n \"def setup_applications(self, configs):\\n self.__applications = self.setup_components(configs, 'scale_client.applications')\",\n \"def RegisterPlugins(cls, plugin_classes):\\n for plugin_class in plugin_classes:\\n cls.RegisterPlugin(plugin_class)\",\n \"def get_manager(self, name):\\n\\n if name == \\\"control\\\":\\n manager = self._control_manager\\n elif name == \\\"alarm\\\":\\n manager = self._alarm_manager\\n elif name == \\\"state\\\":\\n manager = self._machine_manager\\n else:\\n manager = self._function_manager\\n\\n return manager\",\n \"def _load_services(self) -> None:\\n # load default services\\n self.service_errors = ServiceManager.load_locals()\\n # load custom services\\n service_paths = self.config.get(\\\"custom_services_dir\\\")\\n logger.debug(\\\"custom service paths: %s\\\", service_paths)\\n if service_paths is not None:\\n for service_path in service_paths.split(\\\",\\\"):\\n service_path = Path(service_path.strip())\\n custom_service_errors = ServiceManager.add_services(service_path)\\n self.service_errors.extend(custom_service_errors)\\n # load default config services\\n self.service_manager.load_locals()\\n # load custom config services\\n custom_dir = self.config.get(\\\"custom_config_services_dir\\\")\\n if custom_dir is not None:\\n custom_dir = Path(custom_dir)\\n self.service_manager.load(custom_dir)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61248213","0.60335684","0.6032508","0.5993886","0.59699","0.58547497","0.5809432","0.56251633","0.56170464","0.56035906","0.55961794","0.5585247","0.5480994","0.54456997","0.53996974","0.53993297","0.53955936","0.5385212","0.5380328","0.5357524","0.5357201","0.533299","0.5320499","0.52582926","0.52460986","0.5233379","0.5221362","0.52081925","0.51999635","0.5195066","0.5193746","0.51922303","0.51760864","0.51694715","0.51673794","0.5164503","0.51582074","0.5147668","0.513086","0.51137227","0.50975055","0.5073879","0.5054857","0.505423","0.5053067","0.5046912","0.5043652","0.5021995","0.50216466","0.50186616","0.5010807","0.50026375","0.4996631","0.49931994","0.49911916","0.49739933","0.49595675","0.49578902","0.495659","0.49558765","0.49488616","0.4937598","0.4913847","0.49093628","0.490864","0.48923746","0.48889267","0.48828682","0.48801798","0.48782927","0.4876957","0.487522","0.4870299","0.4868382","0.48671073","0.4857407","0.48494583","0.48493576","0.48426664","0.48348826","0.4833626","0.4814708","0.48133957","0.48038936","0.47828802","0.47734305","0.47704604","0.4757468","0.47556448","0.47353315","0.4734898","0.47326916","0.47323754","0.4727316","0.47263557","0.47233054","0.47166884","0.47139576","0.47077596","0.47063518"],"string":"[\n \"0.61248213\",\n \"0.60335684\",\n \"0.6032508\",\n \"0.5993886\",\n \"0.59699\",\n \"0.58547497\",\n \"0.5809432\",\n \"0.56251633\",\n \"0.56170464\",\n \"0.56035906\",\n \"0.55961794\",\n \"0.5585247\",\n \"0.5480994\",\n \"0.54456997\",\n \"0.53996974\",\n \"0.53993297\",\n \"0.53955936\",\n \"0.5385212\",\n \"0.5380328\",\n \"0.5357524\",\n \"0.5357201\",\n \"0.533299\",\n \"0.5320499\",\n \"0.52582926\",\n \"0.52460986\",\n \"0.5233379\",\n \"0.5221362\",\n \"0.52081925\",\n \"0.51999635\",\n \"0.5195066\",\n \"0.5193746\",\n \"0.51922303\",\n \"0.51760864\",\n \"0.51694715\",\n \"0.51673794\",\n \"0.5164503\",\n \"0.51582074\",\n \"0.5147668\",\n \"0.513086\",\n \"0.51137227\",\n \"0.50975055\",\n \"0.5073879\",\n \"0.5054857\",\n \"0.505423\",\n \"0.5053067\",\n \"0.5046912\",\n \"0.5043652\",\n \"0.5021995\",\n \"0.50216466\",\n \"0.50186616\",\n \"0.5010807\",\n \"0.50026375\",\n \"0.4996631\",\n \"0.49931994\",\n \"0.49911916\",\n \"0.49739933\",\n \"0.49595675\",\n \"0.49578902\",\n \"0.495659\",\n \"0.49558765\",\n \"0.49488616\",\n \"0.4937598\",\n \"0.4913847\",\n \"0.49093628\",\n \"0.490864\",\n \"0.48923746\",\n \"0.48889267\",\n \"0.48828682\",\n \"0.48801798\",\n \"0.48782927\",\n \"0.4876957\",\n \"0.487522\",\n \"0.4870299\",\n \"0.4868382\",\n \"0.48671073\",\n \"0.4857407\",\n \"0.48494583\",\n \"0.48493576\",\n \"0.48426664\",\n \"0.48348826\",\n \"0.4833626\",\n \"0.4814708\",\n \"0.48133957\",\n \"0.48038936\",\n \"0.47828802\",\n \"0.47734305\",\n \"0.47704604\",\n \"0.4757468\",\n \"0.47556448\",\n \"0.47353315\",\n \"0.4734898\",\n \"0.47326916\",\n \"0.47323754\",\n \"0.4727316\",\n \"0.47263557\",\n \"0.47233054\",\n \"0.47166884\",\n \"0.47139576\",\n \"0.47077596\",\n \"0.47063518\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74649"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":25999,"cells":{"query":{"kind":"string","value":"Register new components with the component manager. Components are configured and setup after managers."},"document":{"kind":"string","value":"def add_components(self, components: Union[List[Any], Tuple[Any]]):\n for c in self._flatten(components):\n self.apply_configuration_defaults(c)\n self._components.add(c)"},"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 register_component(var, config):\n id_ = text_type(var.base)\n if id_ not in CORE.component_ids:\n raise ValueError(u\"Component ID {} was not declared to inherit from Component, \"\n u\"or was registered twice. Please create a bug report with your \"\n u\"configuration.\".format(id_))\n CORE.component_ids.remove(id_)\n if CONF_SETUP_PRIORITY in config:\n add(var.set_setup_priority(config[CONF_SETUP_PRIORITY]))\n if CONF_UPDATE_INTERVAL in config:\n add(var.set_update_interval(config[CONF_UPDATE_INTERVAL]))\n add(App.register_component(var))\n yield var","def instantiate(self, components):\n with self.__lock:\n # Store the new components\n self._status.store(components)\n\n # Install required bundles\n bundles = set((component.bundle_name, component.bundle_version)\n for component in components)\n self._install_bundles(bundles)\n\n if self._agent is not None:\n # Instantiate them\n self._agent.handle(components)\n else:\n # Wait for an agent to come\n self._remaining.update(components)","def register(self, obj):\r\n name = obj._component_name\r\n if name in self.components:\r\n raise ComponentAlreadyRegistered(\"Component already registered with name %s\" % name)\r\n\r\n self.components[obj._component_name] = obj","def setup_components(self, builder: \"Builder\"):\n self._setup_components(builder, self._managers + self._components)","def setup_component(self):\n self.conf, self.context = self._init_component()\n self.initialize()","def create_allcomponents(self):\n\n # we store all components in a list/hash which we iterate for startup/shutdown/dumps debugging, and which can be used to lookup components\n self.components = MDictList()\n\n # setup log manager helper early so that log manager can receive messages (and queue them until startup)\n self.createappendcomp('logmanager', mlogger.MewloLogManager)\n\n # now update site state (log manager should catch this)\n self.set_statelabel(mconst.DEF_SITESTATE_INITIALIZE_START)\n\n # create (non-db-persistent) site settings -- these are set by configuration at runtime\n self.settings = self.createappendcomp('settings', MewloSettings)\n\n # database manager\n self.createappendcomp('dbmanager', mdbmanager_sqlalchemy.MewloDatabaseManagerSqlA)\n\n # component registry\n self.createappendcomp('registrymanager', mregistry.MewloRegistryManager)\n\n # signal dispatcher\n self.createappendcomp('signalmanager', msignal.MewloSignalManager)\n\n # rbac permission manager\n self.createappendcomp('rbacmanager', mrbac.MewloRbacManager)\n\n # create persistent(db) pack settings\n self.createappendcomp('packsettings', mdbsettings_pack.MewloSettingsDb_Pack)\n\n # collection of mewlo addon packs\n self.createappendcomp('packmanager', mpackmanager.MewloPackManager)\n\n # site addon manager\n #self.createappendcomp('siteaddonmanager', msiteaddon.MewloSiteAddonManager)\n\n # route manager\n self.createappendcomp('routemanager', mroute.MewloRouteManager)\n\n # navnode manager\n self.createappendcomp('navnodemanager', mnav.NavNodeManager)\n\n # template manager\n self.createappendcomp('templatemanager', mtemplate.MewloTemplateManager)\n\n # asset and alias manager\n self.createappendcomp('assetmanager', massetmanager.MewloAssetManager)\n\n # template helper (this is available inside template/views and provides helper functions like navigation menus, etc.)\n self.createappendcomp('templatehelper', mtemplatehelper.MewloTemplateHelper)\n\n # session manager\n self.createappendcomp('sessionmanager', msessionmanager.MewloSessionManager)\n\n # verification manager\n self.createappendcomp('verificationmanager', mverificationmanager.MewloVerificationManager)\n\n # user manager\n self.createappendcomp('usermanager', musermanager.MewloUserManager)\n\n # mail manager\n self.createappendcomp('mailmanager', mmailmanager.MewloMailManager)","def add(self, *components):\n for component in components:\n if component.container is not None:\n component.container.remove(component)\n component.container = self\n self._components.extend(components)","def register(self):\n self._register_dockyard()\n self._register_docker()","def components(self, components: List[IngredientObjectComponents]):\n\n self._components = components","def load_components(self, on_initialize=False):\n for name, component_data in self.components.items():\n start_on_initialize = component_data.get('on_initialize', False)\n if start_on_initialize == on_initialize:\n component_data.pop('on_initialize', None)\n\n # inject parent module in component\n if not component_data.get('options', None):\n component_data['options'] = {}\n\n component_data['options']['module'] = self\n component = RonObject.instanceObject(component_data)\n setattr(self, name, component)","def startup_allcomponents(self, eventlist):\n\n # walk the component list and ask each to register any db classes\n for key,obj in self.components.get_tuplelist():\n # pre startup - register database classes\n obj.prestartup_register(eventlist)\n\n # now that all database models have been registered with the system, finalize creation of models -- create all db tables, etc\n self.comp('dbmanager').create_tableandmapper_forallmodelclasses()\n\n # walk the component list and let each startup\n for key,obj in self.components.get_tuplelist():\n # start up the component\n obj.startup(eventlist)\n\n # walk the component list and let each do any post-startup\n for key,obj in self.components.get_tuplelist():\n # post startup\n obj.poststartup(eventlist)","def register_application_components(self, args, app: Application):\n raise NotImplementedError","def test_register_component():\n\n component = ComponentMock('component1')\n application_services.register_component(component)\n assert application_services.get_component('component1') == component\n application_services.remove_component(component.get_id())","def _set_components(self, components: List[base_node.BaseNode]) -> None:\n self._check_mutable()\n\n deduped_components = set(components)\n for upstream_component, component in enumerate_implicit_dependencies(\n list(deduped_components),\n registry=self.dsl_context_registry,\n pipeline=self,\n ):\n component.add_upstream_node(upstream_component)\n\n layers = topsort.topsorted_layers(\n list(deduped_components),\n get_node_id_fn=lambda c: c.id,\n get_parent_nodes=lambda c: c.upstream_nodes,\n get_child_nodes=lambda c: c.downstream_nodes)\n self._components = []\n for layer in layers:\n for component in layer:\n self._components.append(component)\n\n if self.beam_pipeline_args:\n for component in self._components:\n add_beam_pipeline_args_to_component(component, self.beam_pipeline_args)","def register(self, events=[]):\n self.events = events\n if not self in manager.handler:\n manager.handler.append(self)","def add(self, component) -> None:\n pass","def load_components(self):\n self_class = self.__class__\n\n # Lazy load component loader\n try:\n component_loader = self_class._component_loader\n\n if component_loader.component_tags != self_class.component_tags:\n raise AttributeError(\"Mismatch in component tags, reloading\")\n\n except AttributeError:\n component_loader = ComponentLoader(*self_class.component_tags)\n self_class._component_loader = component_loader\n\n class_name = self_class.__name__\n definitions = self_class._definitions\n\n # Lazy load definitions\n try:\n platform_definition = definitions[class_name]\n\n except KeyError:\n resources = ResourceManager[class_name]\n platform = ResourceManager.environment\n\n try:\n definition = resources[self_class.definition_name]\n\n except TypeError:\n raise FileNotFoundError(\"Could not find definition file for {}\".format(class_name))\n\n full_path = ResourceManager.get_absolute_path(definition)\n\n definition_sections = ConfigObj(full_path)\n platform_definition = definition_sections[platform]\n definitions[class_name] = platform_definition\n\n component_result = component_loader.load(self, platform_definition)\n\n # Load components\n for component_tag, component in component_result.components.items():\n setattr(self, component_tag, component)\n\n self._component_result = component_result","def register(self):\n\n RPCObjectsRegistry.add(self)","def add_component(self, new: components.Component) -> None:\n for existing in self.components:\n if isinstance(existing, type(new)):\n raise Exception(type(new))\n self.components.append(new)","def register_classes():\n DiffuseCompChain.register_class()\n CatalogCompChain.register_class()\n DiffuseAnalysisChain.register_class()","def components(build_reset, monkeypatch):\n controllers, visuals, htmls = create_components()\n\n app = App(__name__, rows=len(visuals), sidebar=True)\n for controller in controllers:\n # pylint: disable=protected-access\n assert COMPONENT_REGISTRY[controller._uuid] == controller\n app.add_sidebar(controller)\n\n for vis in visuals:\n # pylint: disable=protected-access\n assert COMPONENT_REGISTRY[vis._uuid] == vis\n app.add(vis)\n\n for htm in htmls:\n # pylint: disable=protected-access\n assert COMPONENT_REGISTRY[htm._uuid] == htm\n app.add_sidebar(htm)\n\n assert len(COMPONENT_REGISTRY) == len(controllers) + 2 * len(visuals) + len(htmls)\n\n # pylint: disable=protected-access\n app._build()\n\n # run second time to make sure nothing weird happens with subsequent builds\n app._build()\n\n with server_check(app) as server:\n yield server","def register(self):\n if self.registered:\n return\n\n config = current_app.config.get('TERMINAL_CONFIGS', {})\n apps = config.get('apps', [])\n\n for app in apps:\n cls, mod = app.rsplit('.', maxsplit=1)\n imported = import_module(cls)\n instance = getattr(imported, mod)()\n\n if getattr(instance, 'name', None) is None:\n continue\n\n if getattr(instance, 'hidden', False):\n self.hidden[getattr(instance, 'name')] = instance\n else:\n self.apps[getattr(instance, 'name')] = instance\n\n self.__set_apps_aliases(getattr(instance, 'name'), getattr(instance, 'aliases'))\n\n self.registered = True","def _add_component(self, __assistant):\r\n\r\n # Retrieve the hardware ID.\r\n _model = self.cmbHardware.get_model()\r\n _row = self.cmbHardware.get_active_iter()\r\n _hardware_id = int(_model.get_value(_row, 1))\r\n\r\n self._controller.add_component(self._incident_id, _hardware_id)\r\n self._workbook.load_component_list()\r\n\r\n return False","def registerType(cls, type):\n # NOTE Subclasses must be registered via this method in order to be initialized from XML, etc.\n cls.componentTypes[type.__name__] = type\n #print \"Component.registerType(): Component type \\'\" + type.__name__ + \"\\' registered.\" # [debug]","def register ():\n dsf_geom_import.register ()\n dsf_morph_import.register ()\n dsf_morph_export.register ()\n dsf_uvset_import.register ()\n dsf_arm_import.register ()\n dsf_pose_import.register ()\n dsf_wm_import.register ()\n dsf_geom_export.register ()\n dsf_prop_export.register ()","def startComponent(self):\n self.ms = MessageService()\n self.ms.registerAs(\"TaskRegisterComponent\")\n \n self.ms.subscribeTo(\"CRAB_Cmd_Mgr:NewTask\")\n self.ms.subscribeTo(\"TaskRegisterComponent:StartDebug\")\n self.ms.subscribeTo(\"TaskRegisterComponent:EndDebug\")\n self.ms.subscribeTo(\"KillTask\")\n\n self.ms.subscribeTo(\"TaskRegisterComponent:HeartBeat\")\n self.ms.remove(\"TaskRegisterComponent:HeartBeat\")\n self.ms.publish(\"TaskRegisterComponent:HeartBeat\",\"\",self.HeartBeatDelay)\n self.ms.commit()\n\n # TaskRegister registration in WMCore.MsgService\n self.myThread = threading.currentThread()\n self.factory = WMFactory(\"msgService\", \"WMCore.MsgService.\"+ \\\n self.myThread.dialect)\n self.newMsgService = self.myThread.factory['msgService'].loadObject(\"MsgService\")\n self.myThread.transaction.begin()\n self.newMsgService.registerAs(\"TaskRegisterComponent\")\n self.myThread.transaction.commit()\n\n #\n # non blocking call event handler loop\n # this allows us to perform actions even if there are no messages\n #\n try: \n while True:\n # dispatch loop for Queued messages\n while True:\n try:\n senderId, evt, pload = self.sharedQueue.get_nowait()\n taskUniqName = pload.split(\"::\")[0]\n\n # dealloc threadId\n if senderId not in self.availWorkersIds:\n self.availWorkersIds.append(senderId)\n\n # dispatch the messages and update status \n if evt in [\"TaskRegisterComponent:NewTaskRegisteredPartially\"]:\n logging.info(\"Task %s registred Partially\"%taskUniqName) \n elif evt in [\"TaskRegisterComponent:NewTaskRegistered\"] and taskUniqName not in self.killingRequestes:\n self.ms.publish(evt, pload)\n logging.info(\"Publish Event: %s %s\" % (evt, pload))\n self.ms.commit()\n elif evt in [\"RegisterWorkerComponent:WorkerFailsToRegisterPartially\"]:\n logging.info(\"Task %s failed partially\"%taskUniqName)\n elif evt in [\"RegisterWorkerComponent:RegisterWorkerFailed\"]:\n logging.info(\"Task %s failed\"%taskUniqName)\n self.markTaskAsNotSubmitted(taskUniqName, 'all')\n self.ms.publish(evt, pload)\n logging.info(\"Publish Event: %s %s\" % (evt, pload))\n self.ms.commit()\n elif taskUniqName in self.killingRequestes:\n logging.info(\"Task %s killed by user\"%taskUniqName)\n self.markTaskAsNotSubmitted(taskUniqName, self.killingRequestes[taskUniqName])\n del self.killingRequestes[taskUniqName]\n\n except Queue.Empty, e:\n logging.debug(\"Queue empty: \" + str(e))\n break\n except Exception, exc:\n logging.error(\"'Generic' problem: \" + str(exc))\n logging.error( str(traceback.format_exc()) )\n\n if len(self.availWorkersIds) > 0:\n try:\n type, payload = self.ms.get( wait = False )\n\n if type is None:\n time.sleep( self.ms.pollTime )\n continue\n else:\n self.__call__(type, payload)\n self.ms.commit()\n except Exception, exc:\n logging.error(\"ERROR: Problem managing message...\")\n logging.error(str(exc))\n except Exception, e:\n logging.error(e)\n logging.info(traceback.format_exc())\n\n return","def __init__(self, *components) -> None:\n self.__components = list(components)","def add_comp(self, name, ctype):\n\n name = self.name + '.' + name\n\n assert name not in self.components, 'A component named \\'{}\\' already exists for node \\'{}\\''.format(\n name, self.name)\n\n try:\n cls = co.str_to_comp(ctype)\n except AttributeError:\n try:\n cls = rc.str_to_comp(ctype)\n except AttributeError:\n cls = None\n\n if cls:\n obj = cls(name=name,\n temperature_driven=self.temperature_driven,\n repr_days=self.repr_days)\n else:\n raise ValueError(\n \"%s is not a valid class name! (component is %s, in node %s)\" % (\n ctype, name, self.name))\n\n self.logger.info('Component {} added to {}'.format(name, self.name))\n\n self.components[name] = obj","def register(self):\n raise NotImplementedError","def register(self):\n raise NotImplementedError","def install():\n ArticleDataProvider.register()\n ProductDataProvider.register()","def register(self):\n raise NotImplementedError(\"Should have implemented this\")","def add_component(self, lib_component):\n comp_name = lib_component.name\n try:\n comp = self.__component_list[comp_name]\n except KeyError:\n self.__component_list[comp_name] = lib_component","def register(self):\n # Register generic implementations for all jitclasses\n self._register_methods(self.class_impl_registry,\n self.class_type.instance_type)\n # NOTE other registrations are done at the top-level\n # (see ctor_impl and attr_impl below)\n self.targetctx.install_registry(self.class_impl_registry)","def register_packages(self, module_name, extra_package):\n self.creator_manager.register_packages(module_name, extra_package)","def register() -> None:\n plot_backend = _get_plot_backend(\"matplotlib\")\n plot_backend.register()","def test_component_add_ok(self):\n test_name = sys._getframe().f_code.co_name\n self._execute('component add new_component new_user')\n rv, output = self._execute('component list')\n self.assertEqual(0, rv)\n self.assertEqual(self.expected_results[test_name], output)","def register(self):\n raise NotImplementedError()","def add_packages(self, component_name, packages):\n for pkg in packages:\n self.add_package(component_name, pkg)","def create_components():\n reset_uuid()\n # pylint: disable=protected-access\n controllers = []\n for compstr in dir(control):\n comp = getattr(control, compstr)\n if (compstr[0] != '_' and isclass(comp) and issubclass(comp, control._Controller)\n and compstr != 'Upload'):\n controllers.append(comp())\n\n for controller in controllers:\n assert COMPONENT_REGISTRY[controller._uuid] == controller\n\n visuals = []\n for compstr in dir(visual):\n comp = getattr(visual, compstr)\n if compstr[0] != '_' and isclass(comp) and issubclass(comp, visual._Visual):\n visuals.append(comp())\n\n for vis in visuals:\n assert COMPONENT_REGISTRY[vis._uuid] == vis\n\n htmls = []\n for compstr in dir(html):\n comp = getattr(html, compstr)\n if compstr[0] != '_' and isclass(comp) and issubclass(comp, html._HTML):\n htmls.append(comp())\n\n for htm in htmls:\n assert COMPONENT_REGISTRY[htm._uuid] == htm\n\n return controllers, visuals, htmls","def __components__():\n # Get the component registry of the active application.\n registry = context.app.component_registry\n # A shortcut: return cached components.\n if registry.components is not None:\n return registry.components\n # A list of `Component` subclasses defined in modules exported by addons.\n components = [Component]\n idx = 0\n while idx < len(components):\n for subclass in components[idx].__subclasses__():\n # Skip realizations.\n if issubclass(subclass, Realization):\n continue\n # Check if the component belongs to the current application.\n if subclass.__enabled__():\n components.append(subclass)\n idx += 1\n # Cache and return the components.\n registry.components = components\n return components","def name(self):\n return \"component_manager\"","def add_components(self, comps):\r\n if not isinstance(comps, list):\r\n comps = [comps]\r\n for comp in comps:\r\n self.comps.append(comp)","def register(cls, L):\r\n ...","def item_components(self, item_components):\n\n self._item_components = item_components","def test_register(self):\n self._configure_testshib_provider()\n self._test_register()","def add(self, comp):\n\t\tif comp:\n\t\t\tif isinstance(comp, Component):\n\t\t\t\tcomp.container = self\n\t\t\telse:\n\t\t\t\tfor item in comp:\n\t\t\t\t\tself.add(item)","def register(self, module):\n tagvalues = \"\\n\".join([\"%s: %s\" % (attr, str(getattr(module, attr))) for attr in dir(module) if attr in ['create', 'menu', 'name', 'label'] ])\n # tagvalues = \"\\n\".join([\"%s\" % (attr) for attr in dir(module) if attr not in ['urls'] ])\n logger.debug(\"module {} registered.\\ndir : {}\".format(module.label, tagvalues ))\n self._registry[module.label] = module\n self._modules[module.name] = module\n pass","def register(cls):\n register(cls, cls.provided_class)","def register_classes():\n CoaddSplit.register_class()\n CoaddSplit_SG.register_class()","def list_components(self, request, context):\n response = ListComponentsResponse()\n for component in self._delegator.list_components():\n response.components.append(component)\n return response","def register_resources(self):\n raise NotImplementedError","def __init__(self, component):\r\n self.component = component","def __init__(self, component):\r\n self.component = component","def register(self):\n self.logger.info(\"Registering agent %s\", \"/registry/\" + self._configuration[\"identification\"][\"uuid\"])\n self._coordination.update(\"/registry/\" + self._configuration[\"identification\"][\"uuid\"], self._configuration[\"identification\"])","def register(self, *model):\n for m in model:\n m.Register()\n self.models.append(m)","def set_up():\n ResourcesManager().set_up()\n LocatorUtil().load_locators()","def component(self, component):\n\n self._component = component","def component(self, component):\n\n self._component = component","def test_component_set_successful(self):\n # We create an instance of the panel so we can check existing values\n panel = ComponentAdminPanel(self.env)\n\n # Check the environment initially contains the default values.\n self.assertItemsEqual(panel.get_component_list(), self.default['component'])\n\n # create the section, option, and values in configuration\n self.env.config.set('ticket-field-config', 'component',\n ','.join(self.new['component']))\n # create component_owner option\n self.env.config.set('ticket-field-config','component_owner','test')\n\n admin_command = TicketFieldConfigCommand(self.env)\n\n # run our plugin\n admin_command.set_fields_from_config()\n\n self.assertItemsEqual(panel.get_component_list(), self.new['component'])","def components(self):\r\n return [JSONComponent(c) for c\r\n in self.container.get(\"ComponentInstances\", [])]","def test_register_dynamic_plugin_manager1(self):\n pass","def register_models(self):\n models = self.configs_['pipeline_models']\n\n for i in range(0, len(models)):\n new_model = PipelineModel(models[i], self.score_method_,\n self.predict_as_probability_)\n\n if not new_model.init():\n print 'Error registering model', models[i]['model']['id'],\\\n 'in ensemble'\n return False\n print 'Model', new_model.get_name(), 'registered in ensemble'\n self.models_.append((models[i]['model']['id'],\n new_model.get_sklearn_pipeline()))\n\n if 'weight' not in models[i]:\n self.model_weights_.append(1)\n else:\n self.model_weights_.append(models[i]['weight'])\n return True","def register_models(self, *models, **kwargs):\n\n for model in models:\n self.register(model, **kwargs)","def _initComponent(self):\n\n self.optimizer = self._initOptimizer()\n self.scheduler = self._initScheduler()","def setup(self, configuration, lifecycle_manager):\n self.configuration = configuration\n self.lifecycle = lifecycle_manager\n\n self.lifecycle.add_constraint(\n self.get_components_by_type,\n restrict_during=[\"initialization\", \"population_creation\"],\n )\n self.lifecycle.add_constraint(\n self.get_component, restrict_during=[\"population_creation\"]\n )\n self.lifecycle.add_constraint(\n self.list_components, restrict_during=[\"initialization\"]\n )","def consul_register(self):\n self.log.debug(\"consul-register\")\n self.consul.agent.service.register(\n self.svc_name,\n address=self.this_host,\n check=consulate.models.agent.Check(\n name=\"qemu-process\",\n args=[\n \"/bin/sh\",\n \"-c\",\n \"test -e /proc/$(< /run/qemu.{}.pid )/mem || exit 2\".format(\n self.name\n ),\n ],\n interval=\"5s\",\n ),\n )","def setup(self, registry):\n logger.info(\"%s %s\", self.dist_name, self.version)\n\n from .frontend import AutoplayFrontend\n registry.add(\"frontend\", AutoplayFrontend)","def at_added(self, host):\n\n if self.host:\n if self.host == host:\n return\n else:\n raise ComponentRegisterError(\"Components must not register twice!\")\n\n self.host = host","def _register_services(self, pipeline):\n\n pipeline.register_service(self._aprs_service)","def build(self):\n for component, type in self.__get_data(\"comps\").items():\n self.add_comp(component, type)\n\n self.logger.info('Build of {} finished'.format(self.name))","def test_register_dynamic_plugin_manager(self):\n pass","def addAllFactories(self) -> None:\n ...","def populate_componentControls(self):\n # populate tab\n self.tabs.insertTab(1, self.settingsTab, \"Component Settings\")\n\n refArrayItems = self.root.attr(\"ikrefarray\").get().split(\",\")\n for item in refArrayItems:\n self.settingsTab.refArray_listWidget.addItem(item)","def create_new_component(self, cname):\n while True:\n try:\n self.model.get_component_by_name(cname)\n cname += u'_'\n except KeyError:\n # Component with this name doesn't exist\n break\n # Create the component\n comp = cellml_component.create_new(self.model, cname)\n self.model._add_component(comp)\n return comp","def _add_custom_components(self, components, policy_statements, components_resources):\n initial_components_len = len(components)\n arn_components_len = 0\n for custom_component in self.config.build.components:\n custom_components_len = len(components) - initial_components_len - arn_components_len\n if custom_component.type == \"arn\":\n components.append(\n imagebuilder.CfnImageRecipe.ComponentConfigurationProperty(component_arn=custom_component.value)\n )\n arn_components_len += 1\n else:\n component_script_name = custom_component.value.split(\"/\")[-1]\n component_id = \"ScriptComponent\" + str(custom_components_len)\n custom_component_resource = imagebuilder.CfnComponent(\n self,\n component_id,\n name=self._build_resource_name(\n IMAGEBUILDER_RESOURCE_NAME_PREFIX + \"-Script-{0}\".format(str(custom_components_len))\n ),\n version=utils.get_installed_version(base_version_only=True),\n description=\"This component is custom component for script, script name is {0}, script url is \"\n \"{1}\".format(component_script_name, custom_component.value),\n platform=\"Linux\",\n data=wrap_script_to_component(custom_component.value),\n )\n components.append(\n imagebuilder.CfnImageRecipe.ComponentConfigurationProperty(component_arn=Fn.ref(component_id))\n )\n components_resources.append(custom_component_resource)\n if not self.custom_cleanup_lambda_role:\n self._add_resource_delete_policy(\n policy_statements,\n [\"imagebuilder:DeleteComponent\"],\n [\n self.format_arn(\n service=\"imagebuilder\",\n resource=\"component\",\n resource_name=\"{0}/*\".format(\n self._build_resource_name(\n IMAGEBUILDER_RESOURCE_NAME_PREFIX\n + \"-Script-{0}\".format(str(custom_components_len)),\n to_lower=True,\n )\n ),\n )\n ],\n )","def __init__(self, services, config):\n #pytau.setNode(1)\n #timer = pytau.profileTimer(\"component.__init__\", \"\", str(os.getpid()))\n #pytau.start(timer)\n self.component_id = None\n self.invocation_q = None\n self.services = weakref.proxy(services)\n self.config = config\n self.start_time=0.0\n self.sys_exit = None\n for i in config.keys():\n try:\n setattr(self, i, config[i])\n except Exception, e:\n print 'Error setting Component parameter : ', i, ' - ', e\n #pytau.stop(timer)\n raise\n\n #pytau.stop(timer)","def register_router(self, router):\n for prefix, viewset, basename in router.registry:\n self.register(prefix, viewset, base_name=basename)","def register(self):\n\n registerables = []\n registerables.append(swf.Domain(name=self.domain))\n registerables.append(swf.WorkflowType(\n domain=self.domain,\n name=self.task_list,\n version=self.version,\n task_list=self.task_list))\n\n for current_activity in self.activities:\n registerables.append(\n swf.ActivityType(\n domain=self.domain,\n name=current_activity.name,\n version=self.version,\n task_list=current_activity.task_list))\n\n for swf_entity in registerables:\n try:\n swf_entity.register()\n except (SWFDomainAlreadyExistsError, SWFTypeAlreadyExistsError):\n print(\n swf_entity.__class__.__name__, swf_entity.name,\n 'already exists')","def on_register(cls):","def register_resources(self, resources):\n for resource in resources:\n self.register_resource(resource)","def _process_configureComponent(self, data):\r\n for node in data.pop('addNodes', []):\r\n try:\r\n self._avatar.addNode(node['containerTag'],\r\n node['nodeTag'],\r\n node['pkg'],\r\n node['exe'],\r\n node.get('args', ''),\r\n node.get('name', ''),\r\n node.get('namespace', ''))\r\n except KeyError as e:\r\n raise InvalidRequest(\"Can not process 'ConfigureComponent' \"\r\n \"request. 'addNodes' is missing key: \"\r\n '{0}'.format(e))\r\n\r\n for node in data.pop('removeNodes', []):\r\n try:\r\n self._avatar.removeNode(node['containerTag'],\r\n node['nodeTag'])\r\n except KeyError as e:\r\n raise InvalidRequest(\"Can not process 'ConfigureComponent' \"\r\n \"request. 'removeNodes' is missing key: \"\r\n '{0}'.format(e))\r\n\r\n for conf in data.pop('addInterfaces', []):\r\n try:\r\n self._avatar.addInterface(conf['endpointTag'],\r\n conf['interfaceTag'],\r\n conf['interfaceType'],\r\n conf['className'],\r\n conf.get('addr', ''))\r\n except KeyError as e:\r\n raise InvalidRequest(\"Can not process 'ConfigureComponent' \"\r\n \"request. 'addInterfaces' is missing \"\r\n 'key: {0}'.format(e))\r\n\r\n for conf in data.pop('removeInterfaces', []):\r\n try:\r\n self._avatar.removeInterface(conf['endpointTag'],\r\n conf['interfaceTag'])\r\n except KeyError as e:\r\n raise InvalidRequest(\"Can not process 'ConfigureComponent' \"\r\n \"request. 'removeInterfaces' is missing \"\r\n 'key: {0}'.format(e))\r\n\r\n for param in data.pop('setParam', []):\r\n try:\r\n self._avatar.addParameter(param['containerTag'],\r\n param['name'],\r\n param['value'])\r\n except KeyError as e:\r\n raise InvalidRequest(\"Can not process 'ConfigureComponent' \"\r\n \"request. 'setParam' is missing key: \"\r\n '{0}'.format(e))\r\n\r\n for param in data.pop('deleteParam', []):\r\n try:\r\n self._avatar.removeParameter(param['containerTag'],\r\n param['name'])\r\n except KeyError as e:\r\n raise InvalidRequest(\"Can not process 'ConfigureComponent' \"\r\n \"request. 'deleteParam' is missing key: \"\r\n '{0}'.format(e))","def register():\n \n global _registered\n if not _registered:\n _registered = True\n sys.path_hooks.insert(0, VFSImporter)","def antenny_init_components(self):\n if self.antenny_config is None:\n print(\"Please load a config before initializing components\")\n if not self.antenny_config.check():\n print(\"Config {} is not valid, failed to initialize\".format(self.antenny_config.get_name()))\n print(\"If you believe this is an error, or you have modified the base components of the antenny board, \"\n \"please check Config class as well as the default configs for more details.\")\n\n self.imu_init()\n self.pwm_controller_init()\n self.elevation_servo_init()\n self.azimuth_servo_init()\n self.screen_init()\n self.gps_init()\n self.telemetry_init()\n self.platform_init()","def _register(self, comm, handler):","def appendcomp(self, componentname, component):\n self.components.append(componentname, component)\n return component","def register_plugins(self):\n if self.plugin_whitelist:\n plugin_list = self.plugin_whitelist\n else:\n plugin_list = plugins.__all__\n\n for plugin in plugin_list:\n if plugin in plugins.__all__:\n self.register_plugin(plugin,\n self.plugin_config.get(plugin, {}))\n else:\n raise NameError(\"Plugin %s not in plugins.__all__.\" % plugin)\n\n # Resolve plugin inter-dependencies.\n for plugin in self.plugin:\n self.plugin[plugin].post_init()","def registered(self):\n log.info(\"Registered.\")\n pass","def RegisterPlugins(cls, plugin_classes):\n for plugin_class in plugin_classes:\n cls.RegisterPlugin(plugin_class)","def register_specs(self, *args):\n self._corespecs_queue.extend(*args)","def RegisterService():\n hooks.RegisterHook(SERVICE_NAME, 'file-exists', hook_class=HookForExists)\n hooks.RegisterHook(SERVICE_NAME, 'file-write',\n hook_class=HookForWriteAndTouch)\n hooks.RegisterHook(SERVICE_NAME, 'file-touch',\n hook_class=HookForWriteAndTouch)\n hooks.RegisterHook(SERVICE_NAME, 'file-get', hook_class=HookForGet)\n hooks.RegisterHook(SERVICE_NAME, 'list-files', hook_class=HookForListFiles)\n hooks.RegisterHook(SERVICE_NAME, 'list-dir', hook_class=HookForListDir)","def register(self):\n self.app.bind('CreateSuperUserCommand', CreateSuperUser())\n self.app.bind('InstallCommand', Install())\n self.app.bind(\n 'AdminUserMigrationDirectory',\n os.path.join(package_directory, 'migrations')\n )","def register(mgr):\n mgr.set_lang_info(lang,\n silvercity_lexer=CSSLexer(),\n buf_class=CSSBuffer,\n langintel_class=CSSLangIntel,\n is_cpln_lang=True)","def setup(self, manager):\n self._manager = manager\n self._configured = True","def register(self):\n #self._defaultPrefs=[InstalledPackage(\"Dummy\",0,\"dummy\")]\n defaults=NSUserDefaults.standardUserDefaults()\n print \"got prefs\"\n defaults.registerDefaults_(self._defaultPrefs)\n print \"registered defaults\"\n installed=defaults.objectForKey_('installedPackages')\n print \"got installed\"\n print str(installed)\n print self.version\n if installed:\n installed=[package for package in installed if package[0] != self.name]\n installed.append((self.name, self.version, self.location))\n else:\n installed=[(self.name, self.version, self.location)]\n print \"added self\"\n defaults.removeObjectForKey_('installedPackages')\n defaults.setObject_forKey_(installed, 'installedPackages')\n print \"updated installed\"","def register(id, name, get_packages, find_installed_packages):\n repo = Repository()\n repo.id = id\n repo.name = name\n repo.get_packages = get_packages\n repo.find_installed_packages = find_installed_packages\n repositories.append(repo)","def install_providers():\n host = env.host_string\n providers = get_providers(host)\n for provider in providers.values():\n if getattr(provider, 'manager', None) is not None:\n provider.manager.install()\n\n provider.install()","def _cli(ctx, input, output):\n print(\"Registering...\")\n ctx.obj = dict(\n component=Registration,\n input=input,\n output=output,\n stack=ImageStack.from_path_or_url(input),\n )","def initialization(self):\n super().initialization()\n self.register_uniq_ids([self.id_modal, self.id_modal_close, self.id_wip_button])\n\n # Register modules\n self.modules = [self.mod_table, self.mod_cache, self.mod_upload]","def setup_manager(self) -> None:\n\n #Clean out the process list.\n self.process_list.clear()\n for _ in range(self.num_processes):\n p = Process(target=self.multiprocessing_job,\n args=(self.process_job,))\n self.process_list.append(p)\n self.restart_required = False"],"string":"[\n \"def register_component(var, config):\\n id_ = text_type(var.base)\\n if id_ not in CORE.component_ids:\\n raise ValueError(u\\\"Component ID {} was not declared to inherit from Component, \\\"\\n u\\\"or was registered twice. Please create a bug report with your \\\"\\n u\\\"configuration.\\\".format(id_))\\n CORE.component_ids.remove(id_)\\n if CONF_SETUP_PRIORITY in config:\\n add(var.set_setup_priority(config[CONF_SETUP_PRIORITY]))\\n if CONF_UPDATE_INTERVAL in config:\\n add(var.set_update_interval(config[CONF_UPDATE_INTERVAL]))\\n add(App.register_component(var))\\n yield var\",\n \"def instantiate(self, components):\\n with self.__lock:\\n # Store the new components\\n self._status.store(components)\\n\\n # Install required bundles\\n bundles = set((component.bundle_name, component.bundle_version)\\n for component in components)\\n self._install_bundles(bundles)\\n\\n if self._agent is not None:\\n # Instantiate them\\n self._agent.handle(components)\\n else:\\n # Wait for an agent to come\\n self._remaining.update(components)\",\n \"def register(self, obj):\\r\\n name = obj._component_name\\r\\n if name in self.components:\\r\\n raise ComponentAlreadyRegistered(\\\"Component already registered with name %s\\\" % name)\\r\\n\\r\\n self.components[obj._component_name] = obj\",\n \"def setup_components(self, builder: \\\"Builder\\\"):\\n self._setup_components(builder, self._managers + self._components)\",\n \"def setup_component(self):\\n self.conf, self.context = self._init_component()\\n self.initialize()\",\n \"def create_allcomponents(self):\\n\\n # we store all components in a list/hash which we iterate for startup/shutdown/dumps debugging, and which can be used to lookup components\\n self.components = MDictList()\\n\\n # setup log manager helper early so that log manager can receive messages (and queue them until startup)\\n self.createappendcomp('logmanager', mlogger.MewloLogManager)\\n\\n # now update site state (log manager should catch this)\\n self.set_statelabel(mconst.DEF_SITESTATE_INITIALIZE_START)\\n\\n # create (non-db-persistent) site settings -- these are set by configuration at runtime\\n self.settings = self.createappendcomp('settings', MewloSettings)\\n\\n # database manager\\n self.createappendcomp('dbmanager', mdbmanager_sqlalchemy.MewloDatabaseManagerSqlA)\\n\\n # component registry\\n self.createappendcomp('registrymanager', mregistry.MewloRegistryManager)\\n\\n # signal dispatcher\\n self.createappendcomp('signalmanager', msignal.MewloSignalManager)\\n\\n # rbac permission manager\\n self.createappendcomp('rbacmanager', mrbac.MewloRbacManager)\\n\\n # create persistent(db) pack settings\\n self.createappendcomp('packsettings', mdbsettings_pack.MewloSettingsDb_Pack)\\n\\n # collection of mewlo addon packs\\n self.createappendcomp('packmanager', mpackmanager.MewloPackManager)\\n\\n # site addon manager\\n #self.createappendcomp('siteaddonmanager', msiteaddon.MewloSiteAddonManager)\\n\\n # route manager\\n self.createappendcomp('routemanager', mroute.MewloRouteManager)\\n\\n # navnode manager\\n self.createappendcomp('navnodemanager', mnav.NavNodeManager)\\n\\n # template manager\\n self.createappendcomp('templatemanager', mtemplate.MewloTemplateManager)\\n\\n # asset and alias manager\\n self.createappendcomp('assetmanager', massetmanager.MewloAssetManager)\\n\\n # template helper (this is available inside template/views and provides helper functions like navigation menus, etc.)\\n self.createappendcomp('templatehelper', mtemplatehelper.MewloTemplateHelper)\\n\\n # session manager\\n self.createappendcomp('sessionmanager', msessionmanager.MewloSessionManager)\\n\\n # verification manager\\n self.createappendcomp('verificationmanager', mverificationmanager.MewloVerificationManager)\\n\\n # user manager\\n self.createappendcomp('usermanager', musermanager.MewloUserManager)\\n\\n # mail manager\\n self.createappendcomp('mailmanager', mmailmanager.MewloMailManager)\",\n \"def add(self, *components):\\n for component in components:\\n if component.container is not None:\\n component.container.remove(component)\\n component.container = self\\n self._components.extend(components)\",\n \"def register(self):\\n self._register_dockyard()\\n self._register_docker()\",\n \"def components(self, components: List[IngredientObjectComponents]):\\n\\n self._components = components\",\n \"def load_components(self, on_initialize=False):\\n for name, component_data in self.components.items():\\n start_on_initialize = component_data.get('on_initialize', False)\\n if start_on_initialize == on_initialize:\\n component_data.pop('on_initialize', None)\\n\\n # inject parent module in component\\n if not component_data.get('options', None):\\n component_data['options'] = {}\\n\\n component_data['options']['module'] = self\\n component = RonObject.instanceObject(component_data)\\n setattr(self, name, component)\",\n \"def startup_allcomponents(self, eventlist):\\n\\n # walk the component list and ask each to register any db classes\\n for key,obj in self.components.get_tuplelist():\\n # pre startup - register database classes\\n obj.prestartup_register(eventlist)\\n\\n # now that all database models have been registered with the system, finalize creation of models -- create all db tables, etc\\n self.comp('dbmanager').create_tableandmapper_forallmodelclasses()\\n\\n # walk the component list and let each startup\\n for key,obj in self.components.get_tuplelist():\\n # start up the component\\n obj.startup(eventlist)\\n\\n # walk the component list and let each do any post-startup\\n for key,obj in self.components.get_tuplelist():\\n # post startup\\n obj.poststartup(eventlist)\",\n \"def register_application_components(self, args, app: Application):\\n raise NotImplementedError\",\n \"def test_register_component():\\n\\n component = ComponentMock('component1')\\n application_services.register_component(component)\\n assert application_services.get_component('component1') == component\\n application_services.remove_component(component.get_id())\",\n \"def _set_components(self, components: List[base_node.BaseNode]) -> None:\\n self._check_mutable()\\n\\n deduped_components = set(components)\\n for upstream_component, component in enumerate_implicit_dependencies(\\n list(deduped_components),\\n registry=self.dsl_context_registry,\\n pipeline=self,\\n ):\\n component.add_upstream_node(upstream_component)\\n\\n layers = topsort.topsorted_layers(\\n list(deduped_components),\\n get_node_id_fn=lambda c: c.id,\\n get_parent_nodes=lambda c: c.upstream_nodes,\\n get_child_nodes=lambda c: c.downstream_nodes)\\n self._components = []\\n for layer in layers:\\n for component in layer:\\n self._components.append(component)\\n\\n if self.beam_pipeline_args:\\n for component in self._components:\\n add_beam_pipeline_args_to_component(component, self.beam_pipeline_args)\",\n \"def register(self, events=[]):\\n self.events = events\\n if not self in manager.handler:\\n manager.handler.append(self)\",\n \"def add(self, component) -> None:\\n pass\",\n \"def load_components(self):\\n self_class = self.__class__\\n\\n # Lazy load component loader\\n try:\\n component_loader = self_class._component_loader\\n\\n if component_loader.component_tags != self_class.component_tags:\\n raise AttributeError(\\\"Mismatch in component tags, reloading\\\")\\n\\n except AttributeError:\\n component_loader = ComponentLoader(*self_class.component_tags)\\n self_class._component_loader = component_loader\\n\\n class_name = self_class.__name__\\n definitions = self_class._definitions\\n\\n # Lazy load definitions\\n try:\\n platform_definition = definitions[class_name]\\n\\n except KeyError:\\n resources = ResourceManager[class_name]\\n platform = ResourceManager.environment\\n\\n try:\\n definition = resources[self_class.definition_name]\\n\\n except TypeError:\\n raise FileNotFoundError(\\\"Could not find definition file for {}\\\".format(class_name))\\n\\n full_path = ResourceManager.get_absolute_path(definition)\\n\\n definition_sections = ConfigObj(full_path)\\n platform_definition = definition_sections[platform]\\n definitions[class_name] = platform_definition\\n\\n component_result = component_loader.load(self, platform_definition)\\n\\n # Load components\\n for component_tag, component in component_result.components.items():\\n setattr(self, component_tag, component)\\n\\n self._component_result = component_result\",\n \"def register(self):\\n\\n RPCObjectsRegistry.add(self)\",\n \"def add_component(self, new: components.Component) -> None:\\n for existing in self.components:\\n if isinstance(existing, type(new)):\\n raise Exception(type(new))\\n self.components.append(new)\",\n \"def register_classes():\\n DiffuseCompChain.register_class()\\n CatalogCompChain.register_class()\\n DiffuseAnalysisChain.register_class()\",\n \"def components(build_reset, monkeypatch):\\n controllers, visuals, htmls = create_components()\\n\\n app = App(__name__, rows=len(visuals), sidebar=True)\\n for controller in controllers:\\n # pylint: disable=protected-access\\n assert COMPONENT_REGISTRY[controller._uuid] == controller\\n app.add_sidebar(controller)\\n\\n for vis in visuals:\\n # pylint: disable=protected-access\\n assert COMPONENT_REGISTRY[vis._uuid] == vis\\n app.add(vis)\\n\\n for htm in htmls:\\n # pylint: disable=protected-access\\n assert COMPONENT_REGISTRY[htm._uuid] == htm\\n app.add_sidebar(htm)\\n\\n assert len(COMPONENT_REGISTRY) == len(controllers) + 2 * len(visuals) + len(htmls)\\n\\n # pylint: disable=protected-access\\n app._build()\\n\\n # run second time to make sure nothing weird happens with subsequent builds\\n app._build()\\n\\n with server_check(app) as server:\\n yield server\",\n \"def register(self):\\n if self.registered:\\n return\\n\\n config = current_app.config.get('TERMINAL_CONFIGS', {})\\n apps = config.get('apps', [])\\n\\n for app in apps:\\n cls, mod = app.rsplit('.', maxsplit=1)\\n imported = import_module(cls)\\n instance = getattr(imported, mod)()\\n\\n if getattr(instance, 'name', None) is None:\\n continue\\n\\n if getattr(instance, 'hidden', False):\\n self.hidden[getattr(instance, 'name')] = instance\\n else:\\n self.apps[getattr(instance, 'name')] = instance\\n\\n self.__set_apps_aliases(getattr(instance, 'name'), getattr(instance, 'aliases'))\\n\\n self.registered = True\",\n \"def _add_component(self, __assistant):\\r\\n\\r\\n # Retrieve the hardware ID.\\r\\n _model = self.cmbHardware.get_model()\\r\\n _row = self.cmbHardware.get_active_iter()\\r\\n _hardware_id = int(_model.get_value(_row, 1))\\r\\n\\r\\n self._controller.add_component(self._incident_id, _hardware_id)\\r\\n self._workbook.load_component_list()\\r\\n\\r\\n return False\",\n \"def registerType(cls, type):\\n # NOTE Subclasses must be registered via this method in order to be initialized from XML, etc.\\n cls.componentTypes[type.__name__] = type\\n #print \\\"Component.registerType(): Component type \\\\'\\\" + type.__name__ + \\\"\\\\' registered.\\\" # [debug]\",\n \"def register ():\\n dsf_geom_import.register ()\\n dsf_morph_import.register ()\\n dsf_morph_export.register ()\\n dsf_uvset_import.register ()\\n dsf_arm_import.register ()\\n dsf_pose_import.register ()\\n dsf_wm_import.register ()\\n dsf_geom_export.register ()\\n dsf_prop_export.register ()\",\n \"def startComponent(self):\\n self.ms = MessageService()\\n self.ms.registerAs(\\\"TaskRegisterComponent\\\")\\n \\n self.ms.subscribeTo(\\\"CRAB_Cmd_Mgr:NewTask\\\")\\n self.ms.subscribeTo(\\\"TaskRegisterComponent:StartDebug\\\")\\n self.ms.subscribeTo(\\\"TaskRegisterComponent:EndDebug\\\")\\n self.ms.subscribeTo(\\\"KillTask\\\")\\n\\n self.ms.subscribeTo(\\\"TaskRegisterComponent:HeartBeat\\\")\\n self.ms.remove(\\\"TaskRegisterComponent:HeartBeat\\\")\\n self.ms.publish(\\\"TaskRegisterComponent:HeartBeat\\\",\\\"\\\",self.HeartBeatDelay)\\n self.ms.commit()\\n\\n # TaskRegister registration in WMCore.MsgService\\n self.myThread = threading.currentThread()\\n self.factory = WMFactory(\\\"msgService\\\", \\\"WMCore.MsgService.\\\"+ \\\\\\n self.myThread.dialect)\\n self.newMsgService = self.myThread.factory['msgService'].loadObject(\\\"MsgService\\\")\\n self.myThread.transaction.begin()\\n self.newMsgService.registerAs(\\\"TaskRegisterComponent\\\")\\n self.myThread.transaction.commit()\\n\\n #\\n # non blocking call event handler loop\\n # this allows us to perform actions even if there are no messages\\n #\\n try: \\n while True:\\n # dispatch loop for Queued messages\\n while True:\\n try:\\n senderId, evt, pload = self.sharedQueue.get_nowait()\\n taskUniqName = pload.split(\\\"::\\\")[0]\\n\\n # dealloc threadId\\n if senderId not in self.availWorkersIds:\\n self.availWorkersIds.append(senderId)\\n\\n # dispatch the messages and update status \\n if evt in [\\\"TaskRegisterComponent:NewTaskRegisteredPartially\\\"]:\\n logging.info(\\\"Task %s registred Partially\\\"%taskUniqName) \\n elif evt in [\\\"TaskRegisterComponent:NewTaskRegistered\\\"] and taskUniqName not in self.killingRequestes:\\n self.ms.publish(evt, pload)\\n logging.info(\\\"Publish Event: %s %s\\\" % (evt, pload))\\n self.ms.commit()\\n elif evt in [\\\"RegisterWorkerComponent:WorkerFailsToRegisterPartially\\\"]:\\n logging.info(\\\"Task %s failed partially\\\"%taskUniqName)\\n elif evt in [\\\"RegisterWorkerComponent:RegisterWorkerFailed\\\"]:\\n logging.info(\\\"Task %s failed\\\"%taskUniqName)\\n self.markTaskAsNotSubmitted(taskUniqName, 'all')\\n self.ms.publish(evt, pload)\\n logging.info(\\\"Publish Event: %s %s\\\" % (evt, pload))\\n self.ms.commit()\\n elif taskUniqName in self.killingRequestes:\\n logging.info(\\\"Task %s killed by user\\\"%taskUniqName)\\n self.markTaskAsNotSubmitted(taskUniqName, self.killingRequestes[taskUniqName])\\n del self.killingRequestes[taskUniqName]\\n\\n except Queue.Empty, e:\\n logging.debug(\\\"Queue empty: \\\" + str(e))\\n break\\n except Exception, exc:\\n logging.error(\\\"'Generic' problem: \\\" + str(exc))\\n logging.error( str(traceback.format_exc()) )\\n\\n if len(self.availWorkersIds) > 0:\\n try:\\n type, payload = self.ms.get( wait = False )\\n\\n if type is None:\\n time.sleep( self.ms.pollTime )\\n continue\\n else:\\n self.__call__(type, payload)\\n self.ms.commit()\\n except Exception, exc:\\n logging.error(\\\"ERROR: Problem managing message...\\\")\\n logging.error(str(exc))\\n except Exception, e:\\n logging.error(e)\\n logging.info(traceback.format_exc())\\n\\n return\",\n \"def __init__(self, *components) -> None:\\n self.__components = list(components)\",\n \"def add_comp(self, name, ctype):\\n\\n name = self.name + '.' + name\\n\\n assert name not in self.components, 'A component named \\\\'{}\\\\' already exists for node \\\\'{}\\\\''.format(\\n name, self.name)\\n\\n try:\\n cls = co.str_to_comp(ctype)\\n except AttributeError:\\n try:\\n cls = rc.str_to_comp(ctype)\\n except AttributeError:\\n cls = None\\n\\n if cls:\\n obj = cls(name=name,\\n temperature_driven=self.temperature_driven,\\n repr_days=self.repr_days)\\n else:\\n raise ValueError(\\n \\\"%s is not a valid class name! (component is %s, in node %s)\\\" % (\\n ctype, name, self.name))\\n\\n self.logger.info('Component {} added to {}'.format(name, self.name))\\n\\n self.components[name] = obj\",\n \"def register(self):\\n raise NotImplementedError\",\n \"def register(self):\\n raise NotImplementedError\",\n \"def install():\\n ArticleDataProvider.register()\\n ProductDataProvider.register()\",\n \"def register(self):\\n raise NotImplementedError(\\\"Should have implemented this\\\")\",\n \"def add_component(self, lib_component):\\n comp_name = lib_component.name\\n try:\\n comp = self.__component_list[comp_name]\\n except KeyError:\\n self.__component_list[comp_name] = lib_component\",\n \"def register(self):\\n # Register generic implementations for all jitclasses\\n self._register_methods(self.class_impl_registry,\\n self.class_type.instance_type)\\n # NOTE other registrations are done at the top-level\\n # (see ctor_impl and attr_impl below)\\n self.targetctx.install_registry(self.class_impl_registry)\",\n \"def register_packages(self, module_name, extra_package):\\n self.creator_manager.register_packages(module_name, extra_package)\",\n \"def register() -> None:\\n plot_backend = _get_plot_backend(\\\"matplotlib\\\")\\n plot_backend.register()\",\n \"def test_component_add_ok(self):\\n test_name = sys._getframe().f_code.co_name\\n self._execute('component add new_component new_user')\\n rv, output = self._execute('component list')\\n self.assertEqual(0, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def register(self):\\n raise NotImplementedError()\",\n \"def add_packages(self, component_name, packages):\\n for pkg in packages:\\n self.add_package(component_name, pkg)\",\n \"def create_components():\\n reset_uuid()\\n # pylint: disable=protected-access\\n controllers = []\\n for compstr in dir(control):\\n comp = getattr(control, compstr)\\n if (compstr[0] != '_' and isclass(comp) and issubclass(comp, control._Controller)\\n and compstr != 'Upload'):\\n controllers.append(comp())\\n\\n for controller in controllers:\\n assert COMPONENT_REGISTRY[controller._uuid] == controller\\n\\n visuals = []\\n for compstr in dir(visual):\\n comp = getattr(visual, compstr)\\n if compstr[0] != '_' and isclass(comp) and issubclass(comp, visual._Visual):\\n visuals.append(comp())\\n\\n for vis in visuals:\\n assert COMPONENT_REGISTRY[vis._uuid] == vis\\n\\n htmls = []\\n for compstr in dir(html):\\n comp = getattr(html, compstr)\\n if compstr[0] != '_' and isclass(comp) and issubclass(comp, html._HTML):\\n htmls.append(comp())\\n\\n for htm in htmls:\\n assert COMPONENT_REGISTRY[htm._uuid] == htm\\n\\n return controllers, visuals, htmls\",\n \"def __components__():\\n # Get the component registry of the active application.\\n registry = context.app.component_registry\\n # A shortcut: return cached components.\\n if registry.components is not None:\\n return registry.components\\n # A list of `Component` subclasses defined in modules exported by addons.\\n components = [Component]\\n idx = 0\\n while idx < len(components):\\n for subclass in components[idx].__subclasses__():\\n # Skip realizations.\\n if issubclass(subclass, Realization):\\n continue\\n # Check if the component belongs to the current application.\\n if subclass.__enabled__():\\n components.append(subclass)\\n idx += 1\\n # Cache and return the components.\\n registry.components = components\\n return components\",\n \"def name(self):\\n return \\\"component_manager\\\"\",\n \"def add_components(self, comps):\\r\\n if not isinstance(comps, list):\\r\\n comps = [comps]\\r\\n for comp in comps:\\r\\n self.comps.append(comp)\",\n \"def register(cls, L):\\r\\n ...\",\n \"def item_components(self, item_components):\\n\\n self._item_components = item_components\",\n \"def test_register(self):\\n self._configure_testshib_provider()\\n self._test_register()\",\n \"def add(self, comp):\\n\\t\\tif comp:\\n\\t\\t\\tif isinstance(comp, Component):\\n\\t\\t\\t\\tcomp.container = self\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfor item in comp:\\n\\t\\t\\t\\t\\tself.add(item)\",\n \"def register(self, module):\\n tagvalues = \\\"\\\\n\\\".join([\\\"%s: %s\\\" % (attr, str(getattr(module, attr))) for attr in dir(module) if attr in ['create', 'menu', 'name', 'label'] ])\\n # tagvalues = \\\"\\\\n\\\".join([\\\"%s\\\" % (attr) for attr in dir(module) if attr not in ['urls'] ])\\n logger.debug(\\\"module {} registered.\\\\ndir : {}\\\".format(module.label, tagvalues ))\\n self._registry[module.label] = module\\n self._modules[module.name] = module\\n pass\",\n \"def register(cls):\\n register(cls, cls.provided_class)\",\n \"def register_classes():\\n CoaddSplit.register_class()\\n CoaddSplit_SG.register_class()\",\n \"def list_components(self, request, context):\\n response = ListComponentsResponse()\\n for component in self._delegator.list_components():\\n response.components.append(component)\\n return response\",\n \"def register_resources(self):\\n raise NotImplementedError\",\n \"def __init__(self, component):\\r\\n self.component = component\",\n \"def __init__(self, component):\\r\\n self.component = component\",\n \"def register(self):\\n self.logger.info(\\\"Registering agent %s\\\", \\\"/registry/\\\" + self._configuration[\\\"identification\\\"][\\\"uuid\\\"])\\n self._coordination.update(\\\"/registry/\\\" + self._configuration[\\\"identification\\\"][\\\"uuid\\\"], self._configuration[\\\"identification\\\"])\",\n \"def register(self, *model):\\n for m in model:\\n m.Register()\\n self.models.append(m)\",\n \"def set_up():\\n ResourcesManager().set_up()\\n LocatorUtil().load_locators()\",\n \"def component(self, component):\\n\\n self._component = component\",\n \"def component(self, component):\\n\\n self._component = component\",\n \"def test_component_set_successful(self):\\n # We create an instance of the panel so we can check existing values\\n panel = ComponentAdminPanel(self.env)\\n\\n # Check the environment initially contains the default values.\\n self.assertItemsEqual(panel.get_component_list(), self.default['component'])\\n\\n # create the section, option, and values in configuration\\n self.env.config.set('ticket-field-config', 'component',\\n ','.join(self.new['component']))\\n # create component_owner option\\n self.env.config.set('ticket-field-config','component_owner','test')\\n\\n admin_command = TicketFieldConfigCommand(self.env)\\n\\n # run our plugin\\n admin_command.set_fields_from_config()\\n\\n self.assertItemsEqual(panel.get_component_list(), self.new['component'])\",\n \"def components(self):\\r\\n return [JSONComponent(c) for c\\r\\n in self.container.get(\\\"ComponentInstances\\\", [])]\",\n \"def test_register_dynamic_plugin_manager1(self):\\n pass\",\n \"def register_models(self):\\n models = self.configs_['pipeline_models']\\n\\n for i in range(0, len(models)):\\n new_model = PipelineModel(models[i], self.score_method_,\\n self.predict_as_probability_)\\n\\n if not new_model.init():\\n print 'Error registering model', models[i]['model']['id'],\\\\\\n 'in ensemble'\\n return False\\n print 'Model', new_model.get_name(), 'registered in ensemble'\\n self.models_.append((models[i]['model']['id'],\\n new_model.get_sklearn_pipeline()))\\n\\n if 'weight' not in models[i]:\\n self.model_weights_.append(1)\\n else:\\n self.model_weights_.append(models[i]['weight'])\\n return True\",\n \"def register_models(self, *models, **kwargs):\\n\\n for model in models:\\n self.register(model, **kwargs)\",\n \"def _initComponent(self):\\n\\n self.optimizer = self._initOptimizer()\\n self.scheduler = self._initScheduler()\",\n \"def setup(self, configuration, lifecycle_manager):\\n self.configuration = configuration\\n self.lifecycle = lifecycle_manager\\n\\n self.lifecycle.add_constraint(\\n self.get_components_by_type,\\n restrict_during=[\\\"initialization\\\", \\\"population_creation\\\"],\\n )\\n self.lifecycle.add_constraint(\\n self.get_component, restrict_during=[\\\"population_creation\\\"]\\n )\\n self.lifecycle.add_constraint(\\n self.list_components, restrict_during=[\\\"initialization\\\"]\\n )\",\n \"def consul_register(self):\\n self.log.debug(\\\"consul-register\\\")\\n self.consul.agent.service.register(\\n self.svc_name,\\n address=self.this_host,\\n check=consulate.models.agent.Check(\\n name=\\\"qemu-process\\\",\\n args=[\\n \\\"/bin/sh\\\",\\n \\\"-c\\\",\\n \\\"test -e /proc/$(< /run/qemu.{}.pid )/mem || exit 2\\\".format(\\n self.name\\n ),\\n ],\\n interval=\\\"5s\\\",\\n ),\\n )\",\n \"def setup(self, registry):\\n logger.info(\\\"%s %s\\\", self.dist_name, self.version)\\n\\n from .frontend import AutoplayFrontend\\n registry.add(\\\"frontend\\\", AutoplayFrontend)\",\n \"def at_added(self, host):\\n\\n if self.host:\\n if self.host == host:\\n return\\n else:\\n raise ComponentRegisterError(\\\"Components must not register twice!\\\")\\n\\n self.host = host\",\n \"def _register_services(self, pipeline):\\n\\n pipeline.register_service(self._aprs_service)\",\n \"def build(self):\\n for component, type in self.__get_data(\\\"comps\\\").items():\\n self.add_comp(component, type)\\n\\n self.logger.info('Build of {} finished'.format(self.name))\",\n \"def test_register_dynamic_plugin_manager(self):\\n pass\",\n \"def addAllFactories(self) -> None:\\n ...\",\n \"def populate_componentControls(self):\\n # populate tab\\n self.tabs.insertTab(1, self.settingsTab, \\\"Component Settings\\\")\\n\\n refArrayItems = self.root.attr(\\\"ikrefarray\\\").get().split(\\\",\\\")\\n for item in refArrayItems:\\n self.settingsTab.refArray_listWidget.addItem(item)\",\n \"def create_new_component(self, cname):\\n while True:\\n try:\\n self.model.get_component_by_name(cname)\\n cname += u'_'\\n except KeyError:\\n # Component with this name doesn't exist\\n break\\n # Create the component\\n comp = cellml_component.create_new(self.model, cname)\\n self.model._add_component(comp)\\n return comp\",\n \"def _add_custom_components(self, components, policy_statements, components_resources):\\n initial_components_len = len(components)\\n arn_components_len = 0\\n for custom_component in self.config.build.components:\\n custom_components_len = len(components) - initial_components_len - arn_components_len\\n if custom_component.type == \\\"arn\\\":\\n components.append(\\n imagebuilder.CfnImageRecipe.ComponentConfigurationProperty(component_arn=custom_component.value)\\n )\\n arn_components_len += 1\\n else:\\n component_script_name = custom_component.value.split(\\\"/\\\")[-1]\\n component_id = \\\"ScriptComponent\\\" + str(custom_components_len)\\n custom_component_resource = imagebuilder.CfnComponent(\\n self,\\n component_id,\\n name=self._build_resource_name(\\n IMAGEBUILDER_RESOURCE_NAME_PREFIX + \\\"-Script-{0}\\\".format(str(custom_components_len))\\n ),\\n version=utils.get_installed_version(base_version_only=True),\\n description=\\\"This component is custom component for script, script name is {0}, script url is \\\"\\n \\\"{1}\\\".format(component_script_name, custom_component.value),\\n platform=\\\"Linux\\\",\\n data=wrap_script_to_component(custom_component.value),\\n )\\n components.append(\\n imagebuilder.CfnImageRecipe.ComponentConfigurationProperty(component_arn=Fn.ref(component_id))\\n )\\n components_resources.append(custom_component_resource)\\n if not self.custom_cleanup_lambda_role:\\n self._add_resource_delete_policy(\\n policy_statements,\\n [\\\"imagebuilder:DeleteComponent\\\"],\\n [\\n self.format_arn(\\n service=\\\"imagebuilder\\\",\\n resource=\\\"component\\\",\\n resource_name=\\\"{0}/*\\\".format(\\n self._build_resource_name(\\n IMAGEBUILDER_RESOURCE_NAME_PREFIX\\n + \\\"-Script-{0}\\\".format(str(custom_components_len)),\\n to_lower=True,\\n )\\n ),\\n )\\n ],\\n )\",\n \"def __init__(self, services, config):\\n #pytau.setNode(1)\\n #timer = pytau.profileTimer(\\\"component.__init__\\\", \\\"\\\", str(os.getpid()))\\n #pytau.start(timer)\\n self.component_id = None\\n self.invocation_q = None\\n self.services = weakref.proxy(services)\\n self.config = config\\n self.start_time=0.0\\n self.sys_exit = None\\n for i in config.keys():\\n try:\\n setattr(self, i, config[i])\\n except Exception, e:\\n print 'Error setting Component parameter : ', i, ' - ', e\\n #pytau.stop(timer)\\n raise\\n\\n #pytau.stop(timer)\",\n \"def register_router(self, router):\\n for prefix, viewset, basename in router.registry:\\n self.register(prefix, viewset, base_name=basename)\",\n \"def register(self):\\n\\n registerables = []\\n registerables.append(swf.Domain(name=self.domain))\\n registerables.append(swf.WorkflowType(\\n domain=self.domain,\\n name=self.task_list,\\n version=self.version,\\n task_list=self.task_list))\\n\\n for current_activity in self.activities:\\n registerables.append(\\n swf.ActivityType(\\n domain=self.domain,\\n name=current_activity.name,\\n version=self.version,\\n task_list=current_activity.task_list))\\n\\n for swf_entity in registerables:\\n try:\\n swf_entity.register()\\n except (SWFDomainAlreadyExistsError, SWFTypeAlreadyExistsError):\\n print(\\n swf_entity.__class__.__name__, swf_entity.name,\\n 'already exists')\",\n \"def on_register(cls):\",\n \"def register_resources(self, resources):\\n for resource in resources:\\n self.register_resource(resource)\",\n \"def _process_configureComponent(self, data):\\r\\n for node in data.pop('addNodes', []):\\r\\n try:\\r\\n self._avatar.addNode(node['containerTag'],\\r\\n node['nodeTag'],\\r\\n node['pkg'],\\r\\n node['exe'],\\r\\n node.get('args', ''),\\r\\n node.get('name', ''),\\r\\n node.get('namespace', ''))\\r\\n except KeyError as e:\\r\\n raise InvalidRequest(\\\"Can not process 'ConfigureComponent' \\\"\\r\\n \\\"request. 'addNodes' is missing key: \\\"\\r\\n '{0}'.format(e))\\r\\n\\r\\n for node in data.pop('removeNodes', []):\\r\\n try:\\r\\n self._avatar.removeNode(node['containerTag'],\\r\\n node['nodeTag'])\\r\\n except KeyError as e:\\r\\n raise InvalidRequest(\\\"Can not process 'ConfigureComponent' \\\"\\r\\n \\\"request. 'removeNodes' is missing key: \\\"\\r\\n '{0}'.format(e))\\r\\n\\r\\n for conf in data.pop('addInterfaces', []):\\r\\n try:\\r\\n self._avatar.addInterface(conf['endpointTag'],\\r\\n conf['interfaceTag'],\\r\\n conf['interfaceType'],\\r\\n conf['className'],\\r\\n conf.get('addr', ''))\\r\\n except KeyError as e:\\r\\n raise InvalidRequest(\\\"Can not process 'ConfigureComponent' \\\"\\r\\n \\\"request. 'addInterfaces' is missing \\\"\\r\\n 'key: {0}'.format(e))\\r\\n\\r\\n for conf in data.pop('removeInterfaces', []):\\r\\n try:\\r\\n self._avatar.removeInterface(conf['endpointTag'],\\r\\n conf['interfaceTag'])\\r\\n except KeyError as e:\\r\\n raise InvalidRequest(\\\"Can not process 'ConfigureComponent' \\\"\\r\\n \\\"request. 'removeInterfaces' is missing \\\"\\r\\n 'key: {0}'.format(e))\\r\\n\\r\\n for param in data.pop('setParam', []):\\r\\n try:\\r\\n self._avatar.addParameter(param['containerTag'],\\r\\n param['name'],\\r\\n param['value'])\\r\\n except KeyError as e:\\r\\n raise InvalidRequest(\\\"Can not process 'ConfigureComponent' \\\"\\r\\n \\\"request. 'setParam' is missing key: \\\"\\r\\n '{0}'.format(e))\\r\\n\\r\\n for param in data.pop('deleteParam', []):\\r\\n try:\\r\\n self._avatar.removeParameter(param['containerTag'],\\r\\n param['name'])\\r\\n except KeyError as e:\\r\\n raise InvalidRequest(\\\"Can not process 'ConfigureComponent' \\\"\\r\\n \\\"request. 'deleteParam' is missing key: \\\"\\r\\n '{0}'.format(e))\",\n \"def register():\\n \\n global _registered\\n if not _registered:\\n _registered = True\\n sys.path_hooks.insert(0, VFSImporter)\",\n \"def antenny_init_components(self):\\n if self.antenny_config is None:\\n print(\\\"Please load a config before initializing components\\\")\\n if not self.antenny_config.check():\\n print(\\\"Config {} is not valid, failed to initialize\\\".format(self.antenny_config.get_name()))\\n print(\\\"If you believe this is an error, or you have modified the base components of the antenny board, \\\"\\n \\\"please check Config class as well as the default configs for more details.\\\")\\n\\n self.imu_init()\\n self.pwm_controller_init()\\n self.elevation_servo_init()\\n self.azimuth_servo_init()\\n self.screen_init()\\n self.gps_init()\\n self.telemetry_init()\\n self.platform_init()\",\n \"def _register(self, comm, handler):\",\n \"def appendcomp(self, componentname, component):\\n self.components.append(componentname, component)\\n return component\",\n \"def register_plugins(self):\\n if self.plugin_whitelist:\\n plugin_list = self.plugin_whitelist\\n else:\\n plugin_list = plugins.__all__\\n\\n for plugin in plugin_list:\\n if plugin in plugins.__all__:\\n self.register_plugin(plugin,\\n self.plugin_config.get(plugin, {}))\\n else:\\n raise NameError(\\\"Plugin %s not in plugins.__all__.\\\" % plugin)\\n\\n # Resolve plugin inter-dependencies.\\n for plugin in self.plugin:\\n self.plugin[plugin].post_init()\",\n \"def registered(self):\\n log.info(\\\"Registered.\\\")\\n pass\",\n \"def RegisterPlugins(cls, plugin_classes):\\n for plugin_class in plugin_classes:\\n cls.RegisterPlugin(plugin_class)\",\n \"def register_specs(self, *args):\\n self._corespecs_queue.extend(*args)\",\n \"def RegisterService():\\n hooks.RegisterHook(SERVICE_NAME, 'file-exists', hook_class=HookForExists)\\n hooks.RegisterHook(SERVICE_NAME, 'file-write',\\n hook_class=HookForWriteAndTouch)\\n hooks.RegisterHook(SERVICE_NAME, 'file-touch',\\n hook_class=HookForWriteAndTouch)\\n hooks.RegisterHook(SERVICE_NAME, 'file-get', hook_class=HookForGet)\\n hooks.RegisterHook(SERVICE_NAME, 'list-files', hook_class=HookForListFiles)\\n hooks.RegisterHook(SERVICE_NAME, 'list-dir', hook_class=HookForListDir)\",\n \"def register(self):\\n self.app.bind('CreateSuperUserCommand', CreateSuperUser())\\n self.app.bind('InstallCommand', Install())\\n self.app.bind(\\n 'AdminUserMigrationDirectory',\\n os.path.join(package_directory, 'migrations')\\n )\",\n \"def register(mgr):\\n mgr.set_lang_info(lang,\\n silvercity_lexer=CSSLexer(),\\n buf_class=CSSBuffer,\\n langintel_class=CSSLangIntel,\\n is_cpln_lang=True)\",\n \"def setup(self, manager):\\n self._manager = manager\\n self._configured = True\",\n \"def register(self):\\n #self._defaultPrefs=[InstalledPackage(\\\"Dummy\\\",0,\\\"dummy\\\")]\\n defaults=NSUserDefaults.standardUserDefaults()\\n print \\\"got prefs\\\"\\n defaults.registerDefaults_(self._defaultPrefs)\\n print \\\"registered defaults\\\"\\n installed=defaults.objectForKey_('installedPackages')\\n print \\\"got installed\\\"\\n print str(installed)\\n print self.version\\n if installed:\\n installed=[package for package in installed if package[0] != self.name]\\n installed.append((self.name, self.version, self.location))\\n else:\\n installed=[(self.name, self.version, self.location)]\\n print \\\"added self\\\"\\n defaults.removeObjectForKey_('installedPackages')\\n defaults.setObject_forKey_(installed, 'installedPackages')\\n print \\\"updated installed\\\"\",\n \"def register(id, name, get_packages, find_installed_packages):\\n repo = Repository()\\n repo.id = id\\n repo.name = name\\n repo.get_packages = get_packages\\n repo.find_installed_packages = find_installed_packages\\n repositories.append(repo)\",\n \"def install_providers():\\n host = env.host_string\\n providers = get_providers(host)\\n for provider in providers.values():\\n if getattr(provider, 'manager', None) is not None:\\n provider.manager.install()\\n\\n provider.install()\",\n \"def _cli(ctx, input, output):\\n print(\\\"Registering...\\\")\\n ctx.obj = dict(\\n component=Registration,\\n input=input,\\n output=output,\\n stack=ImageStack.from_path_or_url(input),\\n )\",\n \"def initialization(self):\\n super().initialization()\\n self.register_uniq_ids([self.id_modal, self.id_modal_close, self.id_wip_button])\\n\\n # Register modules\\n self.modules = [self.mod_table, self.mod_cache, self.mod_upload]\",\n \"def setup_manager(self) -> None:\\n\\n #Clean out the process list.\\n self.process_list.clear()\\n for _ in range(self.num_processes):\\n p = Process(target=self.multiprocessing_job,\\n args=(self.process_job,))\\n self.process_list.append(p)\\n self.restart_required = False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6344829","0.63038844","0.6204114","0.6132295","0.6074433","0.5977594","0.5963998","0.5922624","0.591374","0.58610815","0.5751899","0.57106787","0.5632077","0.5617429","0.56010264","0.559912","0.5562307","0.5527054","0.551372","0.551043","0.5477497","0.54603785","0.54191715","0.54139125","0.5412045","0.53521496","0.53503144","0.5341919","0.53386545","0.53386545","0.532748","0.5321996","0.5279561","0.52694184","0.52643925","0.5251436","0.524732","0.52412975","0.52315813","0.5225757","0.5223833","0.51982105","0.5175798","0.5169665","0.5156311","0.5137762","0.5132983","0.5101711","0.5081947","0.5078425","0.50682956","0.50614744","0.5035105","0.5035105","0.5032302","0.5011651","0.5011358","0.5005671","0.5005671","0.5005595","0.49990326","0.49937224","0.49774086","0.4969185","0.49682835","0.4950743","0.49492362","0.49472213","0.49440756","0.4938602","0.4936964","0.49308535","0.4927034","0.49230015","0.49209976","0.4903946","0.48981825","0.489468","0.4878401","0.48731977","0.4860605","0.48577932","0.48507452","0.48503593","0.4832894","0.4817067","0.48021454","0.47921717","0.4788576","0.47826803","0.47812423","0.4779848","0.4778084","0.47775272","0.4777449","0.47721544","0.4771832","0.4771741","0.47668788","0.47538668"],"string":"[\n \"0.6344829\",\n \"0.63038844\",\n \"0.6204114\",\n \"0.6132295\",\n \"0.6074433\",\n \"0.5977594\",\n \"0.5963998\",\n \"0.5922624\",\n \"0.591374\",\n \"0.58610815\",\n \"0.5751899\",\n \"0.57106787\",\n \"0.5632077\",\n \"0.5617429\",\n \"0.56010264\",\n \"0.559912\",\n \"0.5562307\",\n \"0.5527054\",\n \"0.551372\",\n \"0.551043\",\n \"0.5477497\",\n \"0.54603785\",\n \"0.54191715\",\n \"0.54139125\",\n \"0.5412045\",\n \"0.53521496\",\n \"0.53503144\",\n \"0.5341919\",\n \"0.53386545\",\n \"0.53386545\",\n \"0.532748\",\n \"0.5321996\",\n \"0.5279561\",\n \"0.52694184\",\n \"0.52643925\",\n \"0.5251436\",\n \"0.524732\",\n \"0.52412975\",\n \"0.52315813\",\n \"0.5225757\",\n \"0.5223833\",\n \"0.51982105\",\n \"0.5175798\",\n \"0.5169665\",\n \"0.5156311\",\n \"0.5137762\",\n \"0.5132983\",\n \"0.5101711\",\n \"0.5081947\",\n \"0.5078425\",\n \"0.50682956\",\n \"0.50614744\",\n \"0.5035105\",\n \"0.5035105\",\n \"0.5032302\",\n \"0.5011651\",\n \"0.5011358\",\n \"0.5005671\",\n \"0.5005671\",\n \"0.5005595\",\n \"0.49990326\",\n \"0.49937224\",\n \"0.49774086\",\n \"0.4969185\",\n \"0.49682835\",\n \"0.4950743\",\n \"0.49492362\",\n \"0.49472213\",\n \"0.49440756\",\n \"0.4938602\",\n \"0.4936964\",\n \"0.49308535\",\n \"0.4927034\",\n \"0.49230015\",\n \"0.49209976\",\n \"0.4903946\",\n \"0.48981825\",\n \"0.489468\",\n \"0.4878401\",\n \"0.48731977\",\n \"0.4860605\",\n \"0.48577932\",\n \"0.48507452\",\n \"0.48503593\",\n \"0.4832894\",\n \"0.4817067\",\n \"0.48021454\",\n \"0.47921717\",\n \"0.4788576\",\n \"0.47826803\",\n \"0.47812423\",\n \"0.4779848\",\n \"0.4778084\",\n \"0.47775272\",\n \"0.4777449\",\n \"0.47721544\",\n \"0.4771832\",\n \"0.4771741\",\n \"0.47668788\",\n \"0.47538668\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5851719"},"document_rank":{"kind":"string","value":"10"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":259,"numItemsPerPage":100,"numTotalItems":95772,"offset":25900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNjc1Mzc2ODJkMmE2Mjg0NzVhMWJmZmNkIl0sImlhdCI6MTc5MTE3MTU0MywianRpIjoiYzU3ODcyMTktNDg4ZC00YTk0LWE4YWMtM2Y5NTJjNWJjMzVjIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3OTExNzUxNDMsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.hqly9mVYv03GtNasRvWYkhfZs3yYU7OqiMz4Z35wAhZEHi1UjDX4ZOHhSU-Gdba0GNHegdJrWa7gtTXdVeOGCQ","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 |
|---|---|---|---|---|---|---|
Map a list in which element turns scalar element | def scalar_mult(scalar, lista):
return [scalar * element for element in lista] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simple_map(f, l):\n # Again, my first take is a list comprehension.\n return [ f(item) for item in l ]",
"def maplist(f, xs):\n return list(map(f, xs))",
"def simple_map_2(f, l):\n # Same as above without comprehension:\n mapped_l = []\n for item in l:\n mapped_l.append( f(item) ) ... | [
"0.73322433",
"0.72311175",
"0.7190859",
"0.67876816",
"0.6712773",
"0.6535357",
"0.64992934",
"0.64565027",
"0.64177424",
"0.64035016",
"0.6357955",
"0.63018423",
"0.6299705",
"0.62501806",
"0.6207463",
"0.6158768",
"0.6149128",
"0.6136963",
"0.6033882",
"0.60334474",
"0.596... | 0.578542 | 31 |
This function transforms the text corpus with a TfidfVectorizer and trains a Naive Bayes model. Parameter | def train_mnb(X, y, **kwargs):
tf = TfidfVectorizer()
m = MultinomialNB(**kwargs)
pipeline = make_pipeline(tf, m)
pipeline.fit(X, y)
print(f"\ntraining accuracy: {round(pipeline.score(X, y),3)}")
cross_val = cross_val_score(pipeline, X, y, cv=5)
print(f'\ncross-validation accuracy: {cross_va... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self, trainfile):\r\n\r\n # We load the data and lower the text\r\n data_train = pd.read_csv(trainfile, sep = \"\\t\", names = [\"polarity\", \"category\", \"word\", \"offsets\", \"sentence\"])\r\n data_train['sentence_l'] = data_train['sentence'].apply(str.lower)\r\n data_tra... | [
"0.7041745",
"0.6892703",
"0.68457866",
"0.67108583",
"0.66450006",
"0.66246396",
"0.6598008",
"0.6502297",
"0.6480821",
"0.6453072",
"0.6444225",
"0.6428157",
"0.6400798",
"0.6360958",
"0.63345605",
"0.63037866",
"0.6293806",
"0.6275498",
"0.6251998",
"0.6239459",
"0.6236153... | 0.0 | -1 |
Replace characters that are ok for the filesystem but have special meaning in the shell. It is assumed file_path is already passed in double quotes. | def sanitize_file_path_for_shell(file_path):
file_path_sanitized = file_path.replace('\\', '\\\\')
file_path_sanitized = file_path_sanitized.replace('$', '\\$')
file_path_sanitized = file_path_sanitized.replace('"', '\\"')
file_path_sanitized = file_path_sanitized.replace('`', '\\`')
return file_pat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _escape_path(path):\n path = path.strip()\n return '\"{0}\"'.format(path) if _platform_windows else path.replace(\" \", \"\\ \")",
"def sanitize_file_path(file_path, replacement_text=\"\"):\n\n return __RE_INVALID_PATH.sub(replacement_text, file_path.strip())",
"def _escape_filename(self, filename... | [
"0.71783984",
"0.71233505",
"0.7065954",
"0.70276165",
"0.6792996",
"0.667642",
"0.6659069",
"0.65962875",
"0.6565966",
"0.65407276",
"0.6515731",
"0.649737",
"0.647577",
"0.64607286",
"0.6425371",
"0.6413269",
"0.6343448",
"0.62579924",
"0.6134818",
"0.61246663",
"0.61156386... | 0.7965993 | 0 |
create session before each request | def set_db_session():
g.s = database.db_session() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_session(self):\n self.session = requests.Session() # pragma: no cover\n self.session.headers[\"Accept\"] = \"application/json\" # pragma: no cover\n if self.user: # pragma: no cover\n self.session.auth = (self.user, self.cred) # pragma: no cover",
"def before_reque... | [
"0.7623372",
"0.7430753",
"0.73650914",
"0.7351063",
"0.7351063",
"0.7216878",
"0.7167172",
"0.71506554",
"0.71009123",
"0.704625",
"0.70091945",
"0.7002909",
"0.70023346",
"0.70022875",
"0.69955266",
"0.68908185",
"0.68709975",
"0.68529636",
"0.68171114",
"0.68158793",
"0.67... | 0.0 | -1 |
Returns the corresponding Recent Location. | def get_location(self) -> models.Location:
return models.Location.get(region=self, name=self.name, deleted=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_current_location(self):\n return self.get_queryset().filter(status=self.model.CURRENT).first()",
"def most_recent_coordinates(self):\n location = Location.objects.get(id=self.most_recent_location_id)\n\n return location.position['coordinates']",
"def getMostRecent(self):\n ... | [
"0.6604315",
"0.6441396",
"0.6436993",
"0.6409579",
"0.6325625",
"0.62447786",
"0.62360996",
"0.61787456",
"0.6150267",
"0.61499745",
"0.61066777",
"0.6100615",
"0.6090599",
"0.6090599",
"0.6046029",
"0.6039892",
"0.5983601",
"0.5983601",
"0.5960603",
"0.5948464",
"0.5934924"... | 0.6258611 | 5 |
Returns all parent regions of this region. | def all_parents(self) -> Iterable[Region]:
if self.parent is not None:
yield self.parent
yield from self.parent.all_parents() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def children(self) -> List[Region]:\n return []",
"def getParents(self):\n return self.parents[:]",
"def parent_ids(self):\n return self._parent_ids",
"def region(self):\n return [node.region for node in self]",
"def children(self) -> List[Region]:\n return self._children... | [
"0.7434008",
"0.7339606",
"0.7157085",
"0.7153343",
"0.7056081",
"0.6984813",
"0.6946143",
"0.6928434",
"0.6888119",
"0.6858729",
"0.6857094",
"0.6851539",
"0.68390924",
"0.6822237",
"0.682013",
"0.67900497",
"0.676651",
"0.6735071",
"0.6715634",
"0.6683919",
"0.668044",
"0... | 0.8541655 | 0 |
Initialize attributes to describe a car | def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
# default value for a data attribute not matched by a parameter
self.odometer_reading = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, car):\n super(self.__class__, self).__init__(car)\n self.coordinator_name = car.get_faulty_coordinator_name()\n self.second_at_charge_name = car.get_second_at_charge_name()\n self.coordinated_car_name = car.get_corrected_coordinated_car_name()\n self.following_... | [
"0.7682444",
"0.7564797",
"0.7197258",
"0.7195483",
"0.7105557",
"0.694793",
"0.694793",
"0.694793",
"0.68839586",
"0.6785889",
"0.6748675",
"0.67431015",
"0.67331845",
"0.66451067",
"0.6464271",
"0.64505064",
"0.643961",
"0.6439453",
"0.64178514",
"0.6395654",
"0.63946205",
... | 0.6249929 | 29 |
Return a neatly formatted descriptive name | def get_descriptive_name(self):
return f"{self.year} {self.make} {self.model}".title() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_descriptive_name(self):\n long_name = f\"{self.make} {self.model} {self.year}\"\n \n return long_name.title()",
"def get_descriptive_name(self):\n long_name = f\"{self.year} {self.make} {self.model}\"\n return long_name.title()",
"def get_descriptive_name(self):\r\n ... | [
"0.82712626",
"0.8233793",
"0.81636363",
"0.8123895",
"0.8123895",
"0.8123895",
"0.8123895",
"0.8123895",
"0.8123895",
"0.8123895",
"0.8123895",
"0.81226194",
"0.8022516",
"0.79681844",
"0.79071957",
"0.78473455",
"0.77523863",
"0.77043635",
"0.76816696",
"0.7679536",
"0.7660... | 0.8013531 | 13 |
A method that is going to be overridden | def fill_gas_tank(self):
print("Filling the tank for", self.get_descriptive_name()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self):\r\n raise NotImplementedError('override me')",
"def __call__(self):\n raise NotImplementedError",
"def __call__(self):\n raise NotImplementedError()",
"def override(self):\n return None",
"def __call__( self ):\n pass",
"def __call__(self):\n\t\tretu... | [
"0.8271088",
"0.7843803",
"0.7668648",
"0.7631912",
"0.75162923",
"0.75038874",
"0.74938595",
"0.74938595",
"0.7470797",
"0.7404255",
"0.7288453",
"0.72610587",
"0.72610587",
"0.72610587",
"0.7230123",
"0.7177749",
"0.71770835",
"0.71770835",
"0.71261805",
"0.7083847",
"0.705... | 0.0 | -1 |
Initialize the battery's attributes. | def __init__(self, battery_size=40):
self.battery_size = battery_size | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, battery_size=70):\r\n\t\tself.battery_size = battery_size",
"def __init__(self, battery_size=70):\n self.battery_size = battery_size",
"def __init__(self, battery_size=70):\n self.battery_size = battery_size",
"def __init__(self, battery_size=70):\n self.battery_size =... | [
"0.7373256",
"0.73601586",
"0.73601586",
"0.73601586",
"0.734221",
"0.734221",
"0.7319005",
"0.7316006",
"0.72850525",
"0.7227408",
"0.72071785",
"0.7196292",
"0.6998248",
"0.696277",
"0.69499767",
"0.6907041",
"0.6907041",
"0.6907041",
"0.6907041",
"0.6907041",
"0.6907041",
... | 0.7383211 | 0 |
Print a statement describing the battery size. | def describe_battery(self):
print(f"This car has a {self.battery_size}-kWh battery.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def describe_battery(self):\r\n\t\tprint(\"This car has a \" + str(self.battery_size) + \"-kWh battery.\")",
"def describe_battery(self):\r\n print(\"This car has a \" + str(self.battery_size) + \"-kWh battery.\")",
"def describe_battery(self):\n print(\"This car has a \"+str(self.battery_size)+\... | [
"0.8077025",
"0.80585897",
"0.80483544",
"0.7991147",
"0.7991147",
"0.7991147",
"0.7991147",
"0.7991147",
"0.7991147",
"0.7977282",
"0.7844624",
"0.7842952",
"0.781898",
"0.76121926",
"0.6630486",
"0.64125836",
"0.62330794",
"0.6192078",
"0.61695147",
"0.6145232",
"0.61055034... | 0.7825442 | 14 |
Print a statement about the range this battery provides. | def get_range(self):
if self.battery_size == 40:
range = 150
elif self.battery_size == 65:
range = 225
print(f"This car can go about {range} miles on a full charge.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_range(self):\r\n\t\tif self.battery_size == 70:\r\n\t\t\trange = 240\r\n\t\telif self.battery_size == 85:\r\n\t\t\trange = 270\r\n\t\t\t\r\n\t\tmessage = \"This car can go approx. \" + str(range)\r\n\t\tmessage += \" miles on a full charge.\"\r\n\t\tprint(message)",
"def get_range(self):\n if self... | [
"0.7663095",
"0.76585656",
"0.76337993",
"0.7627849",
"0.7579565",
"0.75276333",
"0.7510972",
"0.7475078",
"0.74686944",
"0.7214683",
"0.6869354",
"0.6118391",
"0.5908394",
"0.5883784",
"0.5820139",
"0.5802177",
"0.5795216",
"0.5795216",
"0.5795216",
"0.5763995",
"0.5734394",... | 0.7608142 | 4 |
Initialize attributes of the parent class Call the constructor of the base class Then define the data member for the current class | def __init__(self, make, model, year):
super().__init__(make, model, year)
self.battery = Battery() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, parent=None, **kwargs):\n self.__dict__.update(_dict=dict(), parent=parent)\n self.declare(**kwargs)",
"def __init__(self, name, age, billing):\n super().__init__(name, age)\n \"\"\"Define own properties in children class\"\"\"\n self.billing = billing",
"d... | [
"0.7136743",
"0.70918214",
"0.7000738",
"0.6974844",
"0.6974844",
"0.6889836",
"0.6814976",
"0.67724675",
"0.6718611",
"0.67166483",
"0.66260177",
"0.66138333",
"0.6600251",
"0.658364",
"0.6583424",
"0.6581016",
"0.65571094",
"0.65444577",
"0.65402037",
"0.6535905",
"0.653228... | 0.0 | -1 |
Print a statement describing the battery size. Extends the base interface adding a new method specific for this class | def describe_battery(self):
self.battery.describe_battery() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def describe_battery(self):\r\n print(\"This car has a \" + str(self.battery_size) + \"-kWh battery.\")",
"def describe_battery(self):\n print(\"This car has a \"+str(self.battery_size)+\"-KWh battery.\")",
"def describe_battery(self):\r\n\t\tprint(\"This car has a \" + str(self.battery_size) + \... | [
"0.8252661",
"0.8244354",
"0.823131",
"0.8196981",
"0.8138175",
"0.8138175",
"0.8138175",
"0.8138175",
"0.8138175",
"0.8138175",
"0.8101542",
"0.8101542",
"0.8101542",
"0.80835646",
"0.8036482",
"0.7874975",
"0.7828315",
"0.6725298",
"0.67208236",
"0.67208236",
"0.67208236",
... | 0.6976863 | 17 |
Implicit method override Electric cars don't have gas tanks | def fill_gas_tank(self):
print("This car doesn't have a gas tank!") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fill_gas_tank(self):\r\n\t\tprint(\"This car doesn't need a gas tank.\")",
"def fill_gas_tank(self):\n print(\"This car doesn't need a gas tank!\")",
"def fill_gas_tank(self):\n print(\"This car doesn't need a gas tank!\")",
"def fill_gas_tank(self):\n print(\"\\nThis car doesn't... | [
"0.69217145",
"0.6831921",
"0.6831921",
"0.6540081",
"0.61860675",
"0.6126857",
"0.6059359",
"0.5955987",
"0.5778402",
"0.57008517",
"0.56938565",
"0.56021523",
"0.5577644",
"0.54664433",
"0.5426959",
"0.54259795",
"0.54092133",
"0.5356318",
"0.5295983",
"0.5295983",
"0.52959... | 0.68206114 | 3 |
Function to generate ground truth labels as specified by int_limit. | def generate_true_labels(int_limit, n_obs):
if int_limit > 0:
if int_limit > n_obs:
raise ValueError(f"""Invalid value of int_limit {int_limit}:
greater than the number of sequences""")
else:
true_labels = [1 if idx <=
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_cut_labels(var, bin_edges, bottom_inclusive=True):\n incl = '=' if bottom_inclusive else ''\n return ['{low:g} <{incl} {var} < {high:g}'.format(var=var, low=bin_low,\n high=bin_high, incl=incl)\n for (bin_low, bin_high) in bin_edges... | [
"0.58891654",
"0.58660847",
"0.58303446",
"0.5694453",
"0.5692392",
"0.5666728",
"0.56513286",
"0.5643508",
"0.5582945",
"0.54308045",
"0.5425018",
"0.5418894",
"0.5386328",
"0.5373158",
"0.5323061",
"0.53213376",
"0.53181946",
"0.53151214",
"0.5308631",
"0.52794737",
"0.5237... | 0.75520366 | 0 |
Return a new minio client based on given endpoints and credentials | def connect(**kwargs) -> Minio:
global client
client = Minio(
SETTINGS.s3.endpoint,
access_key=SETTINGS.s3.access_key,
secret_key=SETTINGS.s3.secret_key,
secure=SETTINGS.s3.secure,
**kwargs,
)
logger.debug(
f"Successfully connected to S3 server on endpoint... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_minio_client(\n host=\"minio\", \n port=\"9000\", \n access_key=\"minio\", \n secret_key=\"minio123\", \n secure=False\n ):\n return Minio(\n endpoint=f\"{host}:{port}\",\n access_key=access_key,\n secret_key=secret_key,\n secure=secure\n )",
"def g... | [
"0.731455",
"0.723306",
"0.69170517",
"0.6855766",
"0.67673016",
"0.67613757",
"0.6466971",
"0.61935866",
"0.61898446",
"0.61510766",
"0.61457545",
"0.6138061",
"0.6063103",
"0.59764355",
"0.59592575",
"0.59241456",
"0.58898264",
"0.5886738",
"0.5864017",
"0.5790241",
"0.5770... | 0.59089184 | 16 |
Create the bucket where all datasets will be stored | def create_bucket() -> None:
try:
client.make_bucket(DATASETS_BUCKET)
except BucketAlreadyOwnedByYou:
logger.debug(f"Not creating bucket {DATASETS_BUCKET}: Bucket already exists")
pass
else:
logger.debug(f"Successfully created bucket {DATASETS_BUCKET}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_buckets():\n s3 = boto.connect_s3()\n s3.create_bucket('mls_data.mls.angerilli.ca')",
"def create_and_fill_bucket(self):\n EmrProcessing.bucket = \\\n self.s3_handle.create_bucket(EmrProcessing.bucket_name)\n key = EmrProcessing.bucket.new_key('input/test.csv')\n i... | [
"0.71161413",
"0.6791009",
"0.67162263",
"0.6680957",
"0.6674802",
"0.6673578",
"0.64413446",
"0.63897455",
"0.63669753",
"0.63237906",
"0.631078",
"0.6286531",
"0.62792015",
"0.6254688",
"0.62064546",
"0.62060267",
"0.61797833",
"0.61677337",
"0.61318856",
"0.61285365",
"0.6... | 0.692468 | 1 |
Retrieve an object from datasets bucket | def get_file(object_name: str, **kwargs) -> HTTPResponse:
data = client.get_object(DATASETS_BUCKET, object_name, **kwargs)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, bucket: str, object_name: str) -> bytes:\n raise NotImplementedError()",
"def get_object(self, bucket_name, key, stream=False, extra_get_args={}):\n url = self.__key_url(bucket_name, key)\n res = self.infinispan_client.get(url, headers=self.headers, auth=self.basicAuth)\n ... | [
"0.6928165",
"0.67026985",
"0.6629515",
"0.6608332",
"0.6491294",
"0.6458658",
"0.6420723",
"0.6378986",
"0.6354143",
"0.6300951",
"0.61703414",
"0.6160772",
"0.6131997",
"0.60850906",
"0.6043375",
"0.59998703",
"0.5998574",
"0.5989563",
"0.59847516",
"0.59839803",
"0.597959"... | 0.66965616 | 2 |
Put an object into datasets bucket | async def put_file(object_name: str, file: File, **kwargs) -> str:
# TODO: Do not read file but rather stream content as it comes
await file.read()
# Get the synchronous file interface from the asynchronous file
file_obj = file.file
# Store position of cursor (number of bytes read)
file_size = f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put_object(self, key, data):\n self.s3client.put_object(Bucket=self.s3_bucket, Key=key, Body=data)",
"def put_object(self, bucket_name, key, data):\n url = self.__key_url(bucket_name, key)\n resp = self.infinispan_client.put(url, data=data,\n auth... | [
"0.73082185",
"0.7173861",
"0.69983566",
"0.6985764",
"0.6830087",
"0.6717999",
"0.66830075",
"0.6659365",
"0.64738876",
"0.64718133",
"0.63807553",
"0.6379868",
"0.6363792",
"0.63152105",
"0.6307537",
"0.62962",
"0.6230256",
"0.6186309",
"0.61797756",
"0.61682147",
"0.615810... | 0.0 | -1 |
Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta. Note that decimal places (from zero) are usually not the same as significant digits (measu... | def almost_equal(first, second, places=None, delta=0.1):
if first == second:
# shortcut
return True
if delta is not None and places is not None:
raise TypeError("specify delta or places not both")
if delta is not None:
if abs(first - second) <= del... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def almost_equals(self, other, decimal=...): # -> bool:\n ...",
"def assert_almost_equal(self, val1, val2, delta):\n return self.assertTrue(\n 0 <= abs(val1 - val2) <= delta,\n \"Absolute difference of {} and {} ({}) is not within {}\".format(\n val1,\n ... | [
"0.68236005",
"0.6749057",
"0.6739666",
"0.670881",
"0.6466249",
"0.6378507",
"0.6307229",
"0.62476826",
"0.62318397",
"0.62042546",
"0.6183346",
"0.6175197",
"0.61698675",
"0.6129581",
"0.61233366",
"0.61050105",
"0.60785776",
"0.6067823",
"0.60575235",
"0.6055449",
"0.60546... | 0.67849344 | 1 |
Rude check if uuid is in correct uuid1 format. | def validate_uuid(self, uuid):
match = re.match(
r'([a-z0-9]+)-([a-z0-9]+)-([a-z0-9]+)-([a-z0-9]+)-([a-z0-9]+)',
uuid
)
if match:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_uuid(uuid):\n try:\n converted = UUID(uuid, version=4)\n except ValueError:\n return False\n\n return str(converted) == uuid",
"def validate_uuid(uuid_string):\n try:\n UUID(uuid_string, version=4)\n return True\n except:\n return False",
"def is_vali... | [
"0.7841857",
"0.756394",
"0.7472721",
"0.739947",
"0.73708713",
"0.73455393",
"0.7301181",
"0.71633416",
"0.71633416",
"0.7073445",
"0.7024794",
"0.6966057",
"0.69361615",
"0.69247895",
"0.6830562",
"0.67718047",
"0.6766432",
"0.67584354",
"0.65963656",
"0.65020233",
"0.64920... | 0.75939476 | 1 |
Checks if the CSV file contains all required columns. | def validate_column_names(self, cols):
self.stdout.write('Verifying CSV header')
csv_cols = set(cols)
if self.required_csv_columns <= csv_cols:
return True
else:
missing_cols = set(self.required_csv_columns).difference(csv_cols)
raise ValidationError(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_csv(filename, header, cols, rows):\n\n # open file\n data = pd.read_csv(filename, delimiter='|')\n\n # validate header\n assert header == '|'.join(list(data.columns.values))\n\n # validate column count\n assert data.shape[1] == cols\n\n # validate row count\n assert data.shape[... | [
"0.74219674",
"0.71559626",
"0.7064051",
"0.7044676",
"0.6933204",
"0.6880624",
"0.6842778",
"0.67009544",
"0.6593976",
"0.6554927",
"0.65337193",
"0.64992315",
"0.6493306",
"0.64672685",
"0.6462007",
"0.64533734",
"0.64333785",
"0.6407367",
"0.63730824",
"0.63719225",
"0.636... | 0.77545106 | 0 |
Concatenate observation data into one string. | def concatenate_observation_data(
self, compartment, date, measurementmethod, orig_srid, origx, origy,
parameter, property, quality, sampledevice, samplemethod, unit, value,
):
# Convert to string before joining
data = map(str, [
compartment, date, measurementmethod, orig... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def concatenate_data():",
"def __str__(self):\n return ', '.join(str(item) for item in self._data)",
"def obs_to_string(observations):\n str_obs = []\n for obs in observations:\n str_obs.append(obs.reshape(-1).tostring())\n return str_obs",
"def __str__(self):\n lst = [str(i) fo... | [
"0.724462",
"0.6176857",
"0.6093485",
"0.60458475",
"0.5983507",
"0.59311306",
"0.59206545",
"0.58791316",
"0.5874102",
"0.5709245",
"0.57053846",
"0.5704484",
"0.5695554",
"0.5685938",
"0.5673281",
"0.565494",
"0.56044185",
"0.55893093",
"0.5557514",
"0.55474746",
"0.5525495... | 0.78445834 | 0 |
Parses chunk and puts it in a dict, which is used to insert data in DB. | def chunk_to_dict(chunk):
csv_cols = chunk.keys()
return [dict(zip(csv_cols, v)) for v in chunk.values] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readchunk(self):\n chunksize = self.readdword()\n chunktype = ChunkType(self.readword())\n chunkdata = self.readbytearr(chunksize - 6)\n return {\n \"type\": chunktype,\n \"data\": _ParseChunk(chunktype, chunkdata, self.PIXELSIZE),\n }",
"async def par... | [
"0.6791292",
"0.62264615",
"0.59367365",
"0.57398707",
"0.57072264",
"0.5562959",
"0.5515545",
"0.54788476",
"0.5358384",
"0.53143746",
"0.53005743",
"0.5295604",
"0.5294302",
"0.52832663",
"0.52484864",
"0.52410567",
"0.5231699",
"0.52220035",
"0.52200276",
"0.5217106",
"0.5... | 0.5903628 | 3 |
Removes Observations or removes related Environments. | def remove_or_deref_observations(self, processing_job):
cursor = connection.cursor()
env_hash = self.make_env_hash(processing_job)
# Update observations which have the same environment setup.
# Removes these items from the array.
self.stdout.write('Dereference environment {0} in ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def env_remove(args):\n read_envs = []\n for env_name in args.rm_env:\n env = ev.read(env_name)\n read_envs.append(env)\n\n if not args.yes_to_all:\n answer = tty.get_yes_or_no(\n \"Really remove %s %s?\"\n % (\n string.plural(len(args.rm_env), \"e... | [
"0.62257844",
"0.6080496",
"0.5872701",
"0.58601445",
"0.5766776",
"0.57624966",
"0.5742403",
"0.5738756",
"0.56853753",
"0.5683202",
"0.5669383",
"0.56654215",
"0.5665408",
"0.5649904",
"0.5649904",
"0.5643665",
"0.56427264",
"0.5626603",
"0.5625567",
"0.55980545",
"0.559113... | 0.7031861 | 0 |
Check if concatenated_observation_data is in self.observations | def observation_exists_locally(self, concatenated_observation_data):
local_observation = self.observations.get(
concatenated_observation_data,
None
)
if local_observation:
return local_observation['observation'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def observation_exists(self, concatenated_observation_data):\n local_observation = self.observation_exists_locally(\n concatenated_observation_data\n )\n if local_observation:\n return local_observation\n\n try:\n return Observation.objects.get(\n ... | [
"0.65428954",
"0.626618",
"0.5845177",
"0.5799288",
"0.57642674",
"0.5685769",
"0.55044246",
"0.5491718",
"0.54879206",
"0.5462496",
"0.5368831",
"0.5367507",
"0.5330643",
"0.5304856",
"0.530262",
"0.5287393",
"0.52781326",
"0.52779424",
"0.52746606",
"0.5272336",
"0.52582705... | 0.70318484 | 0 |
Checks if an observation with the same data already exists. | def observation_exists(self, concatenated_observation_data):
local_observation = self.observation_exists_locally(
concatenated_observation_data
)
if local_observation:
return local_observation
try:
return Observation.objects.get(
conca... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_already_present(self, new_da):\n for da in self:\n self._id_of_DataArrays_equal(da, new_da)",
"def check_if_duplicate(self, data):\n\n query = \"SELECT * FROM {} WHERE topic = '{}' AND location = '{}'\\\n \".format(self.table, data['topic'], data['location'])\n\n ... | [
"0.71108025",
"0.702407",
"0.66583943",
"0.65662485",
"0.6549493",
"0.6468821",
"0.6406193",
"0.64007765",
"0.6364914",
"0.6243635",
"0.6242653",
"0.621726",
"0.62128055",
"0.6174885",
"0.6150819",
"0.6140846",
"0.6126474",
"0.59956187",
"0.5966047",
"0.5962848",
"0.5959198",... | 0.6416996 | 6 |
Returns False if point does not exist, else return locationpoint id | def point_exists(self, point):
qs = LocationPoint.objects.raw("""
SELECT * FROM script_execution_manager_locationpoint
WHERE st_dwithin(
thegeometry,
st_transform(
st_setsrid(
st_point({point.x}, {point.y}), {point.sri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isSetId(self):\n return _libsbml.Point_isSetId(self)",
"def check_point(point,points):\n if point in points:\n return True\n else:\n return False",
"def find_point(self, point: Point):\n for internal_point in self.points:\n if internal_point == point:\n ... | [
"0.65851754",
"0.60588527",
"0.59962666",
"0.5944725",
"0.58938813",
"0.5892437",
"0.58379346",
"0.5795499",
"0.57793",
"0.576884",
"0.5735127",
"0.57340264",
"0.5658171",
"0.56532735",
"0.5652695",
"0.56121695",
"0.5558224",
"0.5546083",
"0.5536352",
"0.5525766",
"0.5519552"... | 0.73598516 | 0 |
Create observation related to existing or new LP. | def create_observation(
self, location_point, dictified_chunk, published, processing_job
):
errors = []
def get_relations(model, field):
"""
Gets relation or adds error message to errors list. Errors should be
descriptive to user. (Standard DoesNotExist e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_observation(self):",
"def create_observation(self):",
"def create_observation(self):\n return self._user_state.create_observation()",
"def new_observation(self, mode=NEW, obsId=\"\"):\n # check if current observation must be closed to create a new one\n if mode == NEW and self.obs... | [
"0.5966779",
"0.5966779",
"0.56633604",
"0.56257737",
"0.5275226",
"0.52512157",
"0.5241649",
"0.5192232",
"0.5145275",
"0.5077749",
"0.5063368",
"0.5051711",
"0.5014516",
"0.4991801",
"0.4839248",
"0.4837828",
"0.48263907",
"0.48166376",
"0.4793916",
"0.4787702",
"0.47759995... | 0.46837047 | 32 |
Gets relation or adds error message to errors list. Errors should be descriptive to user. (Standard DoesNotExist errors are not.) If a value is NaN, None is returned. | def get_relations(model, field):
field_iexact = '{0}__exact'.format(field)
value = dictified_chunk[model.__name__.lower()]
if type(value) == float and math.isnan(value):
return None
try:
return model.objects.get(**{
fie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def error(self):\n errors = self._info.get('error', {}).get('errors')\n if not errors:\n return None\n return ' '.join(err.get('message', 'unknown') for err in errors)",
"def get_error(self):\n p = self._get_sub_text('error')\n if not p:\n return None\n else:\n ... | [
"0.60867625",
"0.566688",
"0.5566653",
"0.5510137",
"0.5510137",
"0.5510137",
"0.5510137",
"0.5510137",
"0.5510137",
"0.5510137",
"0.5442257",
"0.5405362",
"0.5397558",
"0.536908",
"0.5291303",
"0.5285853",
"0.5274996",
"0.52188915",
"0.517312",
"0.517312",
"0.5161423",
"0.... | 0.47182307 | 79 |
Adds LocationPoint if it does not exists. Relates observation to point. | def chunk_to_db(self, dictified_chunks, published, processing_job):
self.observations = {}
new_location_points = []
existing_location_points = []
for dc in dictified_chunks:
point = Point(dc['origx'], dc['origy'], srid=dc['orig_srid'])
lp = self.point_exists(point... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append_point(self, point):\n self._points.append(point)",
"def add_point(self, point: Point, interesting=False) -> Point:\n if point not in self.points:\n if not point.name:\n point.name = alphabet(len(self.points))\n self.points.add(point)\n if i... | [
"0.6725591",
"0.67133373",
"0.6681482",
"0.66755474",
"0.66706175",
"0.6607873",
"0.6607873",
"0.6607873",
"0.6607873",
"0.6607873",
"0.6607873",
"0.6607873",
"0.6529323",
"0.64986783",
"0.64739203",
"0.6390155",
"0.6384036",
"0.634297",
"0.63195705",
"0.62687486",
"0.6237278... | 0.0 | -1 |
Saves all observations from the observation 'registry'. | def save_observations(self, observations):
Observation.objects.bulk_create(
[v['observation'] for v in observations.itervalues() if v['created']]
)
for v in observations.itervalues():
if not v['created']:
v['observation'].save() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self):\r\n for obs_name in self.__dict__.keys():\r\n if obs_name is not \"_ObjetSimu__obs\":\r\n if not obs_name in self.__sous_objets:\r\n if obs_name in self.__obs.keys():\r\n if \"copy\" in dir(self.__dict__[obs_name]):\r\n ... | [
"0.73052555",
"0.6733764",
"0.6608693",
"0.6594945",
"0.657012",
"0.64871424",
"0.64703155",
"0.6384951",
"0.62907267",
"0.6276889",
"0.62471867",
"0.62202305",
"0.6190579",
"0.61807287",
"0.6172243",
"0.610022",
"0.6061101",
"0.60320276",
"0.60176027",
"0.60088223",
"0.59973... | 0.6606781 | 3 |
we include a valid route and controllers | def test_response_without_method(app_client, path):
app_iter, status, headers = app_client.get(path)
assert status.upper() == '404 NOT FOUND', "A status 404 is necesary, but a status {} was got from the request".format(
status) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def includeme(config):\n config.add_route('home', '/')\n config.add_route('detail', '/detail/{id:\\d+}')\n config.add_route('update', '/edit/{id:\\d+}')\n config.add_route('create', '/create')",
"def add_routes(self):\n pass",
"def route(self):\n pass",
"def route( request, c ):... | [
"0.62387675",
"0.622436",
"0.6139062",
"0.61008644",
"0.6092722",
"0.5983449",
"0.5922116",
"0.5919165",
"0.5895856",
"0.58876914",
"0.587018",
"0.58597404",
"0.5856948",
"0.58300674",
"0.58160836",
"0.57912624",
"0.57350916",
"0.57123536",
"0.57119346",
"0.5641473",
"0.56345... | 0.0 | -1 |
we include a valid route and controllers | def test_response_without_method_routes(app_routes, path):
app_iter, status, headers = app_routes.get(path)
assert status.upper() == '200 OK', "A status 200 is necesary, but a status {} was got from the request".format(
status)
assert get_body_request(
app_iter) == '200 OK', "The default fro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def includeme(config):\n config.add_route('home', '/')\n config.add_route('detail', '/detail/{id:\\d+}')\n config.add_route('update', '/edit/{id:\\d+}')\n config.add_route('create', '/create')",
"def add_routes(self):\n pass",
"def route(self):\n pass",
"def route( request, c ):... | [
"0.62387526",
"0.6224374",
"0.61399716",
"0.6102114",
"0.609112",
"0.59813225",
"0.59221673",
"0.59184855",
"0.58958554",
"0.5886427",
"0.58700645",
"0.5857996",
"0.5854663",
"0.58290184",
"0.58146137",
"0.5788888",
"0.57340324",
"0.5710644",
"0.5709957",
"0.56408924",
"0.563... | 0.0 | -1 |
Make a CarlaSettings object with the settings we need. | def make_carla_settings(args):
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=0,
NumberOfPedestrians=0,
SeedVehicles = '00000',
WeatherId=1,
QualityLevel=args.quality_level)
settings.random... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_carla_settings(args):\n settings = CarlaSettings()\n settings.set(\n SynchronousMode=False,\n SendNonPlayerAgentsInfo=True,\n NumberOfVehicles=NUM_VEHICLES,\n NumberOfPedestrians=NUM_PEDESTRIANS,\n WeatherId=random.choice([1, 3, 7, 8, 14]),\n QualityLevel=ar... | [
"0.7046542",
"0.64021003",
"0.6321816",
"0.59555054",
"0.58940154",
"0.5859983",
"0.58227974",
"0.5814349",
"0.5743213",
"0.5712618",
"0.56494814",
"0.563011",
"0.56196254",
"0.56128407",
"0.55752116",
"0.5572938",
"0.5552482",
"0.5540732",
"0.55223477",
"0.5518125",
"0.54987... | 0.8063497 | 0 |
INTERNAL USE ONLY Get the fact in the KB that is the same as the fact argument | def _get_fact(self, fact):
for kbfact in self.facts:
if fact == kbfact:
return kbfact | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFact(self, fact):\n for kbfact in self.kb.facts:\n if fact == kbfact:\n return True\n return False",
"def fact(self, name):\n facts = self.facts(name=name)\n return next(fact for fact in facts)",
"def get_furniture():",
"def parse_fact(self, factel... | [
"0.64909446",
"0.55313945",
"0.55220604",
"0.545844",
"0.54017186",
"0.5279208",
"0.526946",
"0.524799",
"0.5233914",
"0.5233914",
"0.5068595",
"0.50262606",
"0.4968205",
"0.4955512",
"0.49484053",
"0.4944101",
"0.49107435",
"0.48900303",
"0.4867359",
"0.4864705",
"0.4863232"... | 0.70821464 | 2 |
INTERNAL USE ONLY Get the rule in the KB that is the same as the rule argument | def _get_rule(self, rule):
for kbrule in self.rules:
if rule == kbrule:
return kbrule | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getRule(self, *args):\n return _libsbml.Model_getRule(self, *args)",
"def get_rule(self):\n\n return self.__rule_",
"def rule(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"rule\")",
"def rule(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"rule\")",
"def ru... | [
"0.72598034",
"0.69801867",
"0.69057363",
"0.69057363",
"0.69057363",
"0.676362",
"0.67517036",
"0.6723854",
"0.6723854",
"0.6723854",
"0.6723854",
"0.6723854",
"0.6723854",
"0.6723854",
"0.6402129",
"0.63560486",
"0.63248295",
"0.628659",
"0.6276691",
"0.61988664",
"0.616951... | 0.79268336 | 2 |
Add a fact or rule to the KB | def kb_add(self, fact_rule):
printv("Adding {!r}", 1, verbose, [fact_rule])
if isinstance(fact_rule, Fact):
if fact_rule not in self.facts:
self.facts.append(fact_rule)
for rule in self.rules:
self.ie.fc_infer(fact_rule, rule, self)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kb_add(self, fact_rule):\n printv(\"Adding {!r}\", 1, verbose, [fact_rule])\n if isinstance(fact_rule, Fact):\n if fact_rule not in self.facts:\n self.facts.append(fact_rule)\n for rule in self.rules:\n self.ie.fc_infer(fact_rule, rule, ... | [
"0.75052065",
"0.67358214",
"0.66465557",
"0.6613316",
"0.6535551",
"0.64647514",
"0.64200574",
"0.6356476",
"0.63013196",
"0.61622655",
"0.6102377",
"0.60814255",
"0.60814255",
"0.60814255",
"0.60700375",
"0.5975886",
"0.5965079",
"0.5875529",
"0.5841823",
"0.58227754",
"0.5... | 0.75037193 | 2 |
Assert a fact or rule into the KB | def kb_assert(self, fact_rule):
printv("Asserting {!r}", 0, verbose, [fact_rule])
self.kb_add(fact_rule) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kb_assert(self, fact):\n if isinstance(fact, Fact): #check if it's an instance of fact\n if (fact.name is \"fact\"): #checking if it is a fact/ double check\n for x in self.facts:\n if (x == fact): #if the fact is already in the kb\n ... | [
"0.7594763",
"0.62535036",
"0.6135857",
"0.6124177",
"0.5977059",
"0.5977059",
"0.5968787",
"0.5905811",
"0.58380437",
"0.57631975",
"0.576085",
"0.5709365",
"0.56988823",
"0.56957656",
"0.56953454",
"0.5676461",
"0.5652195",
"0.5644657",
"0.56348133",
"0.5627622",
"0.5623301... | 0.78474134 | 2 |
Ask if a fact is in the KB | def kb_ask(self, fact):
print("Asking {!r}".format(fact))
if factq(fact):
f = Fact(fact.statement)
bindings_lst = ListOfBindings()
# ask matched facts
for fact in self.facts:
binding = match(f.statement, fact.statement)
if b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_kb_status():\n result = minisat(agent.kb.clauses)\n if result:\n print \"Agent KB is satisfiable\"\n else:\n print \"Agent KB is NOT satisfiable!! There is contradiction that needs fixing!\"",
"def getFact(self, fact):\n for kbfact in self.kb.facts:\n ... | [
"0.67102563",
"0.64609563",
"0.55531037",
"0.5546491",
"0.5480997",
"0.5480862",
"0.546851",
"0.5426157",
"0.53731054",
"0.5303705",
"0.5283261",
"0.5274328",
"0.5240789",
"0.5233031",
"0.5215956",
"0.5210727",
"0.52056134",
"0.52027833",
"0.51916176",
"0.518918",
"0.5165558"... | 0.0 | -1 |
Retract a fact from the KB | def kb_retract(self, fact_or_rule):
printv("Retracting {!r}", 0, verbose, [fact_or_rule])
####################################################
# Student code goes here
if fact_or_rule in self.facts:
ind = self.facts.index(fact_or_rule)
f_r = self.facts[ind]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_retract_fact(self):\n fact = self.env.assert_string('(implied-fact)')\n\n self.assertTrue(fact in list(self.env.facts()))\n\n fact.retract()\n\n self.assertFalse(fact in list(self.env.facts()))",
"def kb_retract(self, fact_or_rule):\n printv(\"Retracting {!r}\", 0, ver... | [
"0.72810733",
"0.68295395",
"0.6592928",
"0.5983057",
"0.5843659",
"0.5822878",
"0.56172395",
"0.5609192",
"0.5586348",
"0.55481756",
"0.5539644",
"0.55248684",
"0.55074006",
"0.5498454",
"0.54947954",
"0.5473625",
"0.54666054",
"0.5443795",
"0.5413491",
"0.5398232",
"0.53903... | 0.66837656 | 2 |
Forwardchaining to infer new facts and rules | def fc_infer(self, fact, rule, kb):
printv('Attempting to infer from {!r} and {!r} => {!r}', 1, verbose,
[fact.statement, rule.lhs, rule.rhs])
####################################################
# Student code goes here
#
binding = match(fact.statement, rule.lhs[0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fc_infer(self, fact, rule, kb):\n printv('Attempting to infer from {!r} and {!r} => {!r}', 1, verbose,\n [fact.statement, rule.lhs, rule.rhs])\n ####################################################\n # //--\n bindings = match(rule.lhs[0],fact.statement)\n if bindin... | [
"0.70777905",
"0.69960123",
"0.61015964",
"0.55858845",
"0.55777586",
"0.55288315",
"0.54299307",
"0.5380897",
"0.5336765",
"0.52970016",
"0.52801335",
"0.518475",
"0.5183168",
"0.5181316",
"0.51246744",
"0.509721",
"0.5092668",
"0.50754994",
"0.50486445",
"0.5037382",
"0.503... | 0.6988643 | 2 |
Main function for running the application. | def test_lk():
# get current directory to work relative to current file path
curdir = os.path.dirname(__file__)
# Load configuration for system
yaml_file = os.path.join(curdir, 'config.yaml')
with open(yaml_file, "r") as f:
config = yaml.load(f)
# extract list of videos from data dir
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(args=None):\n app()\n return 0",
"def main():\n print(\"def main\")\n return APP.run()",
"def main():\n return",
"def main():\n app = App()\n app.run()",
"def main():\n CLI_APP.run()",
"def main(self) -> None:\n pass",
"def main():\n print(\"Call your main applica... | [
"0.8267055",
"0.82121",
"0.81232756",
"0.8114297",
"0.81044734",
"0.8067274",
"0.80287755",
"0.80287755",
"0.80287755",
"0.80164164",
"0.78847355",
"0.78267777",
"0.78267777",
"0.78267777",
"0.78267777",
"0.78124523",
"0.78004485",
"0.77828294",
"0.77566296",
"0.77566296",
"0... | 0.0 | -1 |
parse command line input generate options including input proguardgenerated mappings and predict mappings | def parse_args():
parser = argparse.ArgumentParser(description="evaluate the recovered derg by comparing with ground truth mapping file")
parser.add_argument("-mapping", action="store", dest="mapping_file",
required=True, help="path to proguard-generated mapping.txt")
parser.add_argu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_args():\n\tparser = argparse.ArgumentParser(description=\"comparing proguard-generated and predict mappings\")\n\tparser.add_argument(\"--proguard\", action=\"store\", dest=\"proguard_mappings_dir\",\n\t\t\t\t\t\trequired=True, help=\"directory of proguard-generated mappings file\")\n\tparser.add_argumen... | [
"0.758029",
"0.6911417",
"0.66426575",
"0.6602202",
"0.6586641",
"0.6517531",
"0.64053476",
"0.6373626",
"0.6314406",
"0.631191",
"0.6287974",
"0.6280361",
"0.6261687",
"0.62313056",
"0.62139565",
"0.6213808",
"0.6197871",
"0.6196983",
"0.61876106",
"0.6174314",
"0.616388",
... | 0.66534996 | 2 |
Convert a hex color to rgb integer tuple. | def hex_to_rgb(color):
if color.startswith('#'):
color = color[1:]
if len(color) == 3:
color = ''.join([c * 2 for c in color])
if len(color) != 6:
return False
try:
r = int(color[:2], 16)
g = int(color[2:4], 16)
b = int(color[4:], 16)
except ValueError... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hex_to_rgb(hex):\n hex = hex.lstrip('#')\n hlen = len(hex)\n return tuple(int(hex[i:i + hlen // 3], 16) for i in range(0, hlen, hlen // 3))",
"def hex_to_rgb(self,value):\n value = value.lstrip('#')\n lv = len(value)\n return tuple(int(value[i:i + lv // 3], 16) for i in range(0,... | [
"0.8451613",
"0.839427",
"0.83495486",
"0.8305007",
"0.82783866",
"0.8268142",
"0.8268142",
"0.8268142",
"0.8268142",
"0.82359517",
"0.82191676",
"0.8202206",
"0.8152297",
"0.79935545",
"0.7940223",
"0.78840506",
"0.7768129",
"0.77437425",
"0.7743241",
"0.7723033",
"0.7719117... | 0.7372798 | 31 |
Check whether a color is 'dark'. Currently, this is simply whether the luminance is <50% | def dark_color(color):
rgb = hex_to_rgb(color)
if rgb:
return rgb_to_hls(*rgb)[1] < 128
else: # default to False
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_dark(self):\n\n return self.red() < 125 and self.green() < 125 and self.blue() < 125",
"def dark(r, d):\n return d * 1.0 / (r + d) + d * r * 1.0 / ((r + d) ** 2)",
"def is_monochromatic(self):\n return equal(s.color for s in self.iter_states())",
"def ensureBrightOrDark( nColor, bBrig... | [
"0.8725131",
"0.65368",
"0.65338826",
"0.6522034",
"0.6357333",
"0.63260835",
"0.62616885",
"0.62494576",
"0.62354577",
"0.6234573",
"0.6193287",
"0.6178857",
"0.6167206",
"0.6154868",
"0.6118449",
"0.6047277",
"0.6014609",
"0.59861344",
"0.5977451",
"0.59697956",
"0.5940999"... | 0.81742746 | 1 |
Guess whether the background of the style with name 'stylename' counts as 'dark'. | def dark_style(stylename):
return dark_color(get_style_by_name(stylename).background_color) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_color(style):\n for kw in list(cc.keys()):\n m = re.search(kw, style)\n if m:\n return m.group()\n\n # Return 'b' if nothing has found\n return 'b'",
"def is_dark(self):\n\n return self.red() < 125 and self.green() < 125 and self.blue() < 125",
"def check_them... | [
"0.66091275",
"0.63446206",
"0.6265952",
"0.561835",
"0.5487273",
"0.5460873",
"0.54280055",
"0.5422753",
"0.5419636",
"0.53896165",
"0.5383962",
"0.5319423",
"0.5317914",
"0.5317887",
"0.53108865",
"0.52508605",
"0.5241777",
"0.5228757",
"0.5217556",
"0.52019304",
"0.5188046... | 0.69731295 | 0 |
Construct the keys to be used building the base stylesheet from a templatee. | def get_colors(stylename):
style = get_style_by_name(stylename)
fgcolor = style.style_for_token(Token.Text)['color'] or ''
if len(fgcolor) in (3, 6):
# could be 'abcdef' or 'ace' hex, which needs '#' prefix
try:
int(fgcolor, 16)
except TypeError:
pass
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_stylesheet():\n\n #ss_dict\n ss_dict = {'header_image' : HEADER_IMAGE,\n 'icon_true' : ICON_TRUE,\n 'icon_false' : ICON_FALSE,\n 'futura_lt_light' : FUTURA_LT_LIGHT,\n 'bright_orange' : BRIGHT_ORANGE.name(),\n 'bright_orange_t... | [
"0.60495263",
"0.5874462",
"0.5874462",
"0.5804995",
"0.5754522",
"0.5742323",
"0.57396144",
"0.55724186",
"0.5565366",
"0.54510945",
"0.5429787",
"0.5330616",
"0.52988195",
"0.5295383",
"0.5225139",
"0.5201271",
"0.5179384",
"0.5159989",
"0.5142463",
"0.5080673",
"0.5075791"... | 0.0 | -1 |
Use one of the base templates, and set bg/fg/select colors. | def sheet_from_template(name, colors='lightbg'):
colors = colors.lower()
if colors == 'lightbg':
return default_light_style_template % get_colors(name)
elif colors == 'linux':
return default_dark_style_template % get_colors(name)
elif colors == 'nocolor':
return default_bw_style_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, red=Black.red, green=Black.green, blue=Black.blue):\n self.color = Color(red, green, blue)\n\n self.template = '\\ttextcolor = {textcolor};\\n'",
"def _style_colours(self):\n\n pass",
"def setMyBackground(self):\n base.setBackgroundColor(globals.colors['guiblue4']... | [
"0.63418514",
"0.6126202",
"0.6101432",
"0.60870427",
"0.6030478",
"0.59174025",
"0.5908568",
"0.58894444",
"0.5875755",
"0.58252996",
"0.5767308",
"0.57080126",
"0.5699954",
"0.566833",
"0.56431055",
"0.5625276",
"0.5576492",
"0.5572506",
"0.55247325",
"0.55214554",
"0.55201... | 0.0 | -1 |
r""" Computes the gradient of conv2d with respect to the input of the convolution. This is same as the 2D transposed convolution operator under the hood but requires the shape of the gradient w.r.t. input to be specified explicitly. | def conv2d_input(input_size, weight, grad_output, stride=1, padding=0, dilation=1, groups=1):
stride = _pair(stride)
padding = _pair(padding)
dilation = _pair(dilation)
kernel_size = (weight.shape[2], weight.shape[3])
if input_size is None:
raise ValueError("grad.conv2d_input requires speci... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient(self, node, output_grad):\r\n return [conv2d_grad_op1(node.inputs[0], node.inputs[1], node.const_attr , output_grad),conv2d_grad_op2(node.inputs[0], node.inputs[1], node.const_attr , output_grad)]",
"def _Conv2DGrad(op, grad):\n strides = op.get_attr('strides')\n padding = op.ge... | [
"0.7136372",
"0.7087412",
"0.6661306",
"0.6652858",
"0.65240824",
"0.6440572",
"0.6431438",
"0.64151895",
"0.63838226",
"0.638127",
"0.63581175",
"0.6345818",
"0.6308881",
"0.62837183",
"0.62459445",
"0.6236354",
"0.62340426",
"0.6232537",
"0.62316734",
"0.6220648",
"0.621702... | 0.63617384 | 10 |
r""" Computes the gradient of conv2d with respect to the weight of the convolution. | def conv2d_weight(input, weight_size, grad_output, stride=1, padding=0, dilation=1, groups=1):
stride = _pair(stride)
padding = _pair(padding)
dilation = _pair(dilation)
in_channels = input.shape[1]
out_channels = grad_output.shape[1]
min_batch = input.shape[0]
grad_output = grad_output.con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_gradient (w, x, y):\n (n,d) = x.shape\n g = np.zeros(d)\n for i in range(0,d):\n g[i] = (w*x-y)*np.transpose(x[i])\n g += 0.5*w\n return g",
"def gradient(self, node, output_grad):\r\n return [conv2d_grad_op1(node.inputs[0], node.inputs[1], node.co... | [
"0.7060526",
"0.69919515",
"0.68430454",
"0.66755736",
"0.66457593",
"0.66347766",
"0.6634614",
"0.6628003",
"0.6615836",
"0.6599485",
"0.65958774",
"0.6593012",
"0.6530576",
"0.6513897",
"0.6493217",
"0.6491872",
"0.6491026",
"0.64871246",
"0.6460029",
"0.6453161",
"0.645178... | 0.61689085 | 50 |
4th Order RungeKutta method (RK4) RK4 that solves a system of three coupled differential equations. Additional parameters not explained below, are described in the main.py program located in the same folder as this file. | def RK4(a_in, b, c, x0, y0, z0, N, T, n, fx, fy, fz=None, Basic=False, Vital=False, Season=False, Vaccine=False, CombinedModel=False):
# Setting up arrays
x = np.zeros(n)
y = np.zeros(n)
z = np.zeros(n)
t = np.zeros(n)
# Size of time step
dt = T/n
# Initialize
x[0] = x0
y[0] =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rk4(x,t,tau,derivsRK,param): #couldn't get it to import right so I just copy pasted.\r\n \r\n half_tau = 0.5*tau\r\n F1 = derivsRK(x,t,param) \r\n t_half = t + half_tau\r\n xtemp = x + half_tau*F1\r\n F2 = derivsRK(xtemp,t_half,param) \r\n xtemp = x + half_tau*F2\r\n F3 = derivsRK(xte... | [
"0.7954573",
"0.77571136",
"0.74954444",
"0.71658003",
"0.70909965",
"0.7012071",
"0.69917583",
"0.6986058",
"0.6910422",
"0.68250304",
"0.6824724",
"0.6814575",
"0.68134725",
"0.6803948",
"0.6789339",
"0.6765618",
"0.67407966",
"0.6738729",
"0.6710684",
"0.66979975",
"0.6687... | 0.6626081 | 22 |
Right hand side of S' = dS/dt For basic SIRS, vital dynamics, seasonal variation, vaccine and a combined model | def fS(a, b, c, N, S, I, R=None, vital=False, vaccine=False, combined=False):
if vital:
temp = c*R - a*S*I/N - d*S + e*N
elif vaccine:
R = N - S - I
temp = c*R - a*S*I/N - f*S
elif combined:
temp = c*R - a*S*I/N - d*S + e*N - f*S
else:
temp = c*(N-S-I) - a*S*I/N
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dydt(t,S):\n Scl = S[0]\n Swb = S[1]\n \n Seff_cl = (Scl - Sclmin)/(Sclmax - Sclmin)\n Lcl = acl * Seff_cl**bcl\n \n Seff_wb = (Swb - Swbmin)/(Swbmax - Swbmin)\n Lwb = awb * Seff_wb**bwb\n \n E = pE * Cf *fred\n Beta = Beta0 * Seff_cl\n \n # Equations\n dScldt = Jrf - Lcl - E\n ... | [
"0.6709277",
"0.65212226",
"0.6506355",
"0.6376106",
"0.6086967",
"0.6046832",
"0.60436714",
"0.5999482",
"0.59557784",
"0.5927742",
"0.5925995",
"0.59152555",
"0.5876051",
"0.58732706",
"0.5844832",
"0.5819526",
"0.5817883",
"0.5792154",
"0.57908195",
"0.5771786",
"0.5769986... | 0.5705355 | 24 |
Right hand side of I' = dI/dt For basic SIRS, with vital dynamics, seasonal variation, vaccine and a combined model | def fI(a, b, c, N, S, I, R=None, vital=False, vaccine=False, combined=False):
if vital:
temp = a*S*I/N - b*I - d*I - dI*I
elif vaccine:
temp = a*S*I/N - b*I
elif combined:
temp = a*S*I/N - b*I - d*I - dI*I
else:
temp = a*S*I/N - b*I
return temp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dSIR(s, i, r, beta, gamma, dt):\n \n N = s + i + r\n return np.array([-beta / N * i * s,\n beta / N * i * s - gamma * i,\n gamma * i]) * dt",
"def dSIRD(s, i, r, d, beta, gamma, mu, dt):\n \n N = s + i + r + d\n return np.array([-beta / N * i * s,\n ... | [
"0.65454096",
"0.6504648",
"0.63993156",
"0.62488604",
"0.6208171",
"0.6152282",
"0.6077421",
"0.606764",
"0.6063668",
"0.6053156",
"0.6007391",
"0.59563476",
"0.5868086",
"0.5859338",
"0.5774364",
"0.57708526",
"0.5752",
"0.5680514",
"0.5661055",
"0.56446713",
"0.56088495",
... | 0.54601496 | 32 |
Right hand side of R' = dR/dt For basic SIRS, with vital dynamics, seasonal variation, vaccine and a combined model | def fR(a, b, c, N, S, I, R, vital=False, vaccine=False, combined=False):
if vital:
temp = b*I - c*R - d*R
elif vaccine:
R = N - S - I
temp = b*I - c*R + f*S
elif combined:
temp = b*I - c*R - d*R + f*S
else:
temp = 0
return temp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dSIR(s, i, r, beta, gamma, dt):\n \n N = s + i + r\n return np.array([-beta / N * i * s,\n beta / N * i * s - gamma * i,\n gamma * i]) * dt",
"def dSIRD(s, i, r, d, beta, gamma, mu, dt):\n \n N = s + i + r + d\n return np.array([-beta / N * i * s,\n ... | [
"0.6417594",
"0.62465185",
"0.61990243",
"0.6146874",
"0.6019759",
"0.59690404",
"0.5936613",
"0.59302646",
"0.58936304",
"0.58754086",
"0.5860053",
"0.5856836",
"0.5746976",
"0.57035094",
"0.5688082",
"0.56799275",
"0.56329614",
"0.5620549",
"0.5616551",
"0.5611345",
"0.5608... | 0.53041786 | 44 |
Disease modelling using MonteCarlo. This function uses randomness and transition probabilities as a basis for the disease modelling. Additional parameters not explained below, are described in the main.py program located in the same folder as this file. | def MC(a_in, b, c, S_0, I_0, R_0, N, T, vitality=False, seasonal=False, vaccine=False):
if seasonal:
a0 = a_in #average transmission rate
A = 4 #max.deviation from a0
omega = 0.5 #frequency of oscillation
a = A*np.cos(omega*0) + a0
else:
a =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_scenario_1(seed=1996, permanent_save=True, sigma_process=0.01, sigma_meas_radar=3, sigma_meas_ais=1):\n # specify seed to be able repeat example\n start_time = datetime.now()\n\n np.random.seed(seed)\n\n # combine two 1-D CV models to create a 2-D CV model\n transition_model = CombinedL... | [
"0.63426965",
"0.61112314",
"0.6076911",
"0.6061208",
"0.60226256",
"0.5981131",
"0.59642947",
"0.5918322",
"0.5863828",
"0.5817048",
"0.5789747",
"0.5731177",
"0.57195646",
"0.5717003",
"0.56996053",
"0.5694678",
"0.56899124",
"0.56714576",
"0.5669338",
"0.5646432",
"0.56285... | 0.0 | -1 |
Constructor for smach Concurrent Split. | def __init__(self,
outcomes,
default_outcome,
input_keys = [],
output_keys = [],
outcome_map = {},
outcome_cb = None,
child_termination_cb = None
):
smach.container.Container.__init__(self, outcomes, input_keys, outp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_split(self) -> NoReturn:\n raise NotImplementedError",
"def __init__(self, comm, data, num_epochs, train_list, val_list, num_masters=1,\n synchronous=False, callbacks=[]):\n self.data = data\n self.num_masters = num_masters\n self.num_workers = comm.Get_size() - ... | [
"0.6501006",
"0.60381305",
"0.59367543",
"0.59327763",
"0.5870752",
"0.5870021",
"0.5826461",
"0.5807034",
"0.57936984",
"0.5790517",
"0.5718749",
"0.56733483",
"0.5666154",
"0.56660837",
"0.5630289",
"0.5607317",
"0.55971277",
"0.55574745",
"0.55560327",
"0.55555826",
"0.552... | 0.0 | -1 |
Add state to the opened concurrence. This state will need to terminate before the concurrence terminates. | def add(label, state, remapping={}):
# Get currently opened container
self = Concurrence._currently_opened_container()
# Store state
self._states[label] = state
self._remappings[label] = remapping
return state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_io_state(self, state):\n if self._state != state:\n state = self._state = self._state | state\n self._update_handler(self._state)",
"def add_state(self, state):\n self.states.add(state)",
"def add_state(self, state):\n self._validate_state(state)\n self._s... | [
"0.66800797",
"0.6445865",
"0.64207387",
"0.6252283",
"0.6251686",
"0.62296855",
"0.61850387",
"0.61375093",
"0.60501254",
"0.5971698",
"0.5954651",
"0.5868956",
"0.5826321",
"0.57091546",
"0.57091546",
"0.56562334",
"0.5651364",
"0.5650971",
"0.56308216",
"0.55859417",
"0.55... | 0.64219916 | 2 |
Overridden execute method. This starts all the threads. | def execute(self, parent_ud = None):
# Clear the ready event
self._ready_event.clear()
# Reset child outcomes
self._child_outcomes = {}
# Copy input keys
self._copy_input_keys(parent_ud, self.userdata)
# Spew some info
smach.loginfo("Concurrence... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_workers(self):\n\n for thread in self.threads:\n thread.start()",
"def start_threads(self):\r\n assert len(self.all_threads) > 0\r\n for thread in self.all_threads:\r\n thread.start()",
"def create_and_start_threads(self):\r\n self.create_threads()\r\... | [
"0.72440064",
"0.71170753",
"0.6793708",
"0.67579764",
"0.6752653",
"0.6662899",
"0.65031946",
"0.64659274",
"0.6461829",
"0.64602405",
"0.6420833",
"0.63945025",
"0.6368528",
"0.6360315",
"0.63563305",
"0.6355684",
"0.63202614",
"0.62761915",
"0.62727165",
"0.62565506",
"0.6... | 0.0 | -1 |
Preempt all contained states. | def request_preempt(self):
# Set preempt flag
smach.State.request_preempt(self)
# Notify concurrence that it should preempt running states and terminate
with self._done_cond:
self._done_cond.notify_all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preempt(self):\n rospy.logwarn(\"Preempting scan...\")\n self.preempted = True",
"def skip_all_animations(self):\n for child in self.children:\n child.skip_all_animations()\n \n # remove unskippable animations from queue\n unskippables = [anim for anim... | [
"0.554885",
"0.5414512",
"0.5326902",
"0.529442",
"0.5274952",
"0.5222493",
"0.5195873",
"0.51523536",
"0.51299024",
"0.50996476",
"0.5081874",
"0.5050064",
"0.50393015",
"0.50298834",
"0.5028418",
"0.50032896",
"0.49937183",
"0.49687582",
"0.49533314",
"0.49426508",
"0.49423... | 0.7223714 | 0 |
Runs the states in parallel threads. | def _state_runner(self,label):
# Wait until all threads are ready to start before beginnging
self._ready_event.wait()
self.call_transition_cbs()
# Execute child state
try:
self._child_outcomes[label] = self._states[label].execute(smach.Remapper(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_in_parallel(self):\n\t\tfor p in self.parallel_threads:\n\t\t\tp.start()\n\t\tfor p in self.parallel_threads:\n\t\t\tp.join()",
"def test_setting_state_parallel(self):\n no_replicates = 25\n\n replicate(experiment, no_replicates, parallel=True, no_processes=2)\n for i in range(no_rep... | [
"0.669734",
"0.64710146",
"0.62994856",
"0.61933833",
"0.60969037",
"0.6092645",
"0.6050855",
"0.6029131",
"0.6006256",
"0.5982374",
"0.5978855",
"0.5941273",
"0.59398925",
"0.59389126",
"0.58783174",
"0.5869711",
"0.58460647",
"0.578596",
"0.5767861",
"0.57622504",
"0.571896... | 0.5938656 | 14 |
Need a global enumerated list, not a local one, or there will be errors if one .gnt file skips a character | def saveImages(saveImagePath,dataForSaving,enumeratedList):
for i in range(len(dataForSaving[0])):
singleChar = dataForSaving[0][i]
singleImage = dataForSaving[1][i]
if singleChar not in enumeratedList:
enumeratedList.append(singleChar)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eval_genuine(path):\n out = []\n with open(path, 'r') as fp:\n for line in fp:\n fields = line.rstrip().split()\n ii, tt = fields[:2]\n if tt == 'genuine':\n out.append(ii[2:-4]) # remove 'D_' and '.wav'\n\n return... | [
"0.51875985",
"0.51774746",
"0.5140021",
"0.51013625",
"0.50543755",
"0.50452536",
"0.49202475",
"0.49026576",
"0.48826155",
"0.4863277",
"0.484987",
"0.4848835",
"0.48407993",
"0.4830614",
"0.4829038",
"0.48158124",
"0.48138157",
"0.48046628",
"0.478652",
"0.47688955",
"0.47... | 0.0 | -1 |
Processes training and test files into one tfrecord rather than saving images/labels separately | def processGNTasImageGeneric(saveImagePath,gntPath,imageSize,trainGNT,testGNT):
totalFiles = 0
for subdir, dirs, filenames in os.walk(gntPath):
totalFiles += len(filenames)
print("{} .gnt files".format(totalFiles))
#create train and test folders
if not os.pat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_all_image_files_into_tf_records(image_dir, tf_records_dir):\n files = os.listdir(image_dir)\n\n training_files = []\n test_files = []\n for file in files:\n if os.path.isdir(image_dir + file):\n image_files = os.listdir(image_dir + file)\n length = len(image_files)... | [
"0.75491244",
"0.74270195",
"0.7271221",
"0.70785785",
"0.70030403",
"0.699899",
"0.69399333",
"0.69106877",
"0.6883742",
"0.6876416",
"0.68456495",
"0.6837926",
"0.68090194",
"0.6796269",
"0.679149",
"0.678764",
"0.67850995",
"0.67207783",
"0.6716689",
"0.67131555",
"0.67065... | 0.0 | -1 |
We are going to generate 10 unique characters in the addrs and labels | def generateUniqueAddrs(saveImagePath,numUnique,trainType,addrs_labels):
print("Saving only {} unique characters for {}".format(numUnique,trainType))
train_addrs = addrs_labels[0]
train_labels = addrs_labels[1]
test_addrs = addrs_labels[2]
test_labels = addrs_labels[3]
ge... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_id() -> str:\n return \"\".join(sample(\"abcdefghjkmopqrstuvqxyz\", 16))",
"def generate_uuids():\n uuid_start = str(uuid())\n while uuid_start.startswith(\"zzzzzzzz\"):\n uuid_start = str(uuid())\n uuid_end = list(deepcopy(uuid_start))\n \n char_pool = list(string.digits) ... | [
"0.640046",
"0.6369727",
"0.63013107",
"0.6263165",
"0.62521905",
"0.6217594",
"0.62151855",
"0.6057115",
"0.6023755",
"0.6016253",
"0.59843117",
"0.59843117",
"0.5947065",
"0.5907196",
"0.5886632",
"0.5849489",
"0.58435",
"0.58254504",
"0.5823662",
"0.58192736",
"0.5805219",... | 0.7429078 | 0 |
Processes training and test files into one tfrecord rather than saving images/labels separately | def generateGenericTFRecord(addrs,labels,numOutputs):
print("Generating TFRecord containing training and test files for {} outputs...".format(numOutputs))
filename = 'generic'+str(numOutputs)+'.tfrecords'
writer = tf.python_io.TFRecordWriter(filename)
labels = [i-171 for i in labels] #to... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_all_image_files_into_tf_records(image_dir, tf_records_dir):\n files = os.listdir(image_dir)\n\n training_files = []\n test_files = []\n for file in files:\n if os.path.isdir(image_dir + file):\n image_files = os.listdir(image_dir + file)\n length = len(image_files)... | [
"0.75485015",
"0.74270594",
"0.72712696",
"0.7077852",
"0.70025826",
"0.6998779",
"0.6940493",
"0.6910123",
"0.6883235",
"0.68759894",
"0.6845586",
"0.6837063",
"0.68087155",
"0.6795098",
"0.67914337",
"0.6787535",
"0.67847365",
"0.6720754",
"0.67159617",
"0.6711898",
"0.6706... | 0.6654385 | 23 |
Render a template with a RequestContext. | def render(request, template, data=None, mimetype=None, status=200):
t = get_template(template)
c = RequestContext(request, data)
return HttpResponse(t.render(c), mimetype=mimetype, status=status) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render(self, _template, context=None):\n variables = {}\n if context:\n variables.update(context)\n rv = self.jinja2.render_template(_template, **variables)\n self.response.write(rv)",
"def render(self, _template, **context):\n context['_request'] = self.request\... | [
"0.78249687",
"0.77378184",
"0.7640356",
"0.752489",
"0.7478129",
"0.74194103",
"0.7324433",
"0.718892",
"0.7165826",
"0.7165826",
"0.7163388",
"0.714797",
"0.714797",
"0.7139211",
"0.7137041",
"0.71318865",
"0.7094226",
"0.7079073",
"0.7059118",
"0.7053729",
"0.702802",
"0... | 0.75907755 | 3 |
Check if have an modal in the page and close it | def check_modal(client):
modal_close_btn_xpath = "/html/body/div[9]/div[3]/div/button[1]"
try:
modal_close_btn = wait(client, 20).until(
EC.visibility_of_element_located((By.XPATH, modal_close_btn_xpath))
).click()
except TimeoutException:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait_until_modal_is_closed(self):\n self.selenium.wait_until_page_does_not_contain_element(\n lex_locators[\"modal\"][\"is_open\"], timeout=15\n )",
"def close_modal(self):\n locator = lex_locators[\"modal\"][\"close\"]\n self._jsclick(locator)",
"def isModal(self) ->... | [
"0.7223902",
"0.6937706",
"0.6832686",
"0.6832686",
"0.6832686",
"0.6832686",
"0.6668967",
"0.6477973",
"0.6467144",
"0.64522135",
"0.6235597",
"0.6161681",
"0.609987",
"0.6045032",
"0.60414016",
"0.6033631",
"0.5973035",
"0.5968023",
"0.5936488",
"0.5881599",
"0.5880967",
... | 0.6974228 | 1 |
Takes in a list of column headers and the Data object and returns a list of 2element lists with the minimum and maximum values for each column. The function is required to work only on numeric data types. | def range_(headers, data):
column_matrix=data.get_data(headers).getT() # get columns as rows, as this makes analysis much easier by just perfoming operations on column list directly
if column_matrix==[]:
print "wrong headers, not present in data Object"
return []
column_max=column_matrix.max(1)
column_min=colum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_min_max(data):\n v = [i[1] for i in data]\n extremes = [min(v), max(v)]\n logging.info('Calculated extremes: %s', extremes)\n return extremes",
"def get_features_min_max(self):\n min_max_list = []\n\n # Get each feature's min and max values.\n for feature_name in self.fe... | [
"0.7179984",
"0.67622894",
"0.66347414",
"0.65967995",
"0.6559086",
"0.6524025",
"0.6347338",
"0.6229328",
"0.6198685",
"0.6165774",
"0.6158391",
"0.61267865",
"0.6091353",
"0.60664314",
"0.6055036",
"0.6013343",
"0.60074276",
"0.5973478",
"0.5945628",
"0.59140044",
"0.585765... | 0.67075384 | 2 |
Takes in a list of column headers and the Data object and returns a list of the mean values for each column. Use the builtin numpy functions to execute this calculation. | def mean(headers, data):
column_matrix=data.get_data(headers)
mean_values=column_matrix.mean(0)
return mean_values | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_list(data):\n return sum(data) / len(data)",
"def calculate_mean(data_dir):\n data = ([each for each in os.listdir(data_dir)\n if each.endswith('.h5')])\n all_data = []\n for num_data in data:\n processed_data = os.path.join(data_dir, num_data)\n file = h5py.File(pr... | [
"0.688118",
"0.6788073",
"0.67306453",
"0.6660681",
"0.65742046",
"0.6569169",
"0.6488681",
"0.64012986",
"0.6394433",
"0.6307643",
"0.6307385",
"0.6297519",
"0.6297519",
"0.6287866",
"0.6264603",
"0.6255944",
"0.62483",
"0.6204587",
"0.6190885",
"0.61622494",
"0.6139135",
... | 0.81816053 | 0 |
stdev Takes in a list of column headers and the Data object and returns a list of the standard deviation for each specified column. Use the builtin numpy functions to execute this calculation. | def stdev(headers, data):
column_matrix=data.get_data(headers)
mean_values=column_matrix.std(0)
std_values=mean_values.tolist()
return std_values | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_std_dev(self, data):\n mean = 0\n data_arr = []\n for i in data:\n data_arr.append(i[1])\n return statistics.stdev(data_arr)",
"def column_stdev(column_values, mean):\n\n try:\n stdev = math.sqrt(\n sum([(mean-x)**2 for x in column_values]) / le... | [
"0.762345",
"0.76011705",
"0.7323709",
"0.71934015",
"0.715191",
"0.7065229",
"0.70174754",
"0.69014233",
"0.6891203",
"0.67621124",
"0.67020977",
"0.6664076",
"0.6664076",
"0.6625717",
"0.65968806",
"0.65932107",
"0.6561748",
"0.65059817",
"0.6488277",
"0.6485756",
"0.648408... | 0.855148 | 0 |
Takes in a list of column headers and the Data object and returns a matrix with each column normalized so its minimum value is mapped to zero and its maximum value is mapped to 1. | def normalize_columns_separately(headers, data):
column_matrix=data.get_data(headers)
column_max=column_matrix.max(1)
column_min=column_matrix.min(1)
range=column_max-column_min
nomalized=(column_matrix-column_min)/range
return nomalized | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_columns_together(headers, data):\n\tcolumn_matrix=data.get_data(headers)\n\tmax=column_matrix.max()\n\tprint \"The maximum:\t \", max\n\tmin=column_matrix.min()\n\tprint \"The minimum:\t \", min\n\trange=max-min\n\tprint \"range: \", range\n\tcolumn_matrix=column_matrix-min\n\tnormalized=column_matri... | [
"0.7496443",
"0.66081625",
"0.65859145",
"0.6499091",
"0.6407396",
"0.6192507",
"0.6134639",
"0.60927606",
"0.6090253",
"0.60883844",
"0.6063456",
"0.60361797",
"0.59998703",
"0.59998703",
"0.59897834",
"0.5978918",
"0.5962571",
"0.5955856",
"0.5939429",
"0.59259486",
"0.5905... | 0.708409 | 1 |
Takes in a list of column headers and the Data object and returns a matrix with each entry normalized so that the minimum value (of all the data in this set of columns) is mapped to zero and its maximum value is mapped to 1. | def normalize_columns_together(headers, data):
column_matrix=data.get_data(headers)
max=column_matrix.max()
print "The maximum: ", max
min=column_matrix.min()
print "The minimum: ", min
range=max-min
print "range: ", range
column_matrix=column_matrix-min
normalized=column_matrix/range
return normalized | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_columns_separately(headers, data):\n\tcolumn_matrix=data.get_data(headers)\n\tcolumn_max=column_matrix.max(1)\n\tcolumn_min=column_matrix.min(1)\n\trange=column_max-column_min\n\tnomalized=(column_matrix-column_min)/range\n\treturn nomalized",
"def normalize(data):\n # normalize data and return\... | [
"0.6924816",
"0.6368028",
"0.634722",
"0.6282522",
"0.62384415",
"0.6170771",
"0.5904337",
"0.5867747",
"0.58657235",
"0.585182",
"0.5851378",
"0.58379954",
"0.5837087",
"0.5817979",
"0.57913613",
"0.5751155",
"0.5751155",
"0.5748093",
"0.57406265",
"0.5719488",
"0.5708877",
... | 0.73747426 | 0 |
Return the numeric matrices with sorted columns | def sort(headers, data): # extension
column_matrix=data.get_data(headers) # get raw matrix data for numeric values
print "\n before sorting \n "
print column_matrix
column_matrix=column_matrix.tolist()
column_array=np.asarray(column_matrix)
column_array.sort(axis=0)
print "\n \n done sorting here is your m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_for_sorting():\n return RaggedArray([[1, 0], [2, 0], [0, 0]])",
"def _sort_rows(matrix, num_rows):\n tmatrix = array_ops.transpose(matrix, [1, 0])\n sorted_tmatrix = nn_ops.top_k(tmatrix, num_rows)[0]\n return array_ops.transpose(sorted_tmatrix, [1, 0])",
"def Msort(index, arr1, arr2, matrix):\n... | [
"0.6472477",
"0.6157688",
"0.60989267",
"0.6080551",
"0.5776652",
"0.5737888",
"0.56588423",
"0.56309026",
"0.556288",
"0.5534623",
"0.551707",
"0.5514763",
"0.55020404",
"0.5490696",
"0.5472799",
"0.54618865",
"0.5438563",
"0.5436786",
"0.53938407",
"0.53862166",
"0.53718483... | 0.71695834 | 0 |
takes in data object and then creates a linear regression using the dependant variable | def linear_regression(d, ind, dep):
y=d.get_data([dep])
print "y :",y
A=d.get_data(ind)
print "A :",A
ones = np.asmatrix(np.ones( (A.shape[0]) )).transpose()
A=np.concatenate((A, ones), axis=1)
print "concatenated A :",A
AAinv=np.linalg.inv( np.dot(A.transpose(), A))
print "AAinv: \n",AAinv
"""
print "A... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nnRegression(data):",
"def linear_regression_sklearn(data):\n# Split the data into training/testing sets\n dataset = np.array(data)\n\n X_train = dataset[:,0].reshape(-1,1)\n y_train = dataset[:,1]\n\n# Create linear regression object\n regr = linear_model.LinearRegression()\n\n# Train the model ... | [
"0.75647044",
"0.74391013",
"0.7289286",
"0.7030522",
"0.6867436",
"0.6795315",
"0.66433483",
"0.6637564",
"0.6582622",
"0.6578247",
"0.65309256",
"0.65170056",
"0.6510575",
"0.6499299",
"0.64719",
"0.64666194",
"0.6466013",
"0.64587486",
"0.6433807",
"0.6419431",
"0.63958323... | 0.63677645 | 21 |
Calculate GAN loss for the discriminator | def backward_D(self):
self.loss_D_frame, self.loss_D_frame_real, self.loss_D_frame_fake = self.get_GAN_loss_D_sequential(
discriminator=self.discriminator,
real_images=self.real_target,
fake_images=self.fake_target,
conditioned_on=self.real_source,
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _define_discriminator_loss(self):\n real_d_loss = tf.reduce_mean(self._real_discriminator_out)\n real_d_loss = tf.negative(real_d_loss, name='real_discriminator_loss')\n gen_d_loss = tf.reduce_mean(self._gen_discriminator_out,\n name='gen_discriminator_loss')\n return... | [
"0.77901465",
"0.73512495",
"0.72766215",
"0.7197856",
"0.71317965",
"0.70893556",
"0.6996443",
"0.69658417",
"0.6945136",
"0.6936123",
"0.6872704",
"0.68453836",
"0.6738948",
"0.67176574",
"0.6678768",
"0.6669968",
"0.6669444",
"0.66358835",
"0.6635603",
"0.66341007",
"0.662... | 0.0 | -1 |
register_attr(attr, editor, clazz = None) Registers EDITOR as the editor for atrribute ATTR of class CLAZZ, or for any class if CLAZZ is None. EDITOR can be either a Tk widget subclass of editobj.editor.Editor, or None to hide the attribute. MRO is used in order to allow subclasses to use the editor registered for thei... | def register_attr(attr, editor, clazz = None):
for_attr = _attr_editors.get(attr)
if for_attr: for_attr[clazz] = editor
else: _attr_editors[attr] = { clazz : editor } | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_children_attr(attr, insert = \"insert\", del_ = \"__delitem__\", clazz = None):\n \n if clazz: _children_attrs[clazz] = (attr, insert, del_)\n else: _children_attrs[None].append((attr, insert, del_))",
"def register_on_edit(func, clazz):\n \n _on_edit[clazz] = func",
"def addEditor(self, ... | [
"0.569334",
"0.52287275",
"0.4944205",
"0.4870793",
"0.477365",
"0.46567985",
"0.46526116",
"0.46501258",
"0.4630243",
"0.4627526",
"0.45808572",
"0.45672143",
"0.4548827",
"0.45476916",
"0.45291042",
"0.4518718",
"0.44888854",
"0.4439509",
"0.4431176",
"0.4427259",
"0.442450... | 0.837206 | 0 |
register_children_attr(attr, insert = "insert", del_ = "__delitem__", clazz = None) Registers ATTR as an attribute that can act as the "content" or the "children" of an object of class CLAZZ (or any class if None). If ATTR is None, the object is used as its own list of children (automatically done for list / dict subcl... | def register_children_attr(attr, insert = "insert", del_ = "__delitem__", clazz = None):
if clazz: _children_attrs[clazz] = (attr, insert, del_)
else: _children_attrs[None].append((attr, insert, del_)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_children(self, children: dict) -> None:\n for child in children:\n self.children[child.move] = child",
"def register_attr(attr, editor, clazz = None):\n \n for_attr = _attr_editors.get(attr)\n if for_attr: for_attr[clazz] = editor\n else: _attr_editors[attr] = { clazz : edito... | [
"0.5429349",
"0.54085225",
"0.53786886",
"0.53273",
"0.51638204",
"0.5120558",
"0.5015715",
"0.50146097",
"0.50063944",
"0.49629942",
"0.48599657",
"0.48443073",
"0.48174873",
"0.47865376",
"0.47392642",
"0.47035292",
"0.47018874",
"0.46887925",
"0.46817335",
"0.4680879",
"0.... | 0.8719397 | 0 |
register_method(method, clazz, args_editor) Registers METHOD as a method that must be displayed in EditObj for instance of CLAZZ. METHOD can be either a method name (a string), or a function (in this case, it is not a method, strictly speaking). ARGS_EDITOR are the editors used for entering the argument, e.g. use edito... | def register_method(method, clazz, *args_editor):
methods = _methods.get(clazz)
if methods: methods.append((method, args_editor))
else: _methods[clazz] = [(method, args_editor)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_method(cls: type) -> Callable:\n\n def decorator(func):\n func.enable = lambda: _method_enable(\n cls, [_plugin_funcname(func)], func\n )\n func.disable = lambda: _method_disable(\n cls, [_plugin_funcname(func)], func\n )\n return func\n\n ret... | [
"0.5905217",
"0.58517236",
"0.5786096",
"0.5741496",
"0.57013345",
"0.561656",
"0.5559318",
"0.55209756",
"0.5503904",
"0.54889995",
"0.53730494",
"0.5337263",
"0.5303383",
"0.5225363",
"0.5225363",
"0.52207655",
"0.5208166",
"0.51892644",
"0.5186976",
"0.5176117",
"0.5170982... | 0.78775865 | 0 |
register_available_children(children_codes, clazz) Register the CHILDREN_CODES that are proposed for addition in an instance of CLAZZ. If CHILDREN_CODES is a list of strings (Python code), EditObj will display a dialog box. If CHILDREN_CODES is a single string, no dialog box will be displayed, and this code will automa... | def register_available_children(children_codes, clazz):
if isinstance(children_codes, list):
try: _available_children[clazz].extend(children_codes)
except: _available_children[clazz] = children_codes
else:
_available_children[clazz] = children_codes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_children(self, *args):\r\n self.children.extend(args)\r\n return self",
"def add_children(self, *args):\r\n self._children.extend(args)\r\n return self",
"def addChildren(self, values):\r\n for i, value in enumerate(values):\r\n newScope = copy(self.scope)\... | [
"0.5452896",
"0.53605896",
"0.5334651",
"0.5284387",
"0.52782434",
"0.5211498",
"0.5191764",
"0.5082743",
"0.50570357",
"0.5024224",
"0.49518868",
"0.49307147",
"0.49156395",
"0.4906171",
"0.48993438",
"0.48965266",
"0.4896071",
"0.48945415",
"0.48457983",
"0.4797419",
"0.479... | 0.79036367 | 0 |
register_values(attr, code_expressions) Registers CODE_EXPRESSIONS as a proposed value for ATTR. | def register_values(attr, code_expressions):
code_expressions = map(unicodify, code_expressions)
try: _values[attr].extend(code_expressions)
except KeyError: _values[attr] = list(code_expressions) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_reg_expressions(self, expressions_update: Dict[str, Any]) -> None:\n expressions = self.base_expressions.copy()\n expressions.update(expressions_update)\n self.reg_expressions = expressions",
"def RegisterValues():\n return get_float64_array(lib.Generators_Get_RegisterValues)",... | [
"0.48745957",
"0.4734857",
"0.46250662",
"0.46225697",
"0.4597566",
"0.45449904",
"0.45448384",
"0.4482638",
"0.44240987",
"0.44201872",
"0.4374772",
"0.4365421",
"0.43483615",
"0.43303338",
"0.43257523",
"0.43160722",
"0.42835793",
"0.42812833",
"0.427737",
"0.42618823",
"0.... | 0.85605466 | 0 |
register_on_edit(func, clazz) Register FUNC as an "on_edit" event for CLAZZ. When an instance of CLAZZ is edited, FUNC is called with the instance and the editor Tkinter window as arguments. | def register_on_edit(func, clazz):
_on_edit[clazz] = func | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addEdit( self, cCtrlName, nPositionX, nPositionY, nWidth, nHeight,\n cText=None,\n textListenerProc=None,\n cReadOnly=None,\n cMultiline=None,\n cAutoVScroll=None):\n self.addControl( \"com... | [
"0.5836717",
"0.57678133",
"0.5657995",
"0.5506038",
"0.5439217",
"0.5395581",
"0.53424084",
"0.53140134",
"0.51880944",
"0.51332206",
"0.5114195",
"0.51119095",
"0.509349",
"0.50865626",
"0.5086496",
"0.50285983",
"0.50238705",
"0.5020771",
"0.49626553",
"0.4934645",
"0.4925... | 0.8712736 | 0 |
register_on_children_visible(func, clazz) Register FUNC as an "on_children_visible" event for CLAZZ. When the children of an instance of CLAZZ are shown or hidden, FUNC is called with the instance and the new visibility status (0 or 1) as arguments. | def register_on_children_visible(func, clazz):
_on_children_visible[clazz] = func | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visible(self, show):",
"def register_available_children(children_codes, clazz):\n \n if isinstance(children_codes, list):\n try: _available_children[clazz].extend(children_codes)\n except: _available_children[clazz] = children_codes\n else:\n _available_children[clazz] = children_codes",
"de... | [
"0.5089612",
"0.50880736",
"0.5036541",
"0.5036325",
"0.4887222",
"0.4887222",
"0.4887222",
"0.4887222",
"0.4887222",
"0.4887222",
"0.4887222",
"0.4887222",
"0.4887222",
"0.4887222",
"0.4887222",
"0.48733646",
"0.48165864",
"0.47937766",
"0.47393054",
"0.47151053",
"0.4670040... | 0.8832136 | 0 |
This method uses to check if the food name in our database or not. name It is the name of the food from the users. true if food in databases, false othewise | def findFood(self,name):
name = name.lower()
return dictfood.has_key(name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __contains__(self, user_name):\n tuples = self._execute(\n \"SELECT name FROM users WHERE name == ?\",\n (user_name,)\n )\n return len(tuples) == 1",
"def player_exists_in_db(name: str):\n with open('db.json') as fo:\n data = loads(fo.read())\n return n... | [
"0.65653473",
"0.63060015",
"0.6292949",
"0.62000495",
"0.6126626",
"0.6053125",
"0.6008738",
"0.5959989",
"0.59151655",
"0.5908109",
"0.58882326",
"0.58628136",
"0.58392847",
"0.5811589",
"0.58058965",
"0.5798567",
"0.57955873",
"0.57936364",
"0.5790114",
"0.5773204",
"0.577... | 0.73230463 | 0 |
This method uses to check if the food name in our database or not. string It is the string name of food from the users. total calories | def calculateCal(self,string):
global total
total = 0
string = string.upper()
lis = tokenize.sent_tokenize(string)
for string1 in lis:
food, qual = string1.split()
food = food.lower()
qual = float(qual[:-1])
if (dictfood.has_key(food)):
cal = dictfood[food]
else:
cal = 0
total = tota... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def findFood(self,name):\n\t\tname = name.lower()\n\t\treturn dictfood.has_key(name)",
"def checkFood(self, food):\n pass",
"def FoodCheckIn(sc, event):\n channel = sc.api_call('channels.info', channel=event['channel'])\n food = event['text'][9:]\n if food:\n if 'pizza' in food:\n sc.api_call... | [
"0.6849376",
"0.6569406",
"0.5917411",
"0.5899268",
"0.56720513",
"0.5544741",
"0.5530943",
"0.55145216",
"0.55123574",
"0.5480699",
"0.54642636",
"0.54486895",
"0.5419985",
"0.53458047",
"0.53259957",
"0.5320329",
"0.53049254",
"0.52984124",
"0.52976334",
"0.52566516",
"0.52... | 0.56761986 | 4 |
A subscriber to the ``pyramid.events.BeforeRender`` events. Updates | def add_renderer_globals(event):
request = event.get('request')
if request is None:
request = get_current_request()
globs = {
'url': route_url,
'h': None,
'a_url': request.application_url,
'user': authenticated_userid(request),
'repo': Repo(request.registry.se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_pre_render(self, event, signal):\n t = ppb.get_time() - self.start_time\n self.frames += 1\n print(f\"Frame {self.frames} rendered at {t}\")",
"def addBeforeRender(call, args=(), kwargs={}, nodeClass='Write'):",
"def _before_render_event(self, *args, **kwargs):\n for chart in... | [
"0.6392563",
"0.637537",
"0.62949324",
"0.56300217",
"0.5565096",
"0.554508",
"0.554508",
"0.55141723",
"0.54848456",
"0.5452291",
"0.53380793",
"0.53380674",
"0.53212523",
"0.531709",
"0.52783054",
"0.52707314",
"0.52675736",
"0.52643305",
"0.5262123",
"0.5244581",
"0.524166... | 0.0 | -1 |
IFieldWidget factory for LocationWidget. | def LocationFieldWidget(field, request):
return FieldWidget(field, LocationWidget(request)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.fields = [ \n \n #plugins.FieldWidget(\"widget\", descr=\"Start from widget\",\n # default=\"/\"),\n #plugins.FieldMarker(\"markersearch\", descr=\"Search for marker\"),\n #plugins.FieldMarker(\"markerreplac... | [
"0.5998817",
"0.5998817",
"0.58848",
"0.5651634",
"0.56191385",
"0.56007206",
"0.5575786",
"0.53905076",
"0.5337973",
"0.5329842",
"0.5285621",
"0.52263105",
"0.52263105",
"0.5196118",
"0.51863796",
"0.5159046",
"0.5151313",
"0.5149169",
"0.5144681",
"0.5127543",
"0.5118616",... | 0.8268078 | 0 |
The `Dataset` is created in `phase.py`. | def __init__(self, dataset: ds.Dataset, settings):
self.dataset = dataset
self.settings = settings
self.visualizer = visualizer.Visualizer() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_datasets(cls, dataset_config, phase):\n raise NotImplementedError",
"def __init__(self, dataset: Dataset):\n self.dataset = dataset",
"def generateDataset(self):\n if self.outdir[-1] != \"/\": \n self.outdir += \"/\"\n self.outdir += \"dataset_trackml\"\n ... | [
"0.69201654",
"0.6653272",
"0.64672613",
"0.63746583",
"0.6292204",
"0.627583",
"0.62632644",
"0.6217298",
"0.62082493",
"0.6206257",
"0.6194928",
"0.6150871",
"0.61010015",
"0.60949945",
"0.60660505",
"0.60438836",
"0.5999239",
"0.5978874",
"0.59778184",
"0.59778184",
"0.594... | 0.55406415 | 73 |
Returns the fit of a list of Profiles (Gaussians, Exponentials, etc.) to the dataset, using a model instance. | def log_likelihood_function(self, instance: af.ModelInstance) -> float:
model_data = self.model_data_from_instance(instance=instance)
fit = self.fit_from_model_data(model_data=model_data)
return fit.log_likelihood | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, models, x, y, z=None, xbinsize=None, ybinsize=None, err=None, bkg=None, bkg_scale=1, **kwargs):\n\n tie_list = []\n try:\n n_inputs = models[0].n_inputs\n except TypeError:\n n_inputs = models.n_inputs\n\n self._data = Dataset(n_inputs, x, y, z, ... | [
"0.6609139",
"0.63325053",
"0.63325053",
"0.63325053",
"0.63325053",
"0.63325053",
"0.63325053",
"0.63325053",
"0.63325053",
"0.63325053",
"0.63325053",
"0.62771976",
"0.62404776",
"0.6146944",
"0.61149955",
"0.6077977",
"0.6064517",
"0.6041971",
"0.6025611",
"0.60122913",
"0... | 0.0 | -1 |
To create the summed profile of all individual profiles in an instance, we can use a list comprehension to iterate over all profiles in the instance. Note how we now use `instance.profiles` to get this dictionary, where in chapter ` we simply used `instance`. | def model_data_from_instance(self, instance: af.ModelInstance) -> np.ndarray:
return sum(
[
profile.profile_from_xvalues(xvalues=self.dataset.xvalues)
for profile in instance.profiles
]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_all(profile):\n params = {}\n params[\"profile\"] = profile\n response = utils.do_request(instanceprofile, \"get\", params)\n data = utils.get_data(\"InstanceProfiles\", response)\n return data",
"def add_profile(self, profile):\r\n self.profiles.append(profile)",
"def calculate... | [
"0.61369634",
"0.5885941",
"0.5739842",
"0.56562793",
"0.5639097",
"0.5628797",
"0.56232256",
"0.56074524",
"0.5585603",
"0.5508757",
"0.5508473",
"0.549711",
"0.54968506",
"0.54808754",
"0.54765385",
"0.54575425",
"0.54535663",
"0.5451851",
"0.54071444",
"0.54000574",
"0.537... | 0.58057755 | 2 |
Call the `FitDataset` class in `fit.py` to create an instance of the fit, whose `log_likelihood` property is used in the `log_likelihood_function`. | def fit_from_model_data(self, model_data: np.ndarray) -> f.FitDataset:
return f.FitDataset(dataset=self.dataset, model_data=model_data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_likelihood_function(self, instance):\r\n\r\n xvalues = np.arange(self.data.shape[0])\r\n model_data = instance.profile_from_xvalues(xvalues=xvalues)\r\n residual_map = self.data - model_data\r\n chi_squared_map = (residual_map / self.noise_map) ** 2.0\r\n log_likelihood =... | [
"0.64182335",
"0.6336622",
"0.63175833",
"0.6288201",
"0.6241241",
"0.61574674",
"0.61114955",
"0.60703874",
"0.6052201",
"0.60460335",
"0.60191625",
"0.59869045",
"0.5968725",
"0.5947575",
"0.59368837",
"0.5896655",
"0.58380103",
"0.5819216",
"0.5817973",
"0.5807584",
"0.580... | 0.0 | -1 |
This visualize function is used in the same fashion as it was in chapter 1. The `Visualizer` class is described in tutorial 2 of this chapter. | def visualize(
self, paths: af.Paths, instance: af.ModelInstance, during_analysis: bool
):
model_data = self.model_data_from_instance(instance=instance)
fit = self.fit_from_model_data(model_data=model_data)
self.visualizer.visualize_dataset(paths=paths, dataset=self.dataset)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_visuals(self):\n pass",
"def visualize(self):\n # TODO\n #pyLDAvis.enable_notebook()\n #vis = pyLDAvis.gensim.prepare(self.lda_model, self.stemmed_corpus)\n return",
"def visualise(self):\n\n scores, education = self.get_data()\n self.write_data(scores, education)\n... | [
"0.7063717",
"0.70084274",
"0.6780399",
"0.67113185",
"0.6641346",
"0.6596172",
"0.634411",
"0.62974614",
"0.6267937",
"0.62584573",
"0.6230526",
"0.62199605",
"0.6215069",
"0.62079453",
"0.6161333",
"0.6143889",
"0.6129229",
"0.6113831",
"0.6110358",
"0.6108171",
"0.6070151"... | 0.0 | -1 |
Save files like the dataset, mask and settings as pickle files so they can be loaded in the ``Aggregator`` | def save_attributes_for_aggregator(self, paths):
# These functions save the objects we will later access using the aggregator. They are saved via the `pickle`
# module in Python, which serializes the data on to the hard-disk.
with open(f"{paths.pickle_path}/dataset.pickle", "wb") as f:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pickle_data(self):\n if 'data_sets.pckl' in self.expected_pickles:\n to_file(\n self.data_sets,\n os.path.join(self.logdir, 'data_sets.pckl')\n )\n if 'all_params.pckl' in self.expected_pickles:\n to_file(\n self.all_pa... | [
"0.71841556",
"0.7051201",
"0.6999294",
"0.69657177",
"0.6965532",
"0.67290497",
"0.6701712",
"0.67006266",
"0.66806704",
"0.6629543",
"0.662331",
"0.66160923",
"0.6615659",
"0.66139543",
"0.659722",
"0.65589774",
"0.65515673",
"0.65493506",
"0.6524547",
"0.64821887",
"0.6479... | 0.7810631 | 0 |
Initializes pythontwitter wrapper with the Twitter API credentials | def __init__(self):
self.api = Api(consumer_key=credentials["consumer_key"],
consumer_secret=credentials["consumer_secret"],
access_token_key=credentials["access_token_key"],
access_token_secret=credentials["access_token_secret"]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_twitter():\n auth = tweepy.OAuthHandler(credentials[\"twitter\"][\"consumer_key\"], credentials[\"twitter\"][\"consumer_secret\"])\n auth.set_access_token(credentials[\"twitter\"][\"access_token\"], credentials[\"twitter\"][\"access_token_secret\"])\n return tweepy.API(auth)",
"def __init__(se... | [
"0.8182253",
"0.7952092",
"0.78614396",
"0.78030735",
"0.7798696",
"0.7798696",
"0.77020943",
"0.7680609",
"0.76543593",
"0.75703394",
"0.75466865",
"0.7542911",
"0.7506404",
"0.74154884",
"0.7342675",
"0.72171617",
"0.71095985",
"0.71095985",
"0.71095985",
"0.71095985",
"0.7... | 0.6326717 | 40 |
Verifies if the given tokens are valid | def verify_credentials(self):
try:
self.api.VerifyCredentials()
logging.info('Successfully verified')
return True
except TwitterError as e:
logging.error('Error verifying credentials: %s', e.message[0]['message'])
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unused_token_is_valid(self):\n assert self.token.is_valid()",
"async def validate_token(self, token):",
"def _check_tokens(number_token=None, name_token=None, gpe_token=None):\n assert number_token is None or number_token == number_token.lower(), \\\n \"Tokens need to be lowercase: %s... | [
"0.76983315",
"0.7479158",
"0.73251635",
"0.7157225",
"0.71501803",
"0.7138056",
"0.7013063",
"0.69469047",
"0.6733868",
"0.66120076",
"0.65514505",
"0.6477569",
"0.6383798",
"0.6369523",
"0.6334665",
"0.6297028",
"0.6261812",
"0.6243167",
"0.62244207",
"0.62236446",
"0.61701... | 0.0 | -1 |
Posts a twit on the moody_py account | def tweet(self, twitter_post, instruction):
if instruction is None:
logging.error('Instruction parameter missing')
return TwitterResponse(description='Instruction parameter missing')
if instruction == Instruction.PROCESS_WEATHER_DATA:
twit_content = "{}, {} {} C {}".... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_to_twitter(tweet):\n auth = tweepy.OAuthHandler(\n os.environ['BLADAMADUR_CONSUMER_KEY'],\n os.environ['BLADAMADUR_CONSUMER_SECRET'])\n auth.set_access_token(\n os.environ['BLADAMADUR_ACCESS_TOKEN'],\n os.environ['BLADAMADUR_ACCESS_TOKEN_SECRET'])\n api = tweepy.API(au... | [
"0.7384305",
"0.73712504",
"0.697456",
"0.6869901",
"0.6778252",
"0.6729129",
"0.6716007",
"0.670674",
"0.6551957",
"0.65180176",
"0.6512323",
"0.6452721",
"0.643159",
"0.641381",
"0.63216686",
"0.6315954",
"0.6310251",
"0.629947",
"0.6298899",
"0.6287242",
"0.6287242",
"0.... | 0.687649 | 3 |
The name of this component. | def name(self):
return "component_manager" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_component_name(self):\n return self._name",
"def name(self):\r\n return self.component.get(\"Name\", \"\")",
"def name(self):\r\n return self.component.get(\"Name\", \"\")",
"def get_name(self):\n return COMPONENT_LIST[self.index][0]",
"def name(self):\n return se... | [
"0.9065345",
"0.897935",
"0.897935",
"0.8652009",
"0.8357189",
"0.8357189",
"0.8357189",
"0.8357189",
"0.8357189",
"0.8357189",
"0.8357189",
"0.8357189",
"0.8357189",
"0.8357189",
"0.83296686",
"0.83296686",
"0.83296686",
"0.83296686",
"0.83296686",
"0.83296686",
"0.83296686"... | 0.0 | -1 |
Called by the simulation context. | def setup(self, configuration, lifecycle_manager):
self.configuration = configuration
self.lifecycle = lifecycle_manager
self.lifecycle.add_constraint(
self.get_components_by_type,
restrict_during=["initialization", "population_creation"],
)
self.lifecycl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n\t\t\n\t\tpass",
"def run(self): \r\n return",
"def make_simulation(self):\n pass",
"def run(self):\r\n pass",
"def RUN(self):",
"def postRun(self):\n pass",
"def _setup_simulation(self\n ) -> None:\n pass",
"def run(s... | [
"0.70393395",
"0.69843966",
"0.69002396",
"0.68817323",
"0.67909",
"0.67798424",
"0.67723346",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",
"0.6762831",... | 0.0 | -1 |
Registers new managers with the component manager. Managers are configured and setup before components. | def add_managers(self, managers: Union[List[Any], Tuple[Any]]):
for m in self._flatten(managers):
self.apply_configuration_defaults(m)
self._managers.add(m) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_manager(self) -> None:\n\n #Clean out the process list.\n self.process_list.clear()\n for _ in range(self.num_processes):\n p = Process(target=self.multiprocessing_job,\n args=(self.process_job,))\n self.process_list.append(p)\n sel... | [
"0.61248213",
"0.60335684",
"0.6032508",
"0.5993886",
"0.59699",
"0.58547497",
"0.5809432",
"0.56251633",
"0.56170464",
"0.56035906",
"0.55961794",
"0.5585247",
"0.5480994",
"0.54456997",
"0.53996974",
"0.53993297",
"0.53955936",
"0.5385212",
"0.5380328",
"0.5357524",
"0.5357... | 0.74649 | 0 |
Register new components with the component manager. Components are configured and setup after managers. | def add_components(self, components: Union[List[Any], Tuple[Any]]):
for c in self._flatten(components):
self.apply_configuration_defaults(c)
self._components.add(c) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_component(var, config):\n id_ = text_type(var.base)\n if id_ not in CORE.component_ids:\n raise ValueError(u\"Component ID {} was not declared to inherit from Component, \"\n u\"or was registered twice. Please create a bug report with your \"\n ... | [
"0.6344829",
"0.63038844",
"0.6204114",
"0.6132295",
"0.6074433",
"0.5977594",
"0.5963998",
"0.5922624",
"0.591374",
"0.58610815",
"0.5751899",
"0.57106787",
"0.5632077",
"0.5617429",
"0.56010264",
"0.559912",
"0.5562307",
"0.5527054",
"0.551372",
"0.551043",
"0.5477497",
"... | 0.5851719 | 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.