def search_(search_query): search_results = search(search_query) and_ids = search(search_query)['ands'] or_ids = search(search_query)['ors'] #Each key in 'ands' and 'ors' has a list of integers that represent #the ids of the meteorites. ands = {'countries': [], 'meteorites': [], 'classifications': []} ors = {'countries': [], 'meteorites': [], 'classifications': []} for model, ids in and_ids.items(): for id in ids: m_info = requests.get('http://meteorite-landings.me/api/' + model + '/' + str(id)).json() ands[model].append(m_info) for values in or_ids.values(): for model, ids in values.items(): for id in ids: m_info = requests.get('http://meteorite-landings.me/api/' + model + '/' + str(id)).json() ors[model].append(m_info) return jsonify(ors = ors, ands = ands)
def search_with_start(start_ind): t_routes = [] this_start = start_ind[0] this_end = start_ind[1] print(start_ind) start_time = time.time() for ind in range(this_start, this_end + 1): print('Process ' + str(start_ind[2]) + ': start number ' + str(ind)) a = len(t_routes) search.search(search.normalOrders.index[ind]) t_nodes, t_times = search.resultsNodes, search.resultsTime t_routes += merge.format_transform(t_nodes, t_times, search.orders) print('Process ' + str(start_ind[2]) + ': end number ' + str(ind) + ' with start length ' + str(a) + ' end length ' + str(len(t_routes)) + ' add ' + str(len(t_nodes))) clear_search_results() now_time = time.time() if now_time - start_time >= 1200.0: f1 = open('temp_res/ori_routes' + str(start_ind[2]), 'wb') pickle.dump((ind, this_end, t_routes), f1) f1.close() start_time = now_time f1 = open('temp_res/ori_routes_C' + str(start_ind[2]), 'wb') pickle.dump(t_routes, f1) f1.close() return t_routes
def test_search(self): search.search(base.get_dbo(), FakeSession(), "test") keywords = [ "os", "notforadoption", "notmicrochipped", "hold", "quarantine", "deceased", "forpublish", "people", "vets", "retailers", "staff", "fosterers", "volunteers", "shelters", "aco", "homechecked", "homecheckers", "members", "donors", "reservenohomecheck", "overduedonations", "activelost", "activefound" ] for k in keywords: search.search(base.get_dbo(), FakeSession(), k)
def do_GET(self): global squid_hostname global squid_port global google_domain global yahoo_domain global keyword parts = self.path.split("?") #Extract requested file and get parameters from path path = parts[0] #Extract variables from get parameters try: arguments = {} arguments["q"] = None #Variable for search request. Default None to prevent errors if no search request was started if (len(parts) > 1): raw_arguments = parts[1].split("&") for raw_argument in raw_arguments[:]: argument = raw_argument.split("=", 1) arguments[argument[0]] = argument[1] if (argument[0] == "p"): # Yahoo uses search?p= so lets copy that to q=, which is what Google uses. arguments["q"] = argument[1] except: print ("No get parameters") print (path) #Decide wether a search or the style.css was requested if (path == "/style.css"): self.document = open('style.css', 'r').read() self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write(bytes(self.document, "utf-8")) elif (path == "/proxy.pac"): self.document = open('proxy.pac', 'r').read() self.document = self.document.replace('<keyword>', keyword.lower(), 1) self.document = self.document.replace('<google_domain>', google_domain, 1) self.document = self.document.replace('<yahoo_domain>', yahoo_domain, 1) self.document = self.document.replace('<squid_host>', squid_hostname, 2) self.document = self.document.replace('<squid_port>', str(squid_port), 2) self.send_response(200) self.send_header('Content-type', 'x-ns-proxy-autoconfig') self.end_headers() self.wfile.write(bytes(self.document, "utf-8")) elif (arguments["q"] != None): arguments["q"] = arguments["q"].replace(keyword + '+', '', 1) arguments["q"] = arguments["q"].replace('+', ' ') arguments["q"] = arguments["q"].replace('! ', '') command = commands(self) search(command).search(arguments["q"]) else: self.send_response(404) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write(bytes('Not found. Please visit <a href="https://github.com/HcDevel/Siri-API/wiki/_pages">https://github.com/HcDevel/Siri-API/wiki/_pages</a>', "utf-8")) return
def main(): opts = read_opts() if not opts.c_backend: print "WARNING: training in pure python. Run with -c option to enable the (much faster) C++ backend" feature_descriptors = faces.list_feature_descriptors((16, 16)) data = [] print "loading faces..." faces.load_data_dir("Face16", 1, feature_descriptors, data, opts.num_faces, opts.c_backend) faces.load_data_dir("Nonface16", -1, feature_descriptors, data, opts.num_other, opts.c_backend) print "suffling..." random.shuffle(data) if opts.sample_size: train_data = data[: opts.sample_size] validation_data = data[opts.sample_size : opts.sample_size + opts.validate_size] elif opts.validate_size: train_data = [] validation_data = data[: opts.validate_size] else: train_data = data validation_data = [] if opts.load_classifier: with open(opts.load_classifier) as in_file: classifier = serializer.load(in_file) else: print "training boosted classifier..." if not train_data: print "specify some training data with the -s flag." exit(1) classifier = boost.train_classifier(train_data, opts.num_iterations) print classifier if train_data: print "training error:" classify(classifier, train_data) if validation_data: print "validation error:" if opts.each_iter: classify_with_all_iterations(classifier, validation_data, opts.plot_iters) else: classify(classifier, validation_data) if opts.plot_features: plot_features(classifier, feature_descriptors) if opts.search_image: search.search(classifier, opts.search_image, feature_descriptors, opts.c_backend) if opts.save_classifier: with open(opts.save_classifier, "w") as out_file: serializer.dump(classifier, out_file)
def search(self, item): print "SEARCH" add_here(history_list[self.window_index][here[self.window_index][0]][0], self.window_index) if history_list[self.window_index][here[self.window_index][0]][0] != "*\\*": result = search(str(item), history_list[self.window_index][here[self.window_index][0]][0]) else: result = search(str(item), history_list[self.window_index][here[self.window_index][0] - 1][0]) print result if result: self.ui.listView.clear() listView(result, self.ui.listView) add_here("*\\*", self.window_index)
def testDateSearch(self): self.assertEquals([["# 0001-01-01\n", "{0} \n".format(write.time) + write.prepareContent("Start of datesearch")], ["# 0015-01-01\n", "{0} \n".format(write.time) + write.prepareContent("Middle of datesearch")]], search.search("", "0001-01-01", "0015-01-01")) self.assertEquals([["# 0001-01-01\n", "{0} \n".format(write.time) + write.prepareContent("Start of datesearch")], ["# 0015-01-01\n", "{0} \n".format(write.time) + write.prepareContent("Middle of datesearch")], ["# 0031-01-01\n", "{0} \n".format(write.time) + write.prepareContent("End of datesearch")]], search.search("", "0001-01-01", "0031-01-01"))
def do_GET(self): parsed_path = urlparse.urlparse(self.path) # res = [] res = {} if parsed_path.path == '/analyze': url = parsed_path.query.split('=')[1] while isShorten(url) == True: _, url = get(url) res['url'] = url prot, domain, path = parseURL(url) res['evil'] = isEvil(domain) num, title, content = search(url) res['num'] = num res['title'] = title res['content'] = content if prot != 'https': res['grade'] = 'F' else: res['grade'] = grading(url) elif parsed_path.path == '/expand': url = parsed_path.query.split('=')[1] while isShorten(url) == True: _, url = get(url) res['url'] = url elif parsed_path.path == '/check': url = parsed_path.query.split('=')[1] _, domain, _=parseURL(url) res['evil'] = isEvil(domain) elif parsed_path.path == '/grade': url = parsed_path.query.split('=')[1] while isShorten(url) == True: _, url = get(url) print('URL:', url) grade = grading(url) res['grade'] = grade print('Grade:', grade) elif parsed_path.path == '/search': url = parsed_path.query.split('=')[1] num, title, content = search(url) res['num'] = num res['title'] = title res['content'] = content # print('Content:', content.decode('utf-8')) self.send_response(200) self.end_headers() result = makeHTML(json.dumps(res)) self.wfile.write(result.encode('utf-8')) return
def search(self, searchParam={}): """ search is the main function: it is processing the request and put the element in the queue """ #self.initVoteThreads() searchResult = [] pageLimit = self.constants["BASE_CONFIG"]["search_page_limit"] if "searchParams" in self.enviroment_variables["configValues"]: if "pageLimit" in self.enviroment_variables["configValues"]["searchParams"]: pageLimit = self.enviroment_variables["configValues"]["searchParams"]["pageLimit"] # put the request in a queue, so we can have multithread searching for multiaccount for page in xrange(1, pageLimit+1): self.logger.info("Request for " + searchParam["term"] + " type: " + searchParam["typeSearch"] + " sort: " + searchParam["sort"] + " page: " + str(page)) tmpSearchArray = search(self, term=searchParam["term"], typeSearch=searchParam["typeSearch"], sort=searchParam["sort"], categories=searchParam["categories"], page=page) if len(tmpSearchArray) > 0 and searchParam["typeSearch"] in tmpSearchArray and len(tmpSearchArray[searchParam["typeSearch"]]) > 0: for item in tmpSearchArray[searchParam["typeSearch"]]: # check if i can vote and if i can comment and i can follow # need to check in config # put it in a function... self.constants["QUEUE_VOTE"].put(item) self.constants["QUEUE_COMMENT"].put(item) # self.constants["QUEUE_FOLLOW"].put(self.follow(item)) searchResult = searchResult + tmpSearchArray[searchParam["typeSearch"]] time.sleep(randint(15, 35)) # I need to wait some seconds to do another search # add result in all active queue and|or in file return searchResult
def DO_PLUGIN_SEARCH(self, args, criterion, exact): search_terms = args url = "http://sourcemod.net/plugins.php?search=1&%s=%s" % (criterion, search_terms) db_search_terms = search_terms.replace("%", "\\%").replace("*", "%") if not exact: db_search_terms = "%" + db_search_terms + "%" search_args = {criterion: db_search_terms} plugins = search.search(**search_args) length = len(plugins) if length == 0: # No results found return "No results found for \x02%s\x02" % (args) elif length == 1: plugin = plugins[0] return "\x02%s\x02, by %s: %s " "( http://forums.alliedmods.net/showthread.php?p=%s )" % ( plugin["title"], plugin["author"], plugin["description"], plugin["postid"], ) elif length < 7: return "Displaying \x02%d\x02 results: %s ( %s )" % ( length, ",".join(map(lambda o: o["title"], plugins)), url, ) else: return "First \x026\x02 results of \x02%d\x02: %s ( %s )" % ( length, ", ".join(map(lambda o: o["title"], plugins[:6])), url, )
def duenote(index): target = list_of_readable_files[int(index)] text = documents.get_text_from_file(target) textSnippets = search.search(text) data = [] for text in textSnippets: labels = classify(text) data.append(labels) scheduling, todo = parseJSON(data) google_calendar = GoogleCalendar() google_task = GoogleTask() for t in todo: print ("Sending task\n") google_task.add_task(t) t.due_date = datetime.strftime(parser.parse(t.due_date), '%m/%d/%y') for s in scheduling: print ("Sending cal\n") google_calendar.send_to_google_calendar(s) s.start_time = datetime.strftime(parser.parse(s.start_time), '%m/%d/%y') return render_template('duenote.html', scheduling=scheduling,todo=todo)
def search_results(page, mentee_topic_choice=None): mentee_topic_choice = mentee_topic_choice or request.form.get("searchtopics") print "~~~~~~~~~~~~~~~~mentee_topic_choice" print mentee_topic_choice mentor_data = search.search(mentee_topic_choice) if mentor_data: start_index = (page - 1) * (PER_PAGE) end_index = (page) * (PER_PAGE) ment_count = len(mentor_data) users = mentor_data[start_index:end_index] # users = mentor_data.paginate(page, PER_PAGE, False) if not users and page != 1: abort(404) pagination_per_page = pagination.Pagination(page, PER_PAGE, ment_count) search_topic = search.search_topic_display(mentee_topic_choice) return render_template( "searchresults.html", search_topic_display=search_topic, pagination=pagination_per_page, users=users, mentee_topic_choice=mentee_topic_choice, ) messages = flash("Sorry! There are no mentors under this search topic") return redirect(url_for("index"))
def find(): from search import search fromEnvVars = FromEnvVars( name, description, hints = "CCTBX_ROOT" ) paths = search( [fromEnvVars] ) return paths
def DO_PLUGIN_SEARCH(self, args, criterion, exact): search_terms = args.replace(" ", "+") url = "http://sourcemod.net/plugins.php?search=1&%s=%s" % (criterion, search_terms) db_search_terms = search_terms.replace('%', '\\%').replace('*', '%') if not exact: db_search_terms = '%' + db_search_terms + '%' search_args = { criterion: db_search_terms } plugins = search.search(**search_args) length = len(plugins) if length == 0: # No results found return "No results found for \x02%s\x02" % (args) elif length == 1: plugin = plugins[0] return "\x02%s\x02, by %s: %s "\ "( http://forums.alliedmods.net/showthread.php?p=%s )" % (plugin['title'], plugin['author'], plugin['description'], plugin['postid']) elif length < 7: return "Displaying \x02%d\x02 results: %s ( %s )" % (length, ",".join(map(lambda o: o['title'], plugins)), url) else: return "First \x026\x02 results of \x02%d\x02: %s ( %s )" % (length, ", ".join(map(lambda o: o['title'], plugins[:6])), url)
def __init__(self, proxies={'http': 'http://127.0.0.1:8080', 'https': 'http://127.0.0.1:8080'}): """ Creates an instance of the ZAP api client. :Parameters: - `proxies`: dictionary of ZAP proxies to use. Note that all of the other classes in this directory are generated new ones will need to be manually added to this file """ self.__proxies = proxies self.acsrf = acsrf(self) self.ajaxSpider = ajaxSpider(self) self.ascan = ascan(self) self.authentication = authentication(self) self.autoupdate = autoupdate(self) self.brk = brk(self) self.context = context(self) self.core = core(self) self.forcedUser = forcedUser(self) self.httpsessions = httpSessions(self) self.importLogFiles = importLogFiles(self) self.params = params(self) self.pnh = pnh(self) self.pscan = pscan(self) self.script = script(self) self.search = search(self) self.selenium = selenium(self) self.sessionManagement = sessionManagement(self) self.spider = spider(self) self.users = users(self)
def test_bridge_has_shab_cookie(self): """ When bridge has shab cookie, abtest_manager.reload should be called and shab cookie should be removed from bridge response headers. """ # Set bridge response text to be good JSON. mock_bridge_response = MockBridgeResponseWithShabCookie() mock_bridge_response.text = '{"search_result": {"results_good": true, "primary_parametric_fields": ["good"]}}' mock_requests_get = mock.MagicMock( name="mock_requests_get", return_value=mock_bridge_response) mock_get_http_headers = mock.MagicMock( name='mock_get_http_headers', return_value={}) with mock.patch('requests.get', mock_requests_get): with mock.patch('serpng.lib.http_utils.get_http_headers', mock_get_http_headers): mock_request = MockRequest() mock_request.abtest_manager.reload_cookie = mock.MagicMock(name='mock_reload_cookie') # pylint: disable=W0612 # (result and user_data are not tested in this test case) # result_sj added for SJ Ads A/B test. response_headers, result, result_sj, user_data = search.search( request=mock_request, query=MockQuery()) mock_request.abtest_manager.reload_cookie.assert_called_with('shab_val', True) self.assertEqual(response_headers, {'set-cookie': 'has_comma has_comma, no_comma no_comma'})
def search_search(): query = request.args.get('q') start = request.args.get('from') size = request.args.get('size') # return render_template('search.html.jinja2', results=search.search('scrapi', query, start, size)) results, count = search.search('scrapi', query, start, size) return json.dumps(results)
def search(request): if request.GET.has_key('q'): try: q = request.GET['q'] results = s.search(q) gene_ids= [] for result in results: if result['doc_type'] == 'GENE': gene_ids.append(result['id']) gene_objs = Gene.objects.filter(pk__in=gene_ids) species_genes = {} species_names = {} genes = [] for gene_obj in gene_objs: species_names[gene_obj.species.id] = gene_obj.species.name bicluster_ids = [b.id for b in gene_obj.bicluster_set.all()] regulates = Bicluster.objects.filter(influences__name__contains=gene_obj.name) _, influence_biclusters = get_influence_biclusters(gene_obj) if not species_genes.has_key(gene_obj.species.id): species_genes[gene_obj.species.id] = [] genes = species_genes[gene_obj.species.id] genes.append(GeneResultEntry(gene_obj.id, gene_obj.name, gene_obj.species.id, gene_obj.description, bicluster_ids, influence_biclusters, regulates)) except Exception as e: error_message = str(e) return render_to_response('search.html', locals())
def solve(totals, goal, init=None): ''' Search for shortest path to solve the pouring problem. totals -- a tuple of capacities (numbers) of glasses goal -- a number indicating the volume level we want to have any one of the glasses contain init -- optional tuple of initial levels for each glass If start is not specified, we set the starting levels of each glass to zero. We start the search at the start state and follow paths of successor states (generated by `next`) until we reach the goal. After reaching the goal state, we return the shortest path found, a sequence of states from start to goal state. ''' done = lambda state: state.contains(goal) init = init or tuple(0 for t in totals) glasses = (Glass(i,t) for i,t in zip(init, totals)) start = State(Glasses(glasses), action=None) return search(start, next, done)
def test_good_bridge_response(self): """When the bridge response is good, good response_header, result and user_data should be constructed and returned.""" # Set bridge response text to be good JSON. mock_bridge_response = MockBridgeResponse() mock_bridge_response.text = '{"search_result": {"results_good": true, "primary_parametric_fields": ["good"]}}' mock_requests_get = mock.MagicMock( name="mock_requests_get", return_value=mock_bridge_response) mock_get_http_headers = mock.MagicMock( name='mock_get_http_headers', return_value={}) with mock.patch('requests.get', mock_requests_get): with mock.patch('serpng.lib.http_utils.get_http_headers', mock_get_http_headers): # result_sj added for SJ Ads A/B test. response_headers, result, result_sj, user_data = search.search( request=MockRequest(), query=MockQuery()) expected_search_result = MockSearchResult( request=MockRequest(), search_result_json={'results_good': True, 'primary_parametric_fields': ['good']}, bridge_search_query='' ) self.assertEqual(expected_search_result, result) expected_user_data = MockUserData( json_response={'search_result': {'results_good': True, 'primary_parametric_fields': ['good']}} ) self.assertEqual(expected_user_data, user_data) self.assertEqual(response_headers, {'a': 'b'})
def websearch(bot, data): """Search the web for a query. use ! to send result to channel, and @ to receive as personal message """ if data["message"][0] == "!": query = data["message"].replace("!search ", "") destination = "to" else: query = data["message"].replace("@search ", "") destination = "from" try: results = search.search(query) except URLError: bot.send("Sorry, I dun goofed",channel=data[destination]) return if (results == []): bot.send("No search results for \"{}\"".format(query), channel=data[destination]) return bot.send("Web results for \"{}\":".format(query),channel=data[destination]) for result in results: bot.send("* {}: {}".format(result[0], result[1]), channel=data[destination])
def do_GET(self): start = time.time() out = codecs.getwriter("utf-8")(self.wfile, 'xmlcharrefreplace') self.send_response(200, "OK") self.send_header("Content-Type", "text/xml") self.end_headers() out.write('<?xml version="1.0" encoding="utf-8" ?>') query = urlparse.urlparse(self.path).query params = urlparse.parse_qs(query) search.search(params, self.wfile) end = time.time() print >>sys.stderr, "Elapsed:", end - start
def searchView(request): """ Renders search.html using the search results of a query entered into the search bar @type request: string @param request: An HTML request @rtype: HTML page @return: Rendered version of search.html """ sform = SearchForm(request.POST) # Ensure form is valid if not sform.is_valid(): return index(request) user_query = sform.cleaned_data['search_query'] # Get search results. Format: [ MatchObject, MatchObject, ...] search_result = search(user_query) # Construct a dictionary from search results to pass along to html template search_dict = {"results" : [], "query" : ''} for match in search_result : # Make list for each MatchObject in search_result. # List format = [MatchObject, type of object, name of object, [LiObject, LiObject, ...] ] result_list = [match] result_list.extend(getTypeNameImage(match.idref)) search_dict["results"].append(result_list) search_dict["query"] = sform.cleaned_data['search_query'] return render(request, 'wcdb/search.html', search_dict)
def main(): arguments = docopt(doc, version='Python Package Manager 0.1') if arguments['install']: if arguments['<package>']: install(arguments['<package>']) else: #find requirements.txt #find package.json #load dependence list #call install for all deps pass elif arguments['search']: if arguments['<package>']: search(arguments['<package>']) return 1
def my_form_post(): keyword = request.form['text'] keyword = keyword.upper().lower() data_type = get_id_type(request.form['platform']) resultSearch = [] start_download = False word_id = 0 print "adresse ip : ", request.remote_addr conn = manage_database.connect_database() manage_database.add_connection_user(conn, request.remote_addr) if keyword == None or keyword == "": return (render_template("index.html", type=data_type, dataResults=[])) data_ret = manage_database.search_word(conn, keyword, request.form['platform']) if data_ret == None: start_download = True cursor = conn.cursor() cursor.execute('''INSERT INTO keyword (word, nb) VALUES(?, ?)''', (keyword, 1,)) word_id = cursor.lastrowid conn.commit() """ search_results = search(keyword) image_search = search_image(keyword) news_results = searchNews(keyword) videos_search = search_video(keyword) torrent_search = search_torrent(keyword) manage_database.fill_new_entry(conn, keyword, search_results, image_search, \ news_results, videos_search, torrent_search) """ else: resultSearch = data_ret thread_download = threading.Thread(target=optimise_request.download, args=(keyword, word_id)) if request.form['platform'] == "search": if data_ret == None: resultSearch = search(keyword) elif request.form['platform'] == "images": if data_ret == None: resultSearch = search_image(keyword) elif request.form['platform'] == "news": if data_ret == None: resultSearch = searchNews(keyword) elif request.form['platform'] == "videos": if data_ret == None: resultSearch = search_video(keyword) elif request.form['platform'] == "torrent": if data_ret == None: resultSearch = search_torrent(keyword) if start_download == True: thread_download.start() conn.close() if resultSearch != None: return (render_template("index.html", type=data_type, dataResults=resultSearch)) return (render_template("index.html", type=data_type, dataResults=[]))
def find_ancestors(z, arcs_from): initial_paths = [SearchPath(0, vertex) for vertex in z] expand = make_expand(arcs_from, feasible_sign=-1) extract_state = lambda path : path.extract_state() result = search(initial_paths, expand, has_reached_goal, extract_state) closed = result['closed'] z_ancestors = set(closed.keys()) return z_ancestors
def update_result_search(conn, keyword): search_results = search(keyword) image_search = search_image(keyword) news_results = searchNews(keyword) videos_search = search_video(keyword) torrent_search = search_torrent(keyword) manage_database.update_row(conn, keyword, search_results, image_search,\ news_results, videos_search, torrent_search)
def analyse_args(args): try: option, value = split_arg(args[0]) except IndexError: return create_session() allowed_opts = { # these don't take any value, and don't respond if an invalid value is passed 'help': 'print (help_string)', 'configure': 'Session(is_bare = True).reconfigure()', 'change-pass': '******', 'random': 'random(create_session())', # these demand one value (`backup` requires a valid location, while the other three require a datetime format) 'write': 'Story(create_session(), when = value, is_write = True).write()', 'view': 'Story(create_session(), when = value, check_path = True).view()', 'backup': 'backup(create_session(), backup_loc = value)', 'encrypt': 'Story(create_session(), when = value, check_path = True).encrypt()', } try: if option == 'search': # special handling for `search` args.extend(['lang=None', 'start=start', 'end=end', 'grep']) options, values = zip(*map(split_arg, args)) grep_val = '0' if 'ugly' in options else values[options.index('grep')] search(session = create_session(), word = value, lang = values[options.index('lang')], start = values[options.index('start')], end = values[options.index('end')], grep = int(grep_val) if grep_val and grep_val.isdigit() else 7) # '7' is rather smooth elif option == 'stats': # ... and `stats` args.extend(['lang=None']) options, values = zip(*map(split_arg, args)) stats(session = create_session(), speed = int(value) if value and value.isdigit() else None, lang = values[options.index('lang')]) else: exec(allowed_opts[option]) exit('') except KeyError: print ERROR, 'Invalid arguments! Continuing with the default...' return create_session() except (KeyboardInterrupt, EOFError): sleep(CAPTURE_WAIT) exit('\nGoodbye...\n')
def GET(self): i = web.input(q="", page=1) page = int(i.page) nmatched, results = search.search(i.q, page=page-1) if len(results) == 1 and page == 1: raise web.seeother(results[0].id) else: return render.search(results, nmatched, page)
def is_d_connected(x, y, z, arcs_from): initial_paths = [SearchPath(0, vertex, vertex, 0, 0) for vertex in x] z_ancestors = find_ancestors(z, arcs_from) is_blocked = make_blocked_predicate(z, z_ancestors) expand = make_expand(arcs_from, is_blocked) has_reached_goal = make_goal_test(y) extract_state = lambda path : path.extract_state() result = search(initial_paths, expand, has_reached_goal, extract_state) return result['reached_goal']
def test_search_for_fail_on_no_connection(): """ Testing search if does not crash if the database does not exist. """ test_engine = create_engine('sqlite:///') Base.metadata.create_all(test_engine) test_session = sessionmaker(bind=test_engine) test_session = test_session() result = search.search("DEMO123", session=test_session) print("Result is:\n", result) expected_result = json.dumps({"status": "OK", "results": []}) print("Expected:\n", expected_result) assert result == expected_result
def get_collection(collection: str): model = model_selector(collection) query = request.args.get("query", None, type=str) populate = request.args.get("populate", False, type=json.loads) if query == None: return make_response({"error": "No query provided."}, 400) resp: list = search(collection, query, populate) if len(resp) > 20: return make_response({"error": "To many results. Consider being more " + "specific.", "matches": len(resp)}, 400) resp = json.dumps(resp, ensure_ascii=False, indent=4) return resp
def do_GET(self): self.do_HEAD() _GET = parse_qs(urlparse(self.path).query) if 'q' in _GET: result = search.search(_GET['q'][0]) self.wfile.write("<html><head><title>Search result</title></head>") self.wfile.write("<body>") self.wfile.write("<p>Result in " + str(result['time']) + " seconds</p>") for page in result['pages']: self.wfile.write("<p>" + page[1] + "</p>") self.wfile.write("<p>You accessed path: %s</p>" % self.path) self.wfile.write("</body></html>") self.finish()
def dosearch(): query = request.args['query'] qtype = request.args['query_type'] page_num = int(request.args['page_num']) results = 0 search_results = search.search(query, qtype, page_num) if len(search_results) > 0: if isinstance(search_results[-1][0], int): results = search_results[-1][0] del search_results[-1] return render_template('results.html', query=query, results=results, search_results=search_results, qtype=qtype, pageNum=page_num)
def search(self, searchParam={}): """ search is the main function: it is processing the request and put the element in the queue """ #self.initVoteThreads() searchResult = [] pageLimit = self.constants["BASE_CONFIG"]["search_page_limit"] if "searchParams" in self.enviroment_variables["configValues"]: if "pageLimit" in self.enviroment_variables["configValues"][ "searchParams"]: pageLimit = self.enviroment_variables["configValues"][ "searchParams"]["pageLimit"] # put the request in a queue, so we can have multithread searching for multiaccount for page in xrange(1, pageLimit + 1): self.logger.info("Request for " + searchParam["term"] + " type: " + searchParam["typeSearch"] + " sort: " + searchParam["sort"] + " page: " + str(page)) tmpSearchArray = search(self, term=searchParam["term"], typeSearch=searchParam["typeSearch"], sort=searchParam["sort"], categories=searchParam["categories"], page=page) if len(tmpSearchArray) > 0 and searchParam[ "typeSearch"] in tmpSearchArray and len( tmpSearchArray[searchParam["typeSearch"]]) > 0: for item in tmpSearchArray[searchParam["typeSearch"]]: # check if i can vote and if i can comment and i can follow # need to check in config # put it in a function... self.constants["QUEUE_VOTE"].put(item) self.constants["QUEUE_COMMENT"].put(item) # self.constants["QUEUE_FOLLOW"].put(self.follow(item)) searchResult = searchResult + tmpSearchArray[ searchParam["typeSearch"]] time.sleep(randint( 15, 35)) # I need to wait some seconds to do another search # add result in all active queue and|or in file return searchResult
def smart_update_package(): # init count of packages to be updated package_update_count = 0 # get packages installed with their version number get_package_with_ver = subprocess.Popen("pacman -Qm > ./ver_packages.txt", shell=True) get_package_with_ver.wait() with open(directory + "/ver_packages.txt", "r") as packages: installed_packages_ver = [package.strip() for package in packages] rm_file = subprocess.Popen("rm -rf ./ver_packages.txt", shell=True) rm_file.wait() # get packages installed without version number get_package = subprocess.Popen("pacman -Qqm > ./packages.txt", shell=True) get_package.wait() with open(directory + "/packages.txt", "r") as packages: installed_packages = [package.strip() for package in packages] rm_file = subprocess.Popen("rm -rf ./packages.txt", shell=True) rm_file.wait() # really loopy way to download packages. explanation below # check if the package with the version in the user system is equal to the package with the version available in the aur # if it is, update; else, break the loop for package_name in installed_packages: package_data = search.search(package_name, "name") for result in package_data["results"]: # check if the package name is exactly the same. lemonbar matches only to lemonbar and not lemonbar-xft-git if result["Name"] == package_name: aur_package_with_ver = "%s %s" % (result["Name"], result["Version"]) for package_with_ver in installed_packages_ver: # if the version of the package installed in the system is not equal to the version in the aur, update if package_with_ver != aur_package_with_ver: retrieve_file(package_name) extract_tar(package_name) package_update_count += 1 # exit out of loop after we download package break if not package_update_count: print("all packages are up to date")
def parse_result(self, connstream, r): if r != None and isinstance(r,Result): if r.data: #print("Source:\n" + r.source + "\nData:\n" + str(r.data)) searchhits, regexhits = search().apply_terms(r.data) print("Searchhits: " + str(searchhits)) print("Regexhits: " + str(regexhits)) esr = es_result() esr.source = r.source esr.referrer = r.referrer esr.dataHash = r.dataHash esr.dataBytes = r.dataBytes if len(regexhits) > 0: esr.regex_hit = 1 esr.regex_hits = "\n".join(regexhits) else: esr.regex_hit = 0 if len(searchhits) > 0: esr.searchterm_hit = 1 esr.searchterm_hits = "\n".join(searchhits) else: esr.searchterm_hit = 0 if esr.searchterm_hit or esr.regex_hit: esr.data = base64.b64encode(r.data) else: esr.data = "" esr.timeStart = r.timeStart esr.timeEnd = r.timeEnd c = r.crawlerConfig esr.config_name = c.name esr.config_location = c.location esr.config_protocol = c.protocol esr.config_speed = c.speed esr.config_depth = c.depth esr.config_maxDepth = c.maxDepth esr.config_options = c.options print("Saving to elasticsearch.") esr.save() print("Save complete.") return True return False
def toollist(request): request.encoding = "utf-8" _GG("Log").d("toollist GET :", request.GET, "; POST :", request.POST, "; FILES :", request.FILES) # 获取工具列表键值 tlkey = request.GET.get("k", "all") if tlkey not in TlKeyMap: tlkey = "all" # 校验提交的数据 if "searchText" in request.POST: # 判断是否为所有工具模块 if tlkey == "all": return search(request) # 搜索其他模块 searchText = request.POST["searchText"] title = TlKeyMap[tlkey] result = { "MAIN_HOME_TITLE": settings.MAIN_HOME_TITLE, "MAIN_HOME_URL": settings.MAIN_HOME_URL, "RESOURCE_URL": settings.RESOURCE_URL, "HOME_TITLE": settings.HOME_TITLE, "HOME_URL": settings.HOME_URL, "HEAD_TITLE": f"搜索{title}工具", "tlkey": tlkey, "searchText": searchText, "isSearchNone": False, "toolInfoList": [], } # 根据searchText搜索工具信息列表 result["toolInfoList"].extend(serachToolListByName(tlkey, searchText)) # 判断是否搜索出了结果 if searchText: result["isSearchNone"] = len(result["toolInfoList"]) == 0 return render(request, "toollist_item.html", result) return render( request, "toollist.html", { "MAIN_HOME_TITLE": settings.MAIN_HOME_TITLE, "MAIN_HOME_URL": settings.MAIN_HOME_URL, "RESOURCE_URL": settings.RESOURCE_URL, "HOME_TITLE": settings.HOME_TITLE, "HOME_URL": settings.HOME_URL, "HEAD_TITLE": f"工具列表", "tlkey": tlkey, })
def query(self, args): task_id = self.request.id slogger('query', 'query in progress, task_id={}'.format(task_id)) # Don't touch this: self.update_state(state='PROGRESS') time.sleep(1.5) # a short dwell is necessary for other async processes to catch-up # Change all of this to whatever you want: results = search(args) slogger('query', 'check results and process if necessary') # Only write an Excel file for download if there were actual results if len(results) > 0: # Save locally in Excel format then copy the file to S3 because any local # files store locally in the container are highly volatile and # will likely be deleted before the user has a chance to download reports_folder = os.path.join(os.path.dirname( os.path.realpath(__file__)), 'reports') # Use the Celery task id as the filename (we change it to something more userfriendly later) excel_filename = '{}.xlsx'.format(task_id) local_excel_path = os.path.join(reports_folder, excel_filename) slogger('query', 'saving full report locally as {}'.format(local_excel_path)) excel_writer = pd.ExcelWriter(local_excel_path, engine="xlsxwriter") # Here you can customize the name of the Excel sheet: pd.DataFrame(results).to_excel(excel_writer, sheet_name="BoilerplateResults", index=False) excel_writer.save() # Copy to S3 if enabled if config.DISABLE_S3 == False: bucket_name = os.environ['S3_BUCKET_NAME'] # We prefix the S3 key with the name of the app - you can change this if you want: s3_excel_key = '{}/{}'.format(config.DASH_APP_NAME, excel_filename) slogger('query', 'copying {} to S3 bucket {} with key {}'.format(local_excel_path, bucket_name, s3_excel_key)) client = boto3.client('s3', aws_access_key_id=os.environ['S3_ACCESS_KEY_ID'], aws_secret_access_key=os.environ['S3_SECRET_ACCESS_KEY']) body = open(local_excel_path, 'rb') client.put_object(Bucket=bucket_name, Key=s3_excel_key, Body=body) else: slogger('query', 'caution - S3 is disabled so the Download Excel link will be broken!') else: slogger('query', 'empty results - nothing was saved') # Return results for display slogger('query', 'return results') return results
def dosearch(): """ TODO: Use request.args to extract other information you may need for pagination. """ query = request.args['query'] qtype = request.args['query_type'] """print("Page number: {page}".format(page = request.args.get('page')))""" page = request.args.get('page', 1) page = int(page) offset = (page - 1) * 20 next = page + 1 previous = page - 1 if previous < 1: previous = 1 """if len(tokens) > 1: for x in range(1, len(query)): tokens = tokens + "+{next_tk}".format(next_tk = query[x])""" url = "/search?query_type={x}&query={y}".format(x=qtype, y=query) search_results = search.search(qtype, offset, query) length = int(search_results[-1][0]) del search_results[-1] lower_bound = offset + 1 upper_bound = lower_bound + 19 if upper_bound > length: upper_bound = length return render_template('results.html', query=query, query_type=qtype, results=length, search_results=search_results, x=lower_bound, y=upper_bound, page=page, url=url)
def dosearch_old(page_num, page_turns): query = "" qtype = "" page_num = int(page_num) page_turns = int(page_turns) is_new_query = False page_num = page_num + page_turns """ TODO: Use request.args to extract other information you may need for pagination. """ search_results = search.search(query, qtype, is_new_query, page_num) for result in search_results: song, author, score = result print(song)
def dosearch(): query = request.args['query'] qtype = request.args['query_type'] page = request.args['p'] """ TODO: Use request.args to extract other information you may need for pagination. # """ if page == "1": search_results = search.search(query, qtype) else: search_results = search.search_view(query, qtype, page) return render_template('results.html', query=query, results=len(search_results), search_results=search_results)
def search_component(query): """ Index page w/ search results :return: rendered Page """ # text = request.form['search_text'] text = query # !!!!!! # WARNING: no text sanitation done here. Expected to be done in search! # !!!!!! search_results = search(text) json_results = json.loads(search_results) return render_template('index.html', searchResult=json_results, searchComponent=text)
def test_search_substring(): starter() #one user logs in one channel and one message and searches its substring message_list1 = [] user = auth.auth_login('*****@*****.**', 'youshallpass') token = user.get('token') ch = channels.channels_create(token, '1234', True) #user sends message hey to channel m_id = message.message_send(token, ch.get('channel_id'), 'hey') message_details = message.get_message_details( m_id.get('message_id')).get('message') message_list1.append(message_details) #searches hey message_list2 = search.search(token, 'ey') assert message_list1 == message_list2
def test_exact_string_search_3(self): searcher = search() inputString = "Hello. My name is Eric. I am writing this simple test to check to see how well my parsing algorithm is performing. hello again, dont forget my name: Eric. That is all." queries = ['hello','LASDGLKGSVLIUGAEOUGSVLUHwe;ofrw.k?bwri;hqf.IBALIUGqleiugwKUGwrliugwrgOUGFW ;OURW;U','Eric','my name is Eric!','my name is Eric'] self.assertEqual( [0,115], searcher.exact_query(queries[0],inputString)) self.assertEqual( [], searcher.exact_query(queries[1],inputString)) self.assertEqual( [18,149], searcher.exact_query(queries[2],inputString)) self.assertEqual( [], searcher.exact_query(queries[3],inputString)) self.assertEqual( [7], searcher.exact_query(queries[4],inputString))
def test_exact_string_search_1(self): searcher = search() inputString = "Hello world!" queries = ['hello','LASDGLKGSVLIUGAEOUGSVLUHwe;ofrw.k?bwri;hqf.IBALIUGqleiugwKUGwrliugwrgOUGFW ;OURW;U','Eric','my name is Eric!','my name is Eric'] self.assertEqual( [0], searcher.exact_query(queries[0],inputString)) self.assertEqual( [], searcher.exact_query(queries[1],inputString)) self.assertEqual( [], searcher.exact_query(queries[2],inputString)) self.assertEqual( [], searcher.exact_query(queries[3],inputString)) self.assertEqual( [], searcher.exact_query(queries[4],inputString))
def execute(self, filename, searchMethod, save): self.initialize(filename) if self.maze is None: print("No maze created") raise SystemExit start_time = time.perf_counter() path, statesExplored = search(self.maze, searchMethod) time_taken = time.perf_counter() - start_time pygame.init() self.displaySurface = pygame.display.set_mode( (self.windowWidth, self.windowHeight), pygame.HWSURFACE) self.displaySurface.fill((255, 255, 255)) pygame.display.flip() pygame.display.set_caption(self.windowTitle) print("Results") print("Path Length:", len(path)) print("States Explored:", statesExplored) print("Time taken:", time_taken) print(path) self.drawPath(path) self.drawMaze() self.drawStart() self.drawObjective() pygame.display.flip() if save is not None: pygame.image.save(self.displaySurface, save) self.running = False clock = pygame.time.Clock() while self.running: pygame.event.pump() keys = pygame.key.get_pressed() clock.tick(self.fps) if keys[K_ESCAPE]: raise SystemExit
def test_example_unit_tests(): # Example tests, these do not count as your tests # Basic search, function #1 assert search('dog') == DOG # Advanced search option 1, function #2 expected = [['Mexican dog-faced bat', 'AnomieBOT', 1255316429, 1138], ['Guide dog', 'Sarranduin', 1165601603, 7339]] assert article_length(8000, DOG.copy()) == expected # Advanced search option 2, function #3 expected = [['Black dog (ghost)', 'SmackBot', 1220471117, 14746], ['Mexican dog-faced bat', 'AnomieBOT', 1255316429, 1138], ['Dalmatian (dog)', 'J. Spencer', 1207793294, 26582]] assert article_count(3, DOG.copy()) == expected # Advanced search option 3, function #4 expected = ['Guide dog', 'Sarranduin', 1165601603, 7339] assert random_article(3, DOG.copy()) == expected # Advanced search option 4, function #5 #assert favorite_author('J. Spencer', DOG.copy()) == True # Advanced search option 5, function #6 expected = [['Black dog (ghost)', 'SmackBot'], ['Mexican dog-faced bat', 'AnomieBOT'], ['Dalmatian (dog)', 'J. Spencer'], ['Guide dog', 'Sarranduin'], ['Sun dog', 'Hellbus']] assert title_author(DOG.copy()) == expected # Advanced search option 6, function #7 expected = [['Black dog (ghost)', 'SmackBot', 1220471117, 14746], ['Mexican dog-faced bat', 'AnomieBOT', 1255316429, 1138], ['Dalmatian (dog)', 'J. Spencer', 1207793294, 26582], ['Guide dog', 'Sarranduin', 1165601603, 7339], ['Sun dog', 'Hellbus', 1208969289, 18050], [ 'Spain national beach soccer team', 'Pegship', 1233458894, 1526 ], ['Will Johnson (soccer)', 'Mayumashu', 1218489712, 3562], ['Steven Cohen (soccer)', 'Scouselad10', 1237669593, 2117]] assert multiple_keywords('soccer', DOG.copy()) == expected
def get_author_or_tag_results(path): results = search(path) dirs = list(results.pop('books')) # If there's only 1 book, the combinations of tags/authors # doesn't add any extra info, so dead end here if len(dirs) == 1: return dirs # this ensures that we don't have author or tag directories if there are none for key in ['authors', 'tags']: key_results = list(results[key]) vals_in_path = get_search_terms_of_type(key, path) filtered = [val for val in key_results if val not in vals_in_path] if len(filtered) > 0: dirs.append(key) return dirs
def dosearch(): pageNum = request.args.get('page', -1) query = request.args['query'] qtype = request.args['query_type'] pageNum = int(pageNum) search_results = search.search(query, qtype, pageNum) pageNum = search_results[0] rows = search_results[1] numResults = search_results[2] return render_template('results.html', query=query, query_type=qtype, results=len(rows), totalResults=numResults, search_results=rows, page=pageNum)
def __init__(self, proxies=None, apikey=None): """ Creates an instance of the ZAP api client. :Parameters: - `proxies`: dictionary of ZAP proxies to use. Note that all of the other classes in this directory are generated new ones will need to be manually added to this file """ self.__proxies = proxies or { 'http': 'http://127.0.0.1:8080', 'https': 'http://127.0.0.1:8080' } self.__apikey = apikey self.acsrf = acsrf(self) self.ajaxSpider = ajaxSpider(self) self.ascan = ascan(self) self.authentication = authentication(self) self.authorization = authorization(self) self.autoupdate = autoupdate(self) self.brk = brk(self) self.context = context(self) self.core = core(self) self.forcedUser = forcedUser(self) self.httpsessions = httpSessions(self) self.importLogFiles = importLogFiles(self) self.params = params(self) self.pnh = pnh(self) self.pscan = pscan(self) self.reveal = reveal(self) self.script = script(self) self.search = search(self) self.selenium = selenium(self) self.sessionManagement = sessionManagement(self) self.spider = spider(self) self.stats = stats(self) self.users = users(self) # not very nice, but prevents warnings when accessing the ZAP API via https requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
def test_unit_test_soccer(): soccer_search_results = [ 'Spain national beach soccer team', 'Will Johnson (soccer)', 'Steven Cohen (soccer)', 'Craig Martin (soccer)', "United States men's national soccer team 2009 results", 'China national soccer team', "Wake Forest Demon Deacons men's soccer" ] # Basic search, function #1 assert search('soccer') == soccer_search_results # Advanced search option 1, function #2 expected = [ 'Will Johnson (soccer)', 'Steven Cohen (soccer)', 'Craig Martin (soccer)' ] assert title_length(21, soccer_search_results.copy()) == expected # Advanced search option 2, function #3 assert article_count(4, soccer_search_results.copy()) == [ 'Spain national beach soccer team', 'Will Johnson (soccer)', 'Steven Cohen (soccer)', 'Craig Martin (soccer)' ] # Advanced search option 3, function #4 assert random_article(6, soccer_search_results.copy() ) == "Wake Forest Demon Deacons men's soccer" # Advanced search option 4, function #5 assert favorite_article('Will Johnson (soccer)', soccer_search_results.copy()) == True # Advanced search option 5, function #6 expected = [ 'Spain national beach soccer team', 'Will Johnson (soccer)', 'Steven Cohen (soccer)', 'Craig Martin (soccer)', "United States men's national soccer team 2009 results", 'China national soccer team', "Wake Forest Demon Deacons men's soccer", 'USC Trojans volleyball', 'Mets de Guaynabo (volleyball)' ] assert multiple_keywords('volleyball', soccer_search_results.copy()) == expected
def search_page(request): if "query" not in request.GET: return render(request, "web_search/index.html") else: query = request.GET["query"] ranker = int(request.GET["r"]) if "r" in request.GET else 1 results_all = search(query, index_table, doc_info, ranker) results = results_all[0:20] for i in range(len(results)): r = results[i] url = "http://" + doc_url[r[0]] results[i] = (url, r[0] + ": " + url, r[1]) # url, anchor, score # Compute the NDCG service = build("customsearch", "v1", developerKey=API_KEY) res = service.cse().list(q=query + " site:ics.uci.edu", cx=CX, num=10).execute() urls = [result['formattedUrl'] for result in res['items']] valid_urls = dict() i = 0 for url in urls: print url if i > 4: break parsed = urlparse(url) if parsed.scheme: url = url[len(parsed.scheme) + 3:] if url[-1] == "/": url = url[0:-1] if url in url_doc: valid_urls[url] = i i += 1 print valid_urls dcg = 0 for i in range(5): url = results[i][0][7:] if url in valid_urls: dcg += (5 - valid_urls[url]) / (math.log(i + 1, 2) if i > 0 else 1) ndcg = dcg / (5 + 4 + 3 / math.log(3, 2) + 2 / math.log(4, 2) + 1 / math.log(5, 2)) print ndcg return render(request, "web_search/results.html", {"results": results})
def do_GET(s): """Respond to a GET request.""" print(s.path) getParams = parse_qs(urlparse(s.path).query) print(getParams) ans = None query = getParams query_str = getParams['text'][0] request = getParams['request'][0] if request == '1': ans = get_suggestions(query_str) print(ans[0]) print(json.dumps(ans[0])) else: ans = search(query) s.send_response(200) s.send_header("Content-type", "application/json") s.send_header("Access-Control-Allow-Origin", "*") s.end_headers() s.wfile.write(bytes(json.dumps(ans), 'utf-8'))
def get_new_word(self, token, example): word_info = search(token) answer = "No" if word_info is not None: self.update_dict(word_info) answer = self.ask_func(f"{token}は分かりませんでした。検査したので、これは正解ですか?", ["Yes", "No"]) if answer == "No": token_type = self.ask_func( f"<{token}>って言う言葉はどのタイプですか?", [a.name for a in self.manager.word_types] + ["Skip"]) if token_type != "Skip": return self.manager.learn_word(token, token_type, example) else: self.add_reply("すみません、別の話の方がね。もう一度チャットしてみよう") else: return self.manager.learn_word(token, word_info.types[0], example) return None
def perform_command(to_update, phone, command, body): """ Args: to_update: phone: command: body: Returns: """ results, array_resp, to_search = "", [], body[:25] if command.lower() in ALLOWED_COMMAND: if "#google" in command.lower(): print("[+] Search for :", to_search) results = search(to_search, 3) if "#wiki" in command.lower(): print("[+] Wikipedia for :", to_search) results = wikki(to_search) print("[+] results: ", results) if len(results) > 5: chunks = string_divide(results, 200) for chunk in chunks: print("[+] Sending :", chunk) try_send_sms(phone, chunk) else: try_send_sms(phone, "Any relevant results, try another search !") print("[+] Any relevant results, try another search !") print("[+]Update Made in the database !") to_update["command"]["status"] = True print("to_update:", to_update) Sms().update({ "from_number": phone, "command.label": command, "command.body": body }, to_update)
def update_kd(node_root, data, point): # format given data data = data.replace(" ", "").split(",") for i in range(len(data)): data[i] = data[i].split("=") node = search(node_root, point) if node == False: return False temp_point = point.copy() change = 0 # search for changes in axes from input data(if change exists then node will be deleted and inserted) # Change the value for the other arguments given in the input for i in range(len(data)): atribute = data[i][0] value = data[i][1] if atribute == "Latitude": change = 1 temp_point[0] = float(value) elif atribute == "Longitude": change = 1 temp_point[1] = float(value) elif atribute == "Altitude": change = 1 temp_point[2] = float(value) else: strr = "node." + atribute + " = " + "\"" + value + "\"" exec(strr) # call delete for removing node and use insert for updating the data in a new node if change == 1: temp = node delete_kd(node_root, point) res = insert_kd(node_root, temp_point, [ temp.Name, temp.City, temp.Country, temp.IATA, temp.ICAO, temp_point[0], temp_point[1], temp_point[2], temp.Timezone, temp.DST, temp.Tz_database_time_zone, temp.Type, temp.Source ], temp.Airport_ID) return res return node
def Find(self, request, context): stop_event = threading.Event() def on_rpc_done(): _LOGGER.debug("Attempting to regain servicer thread.") stop_event.set() context.add_callback(on_rpc_done) candidates = [] try: candidates = list( search.search(request.desired_name, request.ideal_hamming_distance, stop_event, self._maximum_hashes)) except search.ResourceLimitExceededError: _LOGGER.info("Cancelling RPC due to exhausted resources.") context.cancel() _LOGGER.debug("Servicer thread returning.") if not candidates: return hash_name_pb2.HashNameResponse() return candidates[-1]
def do_text(self, arg): """ sends text messages to people entered in Contacts. Usage: text <name> -m <message>... """ # Searching Contacts for the receipients number found = search.search(arg, Contacts, session) # If the receipients number is not in contacts, a message saying the same is sent if found[0] == 1: print found [1] # Sending text if receipients number is in contacts elif found[0] == 2: receiver_number = found[2] print "Texting %s ......" %(arg['<name>']) feedback = sms.text(receiver_number, ' '.join(arg['<message>'])) print feedback[0]['status'] # Giving results of sending the text else: pass
def FindRange(self, request, context): stop_event = threading.Event() def on_rpc_done(): _LOGGER.debug("Attempting to regain servicer thread.") stop_event.set() context.add_callback(on_rpc_done) secret_generator = search.search( request.desired_name, request.ideal_hamming_distance, stop_event, self._maximum_hashes, interesting_hamming_distance=request.interesting_hamming_distance) try: for candidate in secret_generator: yield candidate except search.ResourceLimitExceededError: _LOGGER.info("Cancelling RPC due to exhausted resources.") context.cancel() _LOGGER.debug("Regained servicer thread.")