def wiki_geosearch(option, opt_str, value, parser): length = len(parser.rargs) global geosearch_res if length < 2: parser.error(colored("option -g needs at least 2 arguments!", "red", attrs=["bold"])) elif length > 3: parser.error(colored("option -g can't handle more than 3 arguments!", "red", attrs=["bold"])) elif length == 2: [latitude, longtitude] = parser.rargs print '\n'+"=="*15+"result"+"=="*15+'\n' try: geosearch_res = wikipedia.geosearch(latitude, longtitude) except wikipedia.WikipediaException: parser.error(colored("An unknown error occured: 'Invalid coordinate provided'. Please report it on GitHub!", "red", attrs=["bold"])) for res in geosearch_res: cprint(res+'\n', "green") print '\n'+"=="*16+"end"+"=="*16+'\n' else: [latitude, longtitude, radius] = parser.rargs try: geosearch_res = wikipedia.geosearch(latitude, longtitude, radius=radius) except wikipedia.WikipediaException: parser.error(colored("An unknown error occured: 'Invalid coordinate provided'. Please report it on GitHub!", "red", attrs=["bold"])) print '\n'+"=="*15+"result"+"=="*15+'\n' for res in geosearch_res: cprint(res+'\n', "green") print '\n'+"=="*16+"end"+"=="*16+'\n'
def get_wiki_result(self): """ Method to search a result in wikipedia if an answer exists then make an output of the 2 first sentences if they are existing otherwise send the "unfind" answer from the init """ try: find_result = wikipedia.search(self.text_parsed) print(find_result) if not find_result: return self.unfind else: wik_page_name = find_result[0] description = wikipedia.summary(wik_page_name, sentences=2) resume = ("Alors alors! A ce que je comprends, " "tu veux l'endroit à cette adresse: {}? " "Non mais tu sais que {}." .format(self.address, description)) return resume except exceptions.DisambiguationError: use_coordinate = self.geocode description = wikipedia.geosearch(use_coordinate['lat'], use_coordinate['lng']) alternative_result = wikipedia.summary(description, sentences=2) alternative_answer = "{} Si ce n'est pas la réponse que tu attendais " \ "alors soit plus précis. Tu vois, si je te dis par exemple: 'Paris'. " \ "Ca veut dire quoi? La célébrité? la ville? le défi? " \ "Voyons mon petiot tu peux le faire!".format(alternative_result) return alternative_answer except wikipedia.exceptions.WikipediaException: use_coordinate = self.geocode description = wikipedia.geosearch(use_coordinate['lat'], use_coordinate['lng']) alternative_result = wikipedia.summary(description, sentences=2) alternative_answer = "{} C'est ça que tu voulais savoir??!!".format(alternative_result) return alternative_answer
def hello(): try: visits = redis.incr("counter") except RedisError: visits = "<i>cannot connect to Redis, counter disabled</i>" city_results = wikipedia.geosearch(latitude=lat, longitude=lon, title=None, results=10, radius=10000, feature_type='city') city_wiki = map(print_wiki, city_results) city_out = "" for i in city_wiki: city_out += str(i) + " " # event_results = wikipedia.geosearch(latitude=lat, # longitude=lon, # title=None, # results=30, # radius=10000, # feature_type='event') # # if len(event_results) > 0: # try: # event_wiki = map(print_wiki, event_results) # else: # event_wiki = None event_wiki = None return city_out
def geosearch(self, args): """::geosearch:: used to find out what happend at a certain location or in the range of radius. examole: 1. geosearch 180 27 -> return event take place at 180' 27' 2. geosearch 180 27 100 -> return event take place in 100 meters range from point 180' 27'""" global geosearch_res [latitude, longtitude, radius] = [0] * 3 if len(args) < 2 or len(args) > 3: raise AssertionError(colored("function geosearch handle 2 or 3 arguments!",\ "red", attrs=["bold"])) elif len(args) == 2: [latitude, longtitude] = args[:] elif len(args) == 3: [latitude, longtitude, radius] = args[:] try: geosearch_res = wikipedia.geosearch(latitude, longtitude, radius=radius) except wikipedia.WikipediaException: raise AssertionError(colored("An unknown error occured: 'Invalid coordinate\ provided'. Please report it on GitHub!", "red", attrs=["bold"])) for res in geosearch_res: cprint(res + '\n', "green")
def wiki_geosearch(option, opt_str, value, parser): """ used to find out what happend at a certain location or in the range of radius """ length = len(parser.rargs) global geosearch_res [latitude, longtitude, radius] = [0] * 3 if length < 2: parser.error( colored("option -g needs at least 2 arguments!", "red", attrs=["bold"])) elif length > 3: parser.error( colored("option -g can't handle more than 3 arguments!", "red", attrs=["bold"])) elif length == 2: [latitude, longtitude] = parser.rargs[:] else: [latitude, longtitude, radius] = parser.rargs[:] try: geosearch_res = geosearch(latitude, longtitude, radius=radius) except WikipediaException: parser.error( colored( "An unknown error occured: 'Invalid coordinate provided'. Please report it on GitHub!", "red", attrs=["bold"])) exit(1) for res in geosearch_res: cprint(res + '\n', "green")
def get_wiki_result(self, lat, lng, question): """Return the summary and the url of the wikipedia page searched""" try: wiki_page = wikipedia.page(question) return {"summary": wiki_page.summary[:500], "url": wiki_page.url} except (wikipedia.exceptions.PageError): return "no result" except (wikipedia.exceptions.DisambiguationError): try: wiki_search = wikipedia.geosearch(lat, lng, question) wiki_page = wikipedia.page(wiki_search[0]) return { "summary": wiki_page.summary[:500], "url": wiki_page.url } except IndexError: return "no result" except (wikipedia.exceptions.DisambiguationError): return "no result"
def find_page_titles_around_point( self, point: Point, title=None, results=None, radius=10000) -> List[str]: """Find pages around point using Wikipedia Geosearch Args: - point: geographic point to search around - title: optional title of nearby page - results: max number of results. Not sure if None is unlimited - radius: search radius in meters. Between 10 and 10,000 Returns: - Page _titles_ around point. Loading actual page metadata is slower, so that can be done in a later function, in case I want to get just titles to filter. """ if not isinstance(point, Point): raise TypeError('point must be of type Point') if title is not None: if not isinstance(title, str): raise TypeError('title must be str') assert isinstance(point, Point), 'point must have Point geometry' lon, lat = list(point.coords)[0] res = wikipedia.geosearch( latitude=lat, longitude=lon, title=title, results=results, radius=radius) return res
def wiki_geosearch(option, opt_str, value, parser): """ used to find out what happend at a certain location or in the range of radius """ length = len(parser.rargs) global geosearch_res [latitude, longtitude, radius] = [0] * 3 if length < 2: parser.error(colored("option -g needs at least 2 arguments!", "red", attrs=["bold"])) elif length > 3: parser.error(colored("option -g can't handle more than 3 arguments!", "red", attrs=["bold"])) elif length == 2: [latitude, longtitude] = parser.rargs[:] else: [latitude, longtitude, radius] = parser.rargs[:] try: geosearch_res = geosearch(latitude, longtitude, radius=radius) except WikipediaException: parser.error( colored( "An unknown error occured: 'Invalid coordinate provided'. Please report it on GitHub!", "red", attrs=["bold"], ) ) exit(1) for res in geosearch_res: cprint(res + "\n", "green")
def __get_page_title(self): """ find article from geocode""" wikipedia.set_lang("fr") self.page_title = wikipedia.geosearch(self.lat, self.long, title=None, results=1, radius=1000)[0]
def get_geo_info(station): ''' FIXME: some stations get None for district and neighborhood, maybe could be fixed by some algortithm that moves the point around until some non None result is obtained for both. See wikipedia also approach above TODO: the wikipedia approach could be improved by replacing exact matching by approximate matching, maybe with NLTK ''' longitude, latitude = float(station['long']), float(station['lat']) # reverse geocoding # NOTE Geocoder.reverse_geocode returns a kind of iterator # with objects that can only be consumed once, beware district, neighborhood, postalcode = None, None, None geo_results = None try: geo_results = Geocoder.reverse_geocode(latitude, longitude) except: geo_results = None if geo_results != None: for result in geo_results: district = result.sublocality if (district == None) else district neighborhood = result.neighborhood if (neighborhood == None) else neighborhood if postalcode == None: postalcode_match = _postalcode_re.match(str(result)) postalcode = postalcode_match.groupdict()['postalcode'] if (postalcode_match != None) else None if (filter(lambda x: x == None, [district, neighborhood, postalcode]) == []): break # try with wikipedia if needed wikipedia_places = None # try by neighborhood if neighborhood == None: wikipedia_places = wikipedia.geosearch(latitude, longitude) for place in wikipedia_places: if place in _neighborhood_to_distric.keys(): neighborhood, district = place, _neighborhood_to_distric[place] break # try by district if district == None: wikipedia_places = wikipedia_places if (wikipedia_places != None) else wikipedia.geosearch(longitude, latitude) for place in wikipedia_places: if place in _district_to_neighborhoods.keys(): district = place break geo_info = {"district" : district, "neighborhood" : neighborhood, "postalcode" : postalcode} return geo_info
def nearby(x): """Locates and returns any Wikipedia page whose physical location is near that of the page supplied.""" try: (lat, lon) = x.coordinates return wikipedia.geosearch(lat, lon, radius=10000) except KeyError: # Accessing coordinates of a page that doesn't have them appears # to throw a key error, despite documentation to the contrary. return None
def wikigeo(lat, lon): l1 = wikipedia.geosearch(lat, lon, title=None, results=10, radius=1000) #print(l1[0]) return (l1[0], wikipedia.summary(l1[0], sentences=0, chars=2048, auto_suggest=False, redirect=True))
def process_geo(message): # noinspection PyBroadException try: lat, lan = (str(message.text).replace('E', '').replace('W', '').replace('N', '').replace('S', ''). replace('° ', '').replace('°', '').replace(',', '').replace(' ', ' ').split(" ")) change_lang(message) for i in wikipedia.geosearch(latitude=lat, longitude=lan, results=5, radius=1000): bot.send_message(chat_id=message.chat.id, text=i, reply_markup=main_keyboard()) except Exception: bot.send_message(chat_id=message.chat.id, text="Not a location.", reply_markup=main_keyboard())
def local_search(self): """ Find nearby sites to self.location """ # Search Wikipedia for nearby pages self.wiki_resp = wk.geosearch(self._coordinates[0], self._coordinates[1], results=self.results, radius=self.radius)
def nearby(x): """ Locates and returns any Wikipedia page whose physical location is near that of the page supplied. """ try: (lat, lon) = x.coordinates return wikipedia.geosearch(lat, lon, radius=10000) except KeyError: # Accessing coordinates of a page that doesn't have them appears # to throw a key error, despite documentation to the contrary. return None
def __set_lookup(self): # Makes a geosearch based on latitude # and longitude, gives back 5 possible # options in a str list self.__set_language() self.lookup = wikipedia.geosearch(self.data[1][0], self.data[1][1], results=5, radius=2000) return self.lookup
def search(coord, place_name): """Finds the Wikipedia page corresponding to the given place. The current implementation requires Wikipedia geotags, meaning it'll miss: - Chains (Starbucks) - Corporate pages (Lagunitas, as opposed to the brewery site) - Area-based things (49-mile drive in SF) :param coord: is (latitude, longitude) :return: A wikipedia page title. """ # We don't use the title arg of `wikipedia.geosearch`. It will return exact title matches, even if the geo location # does not match, so "Boulevard" will return a street rather than the restaurant (which is "Boulevard (restaurant)"). wiki_page_titles = wikipedia.geosearch(*coord) return _match_place_name_to_wiki_page(place_name, wiki_page_titles)
def run_alexa(): command = take_commad() if "play" in command: song = command.replace("play", "") talk("playing..." + song) print(pywhatkit.playonyt(song)) elif "time" in command: time = datetime.datetime.now().strftime("%I:%M %p") print(time) talk(f"current time is {time}") elif "who is" in command: person = command.replace("who is", "") info = wikipedia.summary(person, 1) print(info) talk(info) elif "location" in command: info = wikipedia.geosearch(48.109840, 11.476990) talk(info) elif "weather" in command: info = webbrowser.open( "https://www.google.com/search?q=weather+in+my+location&oq=weather+in+&aqs=chrome.1.69i57j0i67i457j0i20i263l2j0l2j69i60l2.5105j1j7&sourceid=chrome&ie=UTF-8" ) info1 = command.replace("weather", "") print(info) talk(info1) elif "what about" in command: talk( "Sakhawat Hossain is a bangladeshi descent and now living in munich, germany" ) elif "date" in command: talk("sorry I am not feeling well, I have a headache") elif "are you single" in command: talk("no, I am currently in a relationship with Aaminur") elif "joke" in command: talk(pyjokes.get_joke()) print(pyjokes) else: print("please say it again ")
def wikiRef(self, key_lat, key_lon): wk.set_lang('en') try: summ = wk.summary(self.key_city, sentences = 3) print('◈Wiki summary of '+self.key_city+'◈') print(summ+'..') except wk.exceptions.DisambiguationError: print('.') beatAmbig = wk.search(self.key_city) summ_1 = wk.summary(beatAmbig[1], sentences = 3) print('◈Wiki summary of '+self.key_city+'◈') print(summ_1+'..') except wk.exceptions.PageError:print('CANNOT FIND ANY DATA ON WIKI') finally: related = wk.geosearch(key_lat, key_lon, results = 5, radius = 10000) print('\n◈Geographically related results (up to 5 results)◈\n') num = 1 for re in related: print(str(num)+'. '+re) num += 1
def process_geo(message): try: lat, lan = ( str(message.text) .replace("E", "") .replace("W", "") .replace("N", "") .replace("S", "") .replace("° ", "") .replace("°", "") .replace(",", "") .replace(" ", " ") .split(" ") ) set_lang("en") locations = geosearch(latitude=lat, longitude=lan, results=10, radius=1000) if locations: nearby = "<b>Nearby locations</b> are..." bot.send_message( chat_id=message.chat.id, text=nearby, parse_mode="html", reply_markup=main_keyboard(), ) for i in locations: bot.send_message( chat_id=message.chat.id, text=i, reply_markup=main_keyboard() ) else: sorry = "Sorry, can't find nearby locations" bot.send_message( chat_id=message.chat.id, text=sorry, reply_markup=main_keyboard() ) except Exception: bot.send_message( chat_id=message.chat.id, text="Use <b>Map</b> to get coordinates.", parse_mode="html", reply_markup=main_keyboard(), )
def wiki_geosearch(lat, lon, rad): loc_name = wikipedia.geosearch(lat, lon, radius=rad, results=30) latLon = np.zeros(len(loc_name) * 2) summary = list() urls = list() x = 0 y = 0 while y < len(loc_name): page = wikipedia.page(str(loc_name[y])) sum_des = page.summary.encode('utf-8') summary.append(sum_des) url = page.url.encode('utf-8') urls.append(url) coord = page.coordinates loc_name[y] = str(loc_name[y]) latLon[x] = float(coord[0]) latLon[x+1] = float(coord[1]) x += 2 y += 1 latLon = latLon.reshape(len(loc_name), 2) latLon = latLon.tolist() return latLon, loc_name, summary, urls
def index(request): """ Twiiter and Wikipedia API Call """ tweet_list = [] wiki_list = [] search = request.GET.get('search', '').strip() if search and request.method == 'GET': try: if request.GET.get('lag') and request.GET.get('log'): lag = request.GET.get('lag') log = request.GET.get('log') wiki_topic = wikipedia.geosearch(lag, log, search) else: wiki_topic = wikipedia.search(search, 15) except wikipedia.exceptions.DisambiguationError as e: print e.options for topic in wiki_topic: wiki = dict() wiki['topic'] = topic wiki_list.append(wiki) if request.GET.get('lag') and request.GET.get('log'): lag = request.GET.get('lag') log = request.GET.get('log') data = search_twitter(search, lag + ',' + log + ',100mi') else: data = search_twitter(search) results = data['statuses'] for result in results: tweet = dict() tweet['user'] = result['user']['screen_name'] tweet['tweet'] = result['text'] tweet['img_url'] = result['user']['profile_image_url_https'] tweet_list.append(tweet) return render(request, 'mexicoder/index.html', {'data': tweet_list, 'wikidata': wiki_list})
def get_history_url(self): wikipedia.set_lang("fr") try: place = wikipedia.geosearch(latitude=self.lat, longitude=self.lng, results=1) url = wikipedia.page(place[0]).url history = wikipedia.summary(place[0]) return history, url # PageError if the page doesn’t exist except wikipedia.exceptions.PageError: return # DisambiguationError if the page is a disambiguation page except wikipedia.exceptions.DisambiguationError: return # WikipediaException if the latitude or longitude does not match any results except wikipedia.exceptions.WikipediaException: return # if wikipedia.geoserch gives an empty list(search for algeria) so wikipedia.page(place[0]).url raise an IndexError except IndexError: return
def wiki_geosearch(lat, lon, rad): loc_name = wikipedia.geosearch(lat, lon, radius=rad, results=30) latLon = np.zeros(len(loc_name) * 2) summary = list() urls = list() x = 0 y = 0 while y < len(loc_name): page = wikipedia.page(str(loc_name[y])) sum_des = page.summary.encode('utf-8') summary.append(sum_des) url = page.url.encode('utf-8') urls.append(url) coord = page.coordinates loc_name[y] = str(loc_name[y]) latLon[x] = float(coord[0]) latLon[x + 1] = float(coord[1]) x += 2 y += 1 latLon = latLon.reshape(len(loc_name), 2) latLon = latLon.tolist() return latLon, loc_name, summary, urls
def search_wiki_by_term(term, geo_search=False, lat="", lng=""): lang = 'en' count = 5 radius = 10000 wikipedia.set_lang(lang) items = [] try: if geo_search: names = wikipedia.geosearch(float(lat), float(lng), title=term, results=count, radius=radius) else: names = wikipedia.search(term, results=count) for name in names: try: page = wikipedia.page(name) wiki = WikiItem(page.title, page.categories, page.summary, page.revision_id) items.append(wiki) except wikipedia.exceptions.DisambiguationError: continue return items except wikipedia.exceptions.WikipediaException: raise WikiAPIQueryError
def get_wikipedia_data_near_coords(latitude, longitude): """Get 10 data max near (10km) gps coords ex :GmapLatitude":"47.9908779", "GmapLongitude":"0.24142796" :param arg1: latitude :param arg2: longitude :type arg1: <float> :type arg2: <float> """ # Get titles of pages #wikipedia.geosearch(latitude, longitude, results=10, radius=10000) # Keyword arguments: # # title - The title of an article to search for # results - the maximum number of results returned # radius - Search radius in meters. The value must be between 10 and 10000 article_titles = wikipedia.geosearch(float(latitude), float(longitude)) return [get_wikipedia_article_info(article_title) for article_title in article_titles]
import wikipedia wikipedia.set_lang("zh-tw") import wikitextparser as wtp from hanziconv import HanziConv # 台灣歷史年表 # 台灣歷史 # 台灣日治時期 # 臺灣古蹟列表 # TODO: 若整個頁面有一個地點,所有裡面的歷史事件就用該頁面的地點 # TODO: 若整個頁面非一個地點,所有歷史事件就用該句子中有包含的地點。若該歷史事件的句子還是沒有 page = wikipedia.page('臺灣古蹟列表') from get_place import * for site in page.links[0:10]: print(site) print(get_places(site)) wikipedia.page('三崁店社') 中華民國直轄市定古蹟 wikipedia.search('古蹟') wikipedia.page('中正紀念堂').coordinates wikipedia.geosearch(25.03555555999999882033080211840569972991943359375,121.51972222000000556363374926149845123291015625)
def find_page_by_name(self, name: str, point=None, radius=None): """Find a single Wikipedia page given a name Search for the top 5 results. If there's a result with the exact same normalized name, choose that article. Otherwise, choose the first result. Note that even when the name is not exactly the same, the first result usually makes sense. For example, the first result for "Mount Rainier Wilderness" is "Mount Rainier National Park". And it would be ok to show the wikipedia page for the National Park when a user clicks on the wilderness polygon. Args: - name: name to search for - point: point in WGS84 to search around - radius: radius in meters to search around point """ if not isinstance(name, str): raise TypeError('name must be str') if point is not None: if not isinstance(point, Point): raise TypeError('point must be of type Point') if radius is not None and radius > 10000: raise ValueError('max radius 10,000 meters') if point is None: res = wikipedia.search(name, results=5) else: lon, lat = list(point.coords)[0] radius = 400 if radius is None else radius res = wikipedia.geosearch( latitude=lat, longitude=lon, title=name, results=5, radius=radius) exact_match = [ ind for ind, s in enumerate(res) if normalize_string(s) == normalize_string(name) ] choice = None if exact_match != []: choice = exact_match[0] else: choice = 0 # Here turn auto_suggest to False because I know the page name exists # Otherwise sometimes the page names redirect from a name that exists to # a name that does not. For example, searching # ``` # wikipedia.page('Shasta-Trinity National Forest') # ``` # raises `PageError: Page id "shasta trinity national forests" does not # match any pages. Try another id!`, while the page does exist: # https://en.wikipedia.org/wiki/Shasta%E2%80%93Trinity_National_Forest # See also # https://github.com/goldsmith/Wikipedia/issues/192 # https://github.com/goldsmith/Wikipedia/issues/176 return wikipedia.page(res[choice], auto_suggest=False)
def geosearch(self, lat, longitude, num_results=1, radius=1000): return wikipedia.geosearch(lat, longitude, results=num_results, radius=radius)
def get_info_handler(self, bus_message): ''' {'topic' : <keyword>, 'summary' : <numSentences>, 'geosearch' : {'lat' : <float>, 'long' : <float> 'radius' : <int> }, 'coordinates' : 'True', 'references' : 'True' } :param bus_message: :type bus_message: ''' #print(bus_message.content) try: req_dict = json.loads(bus_message.content) except ValueError: err_resp = {'error' : 'Bad json in wikipedia request: %s' % str(bus_message.content)} resp = self.bus.makeResponseMsg(bus_message, json.dumps(err_resp)) self.bus.publish(resp) return try: self.check_req_correctness(req_dict) except ValueError as e: err_resp = {'error' : '%s' % `e`} resp = self.bus.makeResponseMsg(bus_message, json.dumps(err_resp)) self.bus.publish(resp) res_dict = {} if req_dict.get('summary', None) is not None: summary = wikipedia.summary(req_dict['topic'], sentences=req_dict['summary']) res_dict['summary'] = summary.encode('UTF-8', 'replace') wants_page = False else: # Wants whole page content: wants_page = True if req_dict.get('geosearch', None) is not None: geo_parms = req_dict['geosearch'] lat = geo_parms['lat'] longitude = geo_parms['long'] radius = geo_parms['radius'] res_dict['geosearch'] = wikipedia.geosearch(lat, longitude, req_dict['topic'], radius) # Remaining request possibilities require the page to be obtained, # even if summary was requested: page = None if req_dict.get(u'coordinates', None) is not None and req_dict['coordinates']: if page is None: page = wikipedia.page(req_dict['topic']) try: (lat, longitude) = page.coordinates res_dict['coordinates'] = '{"lat" : "%s", "long" : "%s"}' %\ (str(lat), str(longitude)) except KeyError: # Wikipedia entry has not coordinates associated with it: res_dict['coordinates'] = '"None"' if req_dict.get('references', None) is not None and req_dict['references']: if page is None: page = wikipedia.page(req_dict['topic']) res_dict['references'] = page.coordinates if wants_page: if page is None: page = wikipedia.page(req_dict['topic']) res_dict['content'] = page.content resp_msg = self.bus.makeResponseMsg(bus_message, json.dumps(res_dict)) self.bus.publish(resp_msg)
"""Code snippets vol-53 261-Wikipedia geo search. Download all snippets so far: https://wp.me/Pa5TU8-1yg Blog: stevepython.wordpress.com Requirements: pip3 install wikipedia https://pypi.org/project/wikipedia/ Origin: Unknown (sorry, had this on my drive for ages with no origin.) """ import wikipedia print(wikipedia.geosearch(51.505905, -0.022066)) #returns: #['Cabot Square', 'West India Quay', 'Canary Wharf', #'International Sugar Organization', 'SS Robin', #'Canary Wharf DLR station', '1 Cabot Square', #'1 West India Quay', '25 North Colonnade', 'Marriott Canary Wharf']
def locate(lat, lon): speak( "Based on Wikipedia geosearch here we have the most important places near that coordinates" ) print(wikipedia.geosearch(lat, lon))
ny = wikipedia.page("pondicherry") print ny.title print ny.url #print ny.content.encode("iso-8859-15", "xmlcharrefreplace") #print ny.links[0] #print wikipedia.summary("Facebook") ''' wikipedia.search(query, results=10, suggestion=False) Do a Wikipedia search for query. Keyword arguments: results - the maxmimum number of results returned suggestion - if True, return results and suggestion (if any) in a tuple ''' queries = wikipedia.search('Facebook',results = 51, suggestion = True) #print query print queries #print len(queries) for query in queries: print query print wikipedia.suggest('Facebook') print wikipedia.summary('Facebook', sentences=2, chars=10, auto_suggest=True, redirect=True) print wikipedia.page(title="Facebook", pageid=None, auto_suggest=True, redirect=True, preload=False) print wikipedia.geosearch(72.0, 12.0 , title='Facebook', results=10, radius=1000) wikipage = wikipedia.WikipediaPage(title='Facebook', pageid=None, redirect=True, preload=False, original_title=u'') print wikipage
def location_search(self): geo_location = wikipedia.geosearch(37.787, -122.4)
import pandas as pd ##Query 1: finding out more about Hamilton, this returns a list of search results. ## There are three possible arguments, the first is the search parameter, the second ## is a limit on the number of results that can show on a page, and the last is a boolean to ## turn on and off auto-suggestions search_param = "Hamilton" num_results = 100 print(wikipedia.search(search_param, results = num_results, suggestion = True)) ## Query 2: finding wikipedia articles related to longitude and latitude ## coordinates. These coordinates for example are from a california earthquake ## returns a list of results markes as within 10,000 m, which is also the upper bound of the radius parameter latitude = 35.3400 longitude = -120.1900 print(wikipedia.geosearch(latitude, longitude, radius = 10000)) #Query 3: Opening up a wikipedia page, and then you can access features in the WikipediaPage ## object like the content (a full printout of the entire page) or images, a list of all the image urls in that page Columbia_University = wikipedia.WikipediaPage("Columbia University") print(Columbia_University.content) print(Columbia_University.images) ##with these queries, you can build cool datasets like the following, where you can get a csv of wikipedia articles that happen around earthquake coordinates: latitude_list = [37.86319, 51.272222222222, 3.244, 18.513815, -40.8158] longitude_list = [-122.25365, 30.224166666667, 95.825, -72.288193, -72.0028] radius_list = [] for i in range(0, len(latitude_list)): radius_list.append(wikipedia.geosearch(latitude_list[i], longitude_list[i], results = 500, radius = 10000))
lat=centerLat, lon=centerLon, radius=10, in_gallery=True) for photo in photos['photos']['photo']: photoDict.append(photo) except: continue pois = {} rawTexts = {} poiTitleToId = {} myId = 1 #GET ALL POIS wikiRes = wikipedia.geosearch(centerLat, centerLon, results=1000, radius=10000) for ind, title in enumerate(wikiRes): print(ind) try: page = wikipedia.page(title) plat, plon = map(float, page.coordinates) poiTitleToId[title] = myId pois[myId] = {'name': title, 'lat': plat, 'lon': plon} rawTexts[myId] = page.content myId += 1 except: continue with open('dictionary.txt', 'w') as f: for title in poiTitleToId: f.write(title + '\t' + str(poiTitleToId[title]) + '\t' +
wp.search('Ireland', results=5) # Get the summary wp.summary('Ireland') wp.summary('Ireland', sentences=1) # Get a full page Dublin = wp.page('Dublin') Dublin.title Dublin.url Dublin.content Dublin.images Dublin.links # Geosearch searches by latitude wp.geosearch(48.8582, 2.2945, radius=100) # Get a random page wp.random(pages=1) # Get the raw html Dublin_raw = wp.WikipediaPage('Dublin') Dublin_raw.html() # Slow # Can get way more rich stuff with this too, including revision IDs and similar # Some fun ideas # Find two random pages and see if you can link them together via intermediate pages using the links object # Create a social network matrix of articles that link to each other # Use regular expressions to extract interesting bits of text from pages. e.g. what's the most popular word used on wikipedia? # Any other good ideas?
def search_by_geocoordinates(geo_lat, geo_lon, poi_name = None): results = wikipedia.geosearch(geo_lat, geo_lon, poi_name) return results
def search_info(self): ''' Returns the list of infomation about the city ''' self.info = wikipedia.geosearch(self.crd[0], self.crd[1]) return self.info
def wikiGeo(self): #주변 장소 related = wk.geosearch(self.lat, self.lon, results=5, radius=7000) return related
def get_geo_articles(location_page_link, limit=100): article = wikipedia.page(location_page_link) coords = article.coordinates lat, lon = coords neighbors = wikipedia.geosearch(lat, lon, results=limit, radius=10000) return neighbors
import wikipedia print(wikipedia.search("Bill")) print(wikipedia.suggest("Bill cliton")) #print(wikipedia.summary("Ubuntu")) # print(wikipedia.summary("key")) # print(wikipedia.summary("Key (cryptography)")) print(wikipedia.page("Ubuntu")) print(wikipedia.page("Python").content) print(wikipedia.page("Python").url) print(wikipedia.page("Python").references) print(wikipedia.page("Python").title) print(wikipedia.page("Python").categories) print(wikipedia.page("Ubuntu").links) print(wikipedia.geosearch(37.787, -122.4)) print(wikipedia.page(37.787, -122.4)) wikipedia.set_lang("de") print(wikipedia.summary("ubuntu", sentences=2)) print(wikipedia.languages()) print(wikipedia.page("ubuntu").images[0]) print(wikipedia.page("Ubuntu").html())