def main():
woosmap_converted_asset = []
with codecs.open(SEARCH_DATA_PATH, 'rb',
encoding='utf8') as search_data_file:
search_data = json.loads(search_data_file.read())
google_places = GooglePlaces(GOOGLE_API_KEY)
for place_id in search_data['places_ids']:
try:
place = google_places.get_place(place_id)
converted_asset = google_places_to_woosmap(place.details)
if bool(converted_asset):
print("... {place_name} ...converted to Wosmap OK".format(
place_name=place.name.encode('utf-8')))
woosmap_converted_asset.append(converted_asset)
except (GooglePlacesError,
GooglePlacesAttributeError) as error_detail:
print(
'Google Returned an Error : {0} for Place ID : {1}'.format(
error_detail, place_id))
pass
except Exception as exception:
print('Exception Returned {0} for Place ID : {1}'.format(
exception, place_id))
time.sleep(1)
pass
export_to_woosmap_json(woosmap_converted_asset)
print('{0} google places extracted for {1} places_ids found '.format(
len(woosmap_converted_asset), len(search_data['places_ids'])))
def getOneWaypoint(waypoint, reference = None):
pool = ConnectionPool('vendalize')
cfmapWaypoint = pycassa.ColumnFamilyMap(data.Waypoint, pool, 'waypoints') #map waypoints to Waypoint Class
si = sunburnt.SolrInterface("http://54.225.230.44:8983/solr/vendalize.waypoints/")
wp = waypoint.lower()
wp = re.sub('[^\w\s]+','', wp)
response = si.query(waypoint_c=wp).execute(constructor=data.Waypoint)
if len(response) > 0: #found waypoint in database so use the googleid as reference for data
result = response[0]
key = result.key
reference = result.googlereference
google_places = GooglePlaces(config.Config.googlePlacesAPIKey)
place = {}
if reference:
place = google_places.get_place(reference)
if not place:
return getOneWaypoint(waypoint, None) #reference lookup failed, try text search
else:
query_result = google_places.text_search(
query = waypoint)
if len(query_result.places) > 0:
place = (query_result.places)[0]
place.get_details()
return place
def main():
woosmap_converted_asset = []
with codecs.open(SEARCH_DATA_PATH, 'rb', encoding='utf8') as search_data_file:
search_data = json.loads(search_data_file.read())
google_places = GooglePlaces(GOOGLE_API_KEY)
for place_id in search_data['places_ids']:
try:
place = google_places.get_place(place_id)
converted_asset = google_places_to_woosmap(place.details)
if bool(converted_asset):
print("... {place_name} ...converted to Wosmap OK".format(place_name=place.name.encode('utf-8')))
woosmap_converted_asset.append(converted_asset)
except (GooglePlacesError, GooglePlacesAttributeError) as error_detail:
print('Google Returned an Error : {0} for Place ID : {1}'.format(error_detail, place_id))
pass
except Exception as exception:
print('Exception Returned {0} for Place ID : {1}'.format(exception, place_id))
time.sleep(1)
pass
export_to_woosmap_json(woosmap_converted_asset)
print('{0} google places extracted for {1} places_ids found '.format(len(woosmap_converted_asset),
len(search_data['places_ids'])))
class GoogleHelper:
"""
Helper class for accessing the google API
"""
def __init__(self, gmaps_api_key=None):
if gmaps_api_key is None:
from config import config
gmaps_api_key = config["gmapsApiKey"]
self.google_places = GooglePlaces(gmaps_api_key)
def get_pois(self, lat_lng, radius, type_list):
"""
location: must be given in latitutde-longitude
radius: distance in meters within which to return plae results
types: What type of point of interest (examples: TYPE_FOOD)
return: List of GooglePlacesSearchResults.
"""
results = []
for t in type_list:
res = self.google_places.nearby_search(lat_lng=lat_lng,
type=t,
radius=radius)
results.extend(res.places)
# if query_result.has_attributions:
# return query_result.html_attributions
return results
def get_pois_features(self, place_id: str):
"""
Gets safety, elevation, other attributes for a given point of interest
"""
query_result = self.google_places.get_place(place_id)
return query_result
def get_pois_reviews(self, place_id):
"""
Gets ratings for a point of interest, returns json
"""
query_result = self.google_places.get_place(place_id)
return query_result.rating
def add_location_to_restaurants():
from .models import Restaurant
from googleplaces import GooglePlaces, types, lang, GooglePlacesError
gplaces = GooglePlaces(GOOGLE_PLACES_API_KEY)
#find all the restaurants that don't have location codes.
nonlocated_restaurants = Restaurant.objects.filter(
Q(latitude__isnull=True) | Q(longitude__isnull=True) )
#iterates through; doesn't need to be a Bulk insert as background task run overnight
for restaurant in nonlocated_restaurants:
try:
current_place = gplaces.get_place(restaurant.location_code)
restaurant.latitude = current_place.geo_location['lat']
restaurant.longitude = current_place.geo_location['lng']
restaurant.save()
except GooglePlacesError:
print "Errored out on ", restaurant, " location code was: ", restaurant.location_code
return "Completed"
def VisitedPlaces(self, lat, lng):
placesVisited = []
google_places = GooglePlaces(API_KEY)
location = {'lat': lat, 'lng': lng}
query_result = google_places.nearby_search(lat_lng=location,
radius=RADIUS)
placesIds = []
for place in query_result.places:
# Returned places from a query are place summaries.
placesIds.append(place.place_id)
for placeid in placesIds:
place_query_result = google_places.get_place(placeid)
placeVisited = {
# 'formatted_address': place_query_result.formatted_address,
'place_types': place_query_result.types
}
placesVisited.append(placeVisited)
# Iterate through our list of placetypes of interest
for search_place_type in PlaceTypeList:
# Iterate through our list of places visited
#print search_place_type
for place_visited in placesVisited:
# Iterate through the list of places types for the current place visited
#print place_visited
for returned_place_type in place_visited['place_types']:
# Check if the returned place type is one that we are searching for
#print returned_place_type
if returned_place_type == search_place_type:
#print 'match found'
# Get the return score from the dictionary
returned_score = dic_place_types_scores[
search_place_type]
# Return the score
return returned_score
return ZERO
def get_place_details(place_id, key):
place = None
google_places = GooglePlaces(key)
while (place is None):
try:
place = google_places.get_place(place_id)
except Exception as e:
# check for NOT FOUND error (place not found)
if 'NOT_FOUND' in e.message:
print 'Place not found error - ' + place_id
return None # return back to caller
else:
print 'sleeping for ' + place_id + ' using key: ' + key + " : " + str(
e.message)
time.sleep(3)
place = None
key = random.choice(new_keys)
google_places = GooglePlaces(key)
return place
def api():
# Google API Key for places
API_KEY = "AIzaSyBM7aOj21cM0LyY07I0EDBSpTNwFrYxlfU"
# Google Place ID for development testing
our_place = "ChIJU15olDoGwYkR5V4cJDvVpuI"
# Yelp Keys
clientid = "jSrFJLrPGi5-n3JuO-ySFA"
clientsecret = "WS5tdjDSzoiXSgm8q9UyogiuYbYSUzjHsDlhluP4rvsp9pohCmuFDIodNCM1gW05"
# Yelp Object
yelp = YelpAPI(clientid, clientsecret)
# Google Object
google = GooglePlaces(API_KEY)
# Only gives name, lat & lng
place = google.get_place(place_id=our_place)
pprint(place.details)
print(place.details['address_components'][0]['long_name'])
print(place.details['address_components'][1]['long_name'])
print(place.details['address_components'][2]['short_name'])
print(place.details['address_components'][5]['short_name'])
#print(place.details['address_components'][7]['long_name'])
#print(place.details['address_components'][6]['short_name'])
print(place.details['international_phone_number'])
print(place.details['name'])
if our_place == place.place_id:
print('Yes')
addr = place.details['formatted_address'].split(",")
print(addr)
print(addr[0], addr[1], addr[2][1:3].strip(), addr[2][4:9], addr[3])
print(len(addr[2][1:3].strip()))
class MapsAPI:
TRAVEL_BY = {
0: 'walking',
1: 'bicycling',
2: 'transit',
3: 'driving',
4: 'flight'
}
def __init__(self, API_KEY):
self.gmaps = googlemaps.Client(key=API_KEY,
queries_per_second=50,
retry_over_query_limit=False)
self.gmaps_get_place_ID = googlemaps.Client(
key=API_KEY, queries_per_second=50, retry_over_query_limit=False)
self.google_places = GooglePlaces(API_KEY)
def set_place_id(self, place, place_address):
place.google_place_id = self.find_place_id(place_address)
def find_place_id(self, place_address):
result = self.gmaps_get_place_ID.find_place(input=place_address,
input_type='textquery')
try:
place_id = result['candidates'][0]['place_id']
except IndexError:
raise ValueError("Place not found")
pp.pprint(result)
return place_id
def safe_index(self, place_detail, index):
if index in place_detail:
return place_detail[index]
def set_store_detail(self, place):
maps_place = self.google_places.get_place(place.google_place_id)
maps_place.get_details()
detail = maps_place.details
print("-" * 50)
pp.pprint(detail)
if 'opening_hours' in detail and 'periods' in detail['opening_hours']:
place.hours = detail['opening_hours']['periods']
else:
place.hours = 'NA'
place.name = self.safe_index(detail, 'name')
place.address = self.safe_index(detail, 'formatted_address')
place.price_level = self.safe_index(detail, 'price_level')
place.url = self.safe_index(detail, 'url')
place.website = self.safe_index(detail, 'website')
place.rating = self.safe_index(detail, 'rating')
place.reviews = self.safe_index(detail, 'user_ratings_total')
place.type_store = self.safe_index(detail, 'types')
# place.save()
def get_place_info(self, place, place_name):
self.set_place_id(place, place_name)
self.set_store_detail(place)
def get_time(self, event, arrival_time):
leg = None
directions_result = None
print('get_time event.start_address', event.start_address)
print('get_time event.end_address', event.end_address)
print('get_time arrival_time', arrival_time) # try:
directions_result = self.gmaps.directions(
event.start_address,
event.end_address,
mode=self.TRAVEL_BY[event.travel_by],
arrival_time=arrival_time)
leg = directions_result[0]['legs'][0]
# except IndexError or googlemaps.exceptions.ApiError:
# raise ValueError("No route")
print(directions_result)
event.start_address = leg['start_address']
event.end_address = leg['end_address']
print('get_time - event.save()')
print('event.start_address', event.start_address)
print('event.end_address', event.end_address)
event.travel_distance = leg['distance']['value'] # in meter
event.travel_duration = leg['duration']['value'] # in second
print('event.travel_distance', event.travel_distance)
print('event.travel_duration', event.travel_duration)
event.save()
print('event.travel_duration', event.travel_duration)
return event
from googleplaces import GooglePlaces, types, lang
YOUR_API_KEY = 'AIzaSyC1D8hoFRIH1Mw_YArJUK2VO9B9LSoxs24'
google_places = GooglePlaces(YOUR_API_KEY)
# You may prefer to use the text_search API, instead.
print google_places.get_place("ChIJ7z5P2ikbdkgRJbLXb5y1uWs")
# print query_result
# if query_result.has_attributions:
# print query_result.html_attributions
# You may prefer to use the text_search API, instead.
query_result = google_places.nearby_search(
location='London, England', keyword='Fish and Chips',
radius=20000, types=[types.TYPE_FOOD])
print query_result
if query_result.has_attributions:
print query_result.html_attributions
for place in query_result.places:
# Returned places from a query are place summaries.
print place.name
print place.geo_location
print place.place_id
print location
placeName = location.address.split(',')
print "Printing the name of the place: " + placeName[0]
'''
#Find distance between two points
#Start
#loc1 = (37.7528679,-122.4185353)
##loc2 = (37.7528804, -122.4185364)
#print(great_circle(loc1, loc2).kilometers)
#End
#ChIJCVOWkMeAhYARS9aj9GhYuc8,ChIJ8aZslMeAhYARk2BJNvkVPyc,ChIJr3AblMeAhYARrtrGjPRtH3k
l =google_places.get_place(place_id = 'ChIJ6TRCEUN-j4ARj2bdLZOgsLA')
printable = set(string.printable)
print (filter(lambda x: x in printable, l.name))
#print l.name
#placeName2 = str(l.name.replace("\xce", "n"))
#print placeName2
#try:
# placeName1 = str(l.name.replace(",", ""))
#except:
#print "SDSDSD"
#name = l.name
#print "dfsdfsdfsd"
# place = l.name[:-1]
#print place
#print l.name.split("\\")[0].split("\\x")
def add_place(place_id):
API_KEY = "AIzaSyBM7aOj21cM0LyY07I0EDBSpTNwFrYxlfU"
google = GooglePlaces(API_KEY)
place_details = google.get_place(place_id=place_id)
# There is a chance the Places API produces an index error if some components are missing
# With the formatted address we do our best to find those missing parts if we encounter it
# We expect the formatted address to look like this; 1234 Foo Ln, FooBar, NJ 08005, USA
formatted_addr = place_details.details['formatted_address'].strip(
" ").split(",")
try:
# Street Addr from google Places API
addr = place_details.details['address_components'][0]['long_name'] + " " + \
place_details.details['address_components'][1]['long_name']
# City from google Places API
addr_city = place_details.details['address_components'][2][
'short_name']
# State short name 'XX' from google places API
addr_state = place_details.details['address_components'][5][
'short_name']
# Zip code from places API
addr_zip = place_details.details['address_components'][7]['long_name']
# Country from google places API
addr_country = place_details.details['address_components'][6][
'short_name']
# If we have an index error are indices are wrong so we need to use the formatted address
except IndexError:
addr = formatted_addr[0]
addr_city = formatted_addr[1].strip()
addr_state = formatted_addr[2][1:3].strip()
addr_zip = formatted_addr[2][4:9].strip()
addr_country = formatted_addr[3]
# International formatted phone number from google places API
phone_inter = place_details.details['international_phone_number']
# Franchise name from google places API
place_name = place_details.details['name']
new_place = Place(
gid=
place_id, # The place ID in this case would be a Google Places Reference ID
name=place_name,
phone=phone_inter, # TODO fix this need to DB
address=addr,
address_city=addr_city,
address_state=addr_state,
address_zip=addr_zip,
address_country=addr_country)
# TODO add try/except block for errors
db.session.add(new_place)
db.session.commit()
return new_place
def app_context():
with app.app_context():
query = Place.query.filter_by()
for x in query:
print(x.name)
# Google API Key for places
API_KEY = "AIzaSyBM7aOj21cM0LyY07I0EDBSpTNwFrYxlfU"
google = GooglePlaces(API_KEY)
# Try adding a new place.. ?
place_id = 'ChIJn8ORMaIIwYkRDjaLeuBXyN8'
place_details = google.get_place(place_id=place_id)
# print(place_details.details)
# Street Addr from google Places API
addr = place_details.details['address_components'][0]['long_name'] + " " + \
place_details.details['address_components'][1]['long_name']
print(addr)
# City from google Places API
addr_city = place_details.details['address_components'][2][
'short_name']
print(addr_city)
# State short name 'XX' from google places API
addr_state = place_details.details['address_components'][5][
'short_name']
print(addr_state)
# Zip code from places API
addr_zip = place_details.details['address_components'][7]['long_name']
print(addr_zip)
# Country from google places API
addr_country = place_details.details['address_components'][6][
'short_name']
print(addr_country)
# International formatted phone number from google places API
phone_inter = place_details.details['international_phone_number']
print(phone_inter)
# Franchise name from google places API
place_name = place_details.details['name']
print(place_name)
new_place = Place(
gid=
place_id, # The place ID in this case would be a Google Places Reference ID
name=place_name,
phone1="test",
address=addr,
address_city=addr_city,
address_state=addr_state,
address_zip=addr_zip,
address_country=addr_country)
# TODO add try/except block for errors
print('test1')
db.session.add(new_place)
db.session.commit()
# keyword='general',
# types =[types.TYPE_HOSPITAL] or
# [types.TYPE_CAFE] or [type.TYPE_BAR]
# or [type.TYPE_CASINO])
type=types.TYPE_POLICE)
# If any attributions related
# with search results print them
if query_result.has_attributions:
print(query_result.html_attributions)
placeID = ""
# Iterate over the search results
for place in query_result.places:
# print(type(place))
# place.get_details()
print(place.name)
print("Latitude", place.geo_location['lat'])
print("Longitude", place.geo_location['lng'])
placeID = place.place_id
print("id:", placeID)
# place.get_details()
# print(place)
print()
break
query_result2 = google_places.get_place(place_id=placeID, )
if query_result2.has_attributions:
print(query_result2.html_attributions)
class GoogleMapsProcessor(object):
def __init__(self):
self.google_places = GooglePlaces(settings.MAPS_API_KEY)
def search(self, keyword, latlng):
"""
Search Google Places for Businesses
"""
# You may prefer to use the text_search API, instead.
search_tokens = keyword.split(' ')
response = []
for token in search_tokens:
query_result = self.google_places.nearby_search(
lat_lng=latlng,
keyword=token,
radius=10000,
types=[
types.TYPE_AMUSEMENT_PARK,
types.TYPE_BAKERY,
types.TYPE_BAR,
types.TYPE_BOOK_STORE,
types.TYPE_CAFE,
types.TYPE_CLOTHING_STORE,
types.TYPE_CONVENIENCE_STORE,
types.TYPE_DEPARTMENT_STORE,
types.TYPE_FOOD,
types.TYPE_GROCERY_OR_SUPERMARKET,
types.TYPE_HARDWARE_STORE,
types.TYPE_HEALTH,
types.TYPE_HOME_GOODS_STORE,
types.TYPE_LIBRARY,
types.TYPE_LIQUOR_STORE,
types.TYPE_MEAL_DELIVERY,
types.TYPE_MEAL_TAKEAWAY,
types.TYPE_MOVIE_THEATER,
types.TYPE_MUSEUM,
types.TYPE_NIGHT_CLUB,
types.TYPE_PARK,
types.TYPE_PHARMACY,
types.TYPE_RESTAURANT,
types.TYPE_SHOE_STORE,
types.TYPE_SHOPPING_MALL,
types.TYPE_STORE,
])
for place in query_result.places:
# Returned places from a query are place summaries.
cache = {}
place.get_details()
cache['id'] = place.place_id
cache['name'] = place.name
cache['address'] = place.formatted_address
cache['website'] = place.website
cache['phone'] = place.local_phone_number
cache['lat'] = float(place.geo_location.get('lat'))
cache['lng'] = float(place.geo_location.get('lng'))
cache['rating'] = place.rating
cache['types'] = place.types[0] if len(
place.types) > 0 else 'Others'
for photo in place.photos:
photo.get(maxheight=800, maxwidth=533)
cache['photo'] = photo.url
break
response.append(cache)
return response
"""
Search Expedia Hotels
"""
def search_by_text(self, name, lat, lng):
latlng = {'lat': lat, 'lng': lng}
query_result = self.google_places.text_search(
lat_lng=latlng,
query=name,
radius=10,
types=[
types.TYPE_AMUSEMENT_PARK,
types.TYPE_BAKERY,
types.TYPE_BAR,
types.TYPE_BOOK_STORE,
types.TYPE_CAFE,
types.TYPE_CLOTHING_STORE,
types.TYPE_CONVENIENCE_STORE,
types.TYPE_DEPARTMENT_STORE,
types.TYPE_FOOD,
types.TYPE_GROCERY_OR_SUPERMARKET,
types.TYPE_HARDWARE_STORE,
types.TYPE_HEALTH,
types.TYPE_HOME_GOODS_STORE,
types.TYPE_LIBRARY,
types.TYPE_LIQUOR_STORE,
types.TYPE_MEAL_DELIVERY,
types.TYPE_MEAL_TAKEAWAY,
types.TYPE_MOVIE_THEATER,
types.TYPE_MUSEUM,
types.TYPE_NIGHT_CLUB,
types.TYPE_PARK,
types.TYPE_PHARMACY,
types.TYPE_RESTAURANT,
types.TYPE_SHOE_STORE,
types.TYPE_SHOPPING_MALL,
types.TYPE_STORE,
])
return query_result
def get_place(self, place_id):
place = self.google_places.get_place(place_id)
cache = {}
place.get_details()
details = place.details
detail_keys = details.keys()
# Get Reviews
cache['reviews'] = []
if 'reviews' in detail_keys:
result = []
for review in details['reviews']:
cache = {}
cache['rating'] = review.get('rating')
cache['rating_range'] = range(int(
review.get('rating'))) if review.get('rating') else 0
cache['photo'] = review.get('profile_photo_url')
cache['text'] = review.get('text')
cache['name'] = review.get('author_name')
cache['time'] = review.get('time')
result.append(cache)
cache['reviews'] = result
cache['review_count'] = len(cache['reviews'])
cache['id'] = place.place_id
cache['name'] = place.name
cache['address'] = place.formatted_address
cache['website'] = place.website
cache['phone'] = place.local_phone_number
cache['vicinity'] = place.vicinity
cache['lat'] = float(place.geo_location.get('lat'))
cache['lng'] = float(place.geo_location.get('lng'))
cache['rating'] = place.rating
cache['rating_range'] = range(int(place.rating)) if place.rating else 0
cache['types'] = place.types[0] if len(place.types) > 0 else 'Others'
cache['photos'] = []
for photo in place.photos:
photo.get(maxheight=1400, maxwidth=470)
cache['banner'] = photo.url
break
for photo in place.photos:
photo.get(maxheight=800, maxwidth=533)
cache['photos'].append(photo.url)
return cache
import webbrowser
import requests
import json
from openpyxl import Workbook
# ChIJm5MaboqXyzsR-xPxquRpWss
API_KEY = 'AIzaSyBGBT5ghLBk8nGYDxf6RfMxuNb8P7ojnDg'
from googleplaces import GooglePlaces, types, lang
google_places = GooglePlaces(API_KEY)
pid = input("Enter Place ID: ")
xmlfile = google_places.get_place(place_id=pid)
url = "https://maps.googleapis.com/maps/api/place/details/json?place_id=" + pid + "&fields=name,rating,review&key=" + API_KEY
# webbrowser.open_new(url=url)
response = requests.get(url)
with open('main.json', 'wb') as file:
file.write(response.content)
with open('main.json', 'rb') as file:
string = json.load(file)
webpage = string["result"]
reviews = string["result"]["reviews"]
name = string["result"]["name"]
rating = string["result"]["rating"]
workbook = Workbook()
sheet = workbook.active
from googleplaces import GooglePlaces, types, lang
import googlemaps
YOUR_API_KEY = 'AIzaSyC9a-jaBIbXokxx9dIz7aTP9jbOjLCC9ag'
gmaps = googlemaps.Client(key='AIzaSyC9a-jaBIbXokxx9dIz7aTP9jbOjLCC9ag')
google_places = GooglePlaces(YOUR_API_KEY)
print(
google_places.get_place(
place_id=
'qgYvCi0wMDAwMDBjNmVlMjk0ZDM0OjQwYzdlZGFiNjQzOmZlZmZhOWMyNzMzZDUwMzI'))
#google_places.delete_place(place_id='qgYvCi0wMDAwMDBjNmVlMjk0ZDM0OjQwZDRjZTgyYWFmOjRmZDhlMDg4YTc5NTE1MGM')
# set default values
place = 'ABC123'
google_places_array.at[i, 'lat'] = -1
google_places_array.at[i, 'long'] = -1
google_places_array.at[i, 'type'] = 'XXXXX'
google_places_array.at[i, 'rating'] = -1
# print(addr)
# print(geocode_result[0]['geometry']['location']['lat'])
# print(geocode_result[0]['geometry']['location']['lng'])
try:
addr = google_places_array.fulladdress[i]
geocode_result = gmaps.geocode(addr)
place = geocode_result[0]['place_id'] # need to trap this error
query_result = google_places.get_place(place_id=place)
query_result.get_details()
#print (query_result.types)
google_places_array.at[
i, 'lat'] = geocode_result[0]['geometry']['location']['lat']
google_places_array.at[
i, 'long'] = geocode_result[0]['geometry']['location']['lng']
google_places_array.at[i, 'type'] = query_result.types
google_places_array.at[i, 'rating'] = query_result.rating
#print('detail name')
#print (query_result.name)
# print(query_result.rating)
# print('\r')
except:
print("An error")
print(counter)
