def setUp(self):
self.key = "AIzaasdf"
self.client = googlemaps.Client(self.key)
waypoint_data = pd.read_csv(file_path, sep="\t")
for i, row in waypoint_data.iterrows():
waypoint_distances[frozenset([row.waypoint1,
row.waypoint2])] = row.distance_m
waypoint_durations[frozenset([row.waypoint1,
row.waypoint2])] = row.duration_s
all_waypoints.update([row.waypoint1, row.waypoint2])
else:
#file does not exist - compute results
print "Collecting Waypoints"
waypoint_distances = {}
waypoint_durations = {}
gmaps = googlemaps.Client(GOOGLE_MAPS_API_KEY)
for (waypoint1, waypoint2) in combinations(all_waypoints, 2):
try:
route = gmaps.distance_matrix(origins=[waypoint1],
destinations=[waypoint2],
mode="driving",
language="English",
units="metric")
# "distance" is in meters
distance = route["rows"][0]["elements"][0]["distance"]["value"]
# "duration" is in seconds
duration = route["rows"][0]["elements"][0]["duration"]["value"]
waypoint_distances[frozenset([waypoint1, waypoint2])] = distance
# Define api key (automatically get or filled by yourself, see below)
# from GoogleMapsAPIKey import get_my_key
# API_Key = get_my_key()
# ==========================================================
# ==========================================================
# Fill YOUR key get from Google (might change in the future)
API_Key = 'AIzaSyCceg_U0TSY0sASEeVcPV3WXw0NDYHL0j4'
# ==========================================================
# ==========================================================
app = Flask(__name__, template_folder=".")
# Define our client
gmaps = googlemaps.Client(key=API_Key)
# Locate the region (we "FIXED" 40km around JHU here)
location = '39.3299013,-76.6227064' # coordinate of Johns Hopkins University, Homewood Campus
radius = 40000 # units: meters
# Initialize a set to store types supported by Google Places API
# See documentations in this link (https://developers.google.com/places/web-service/supported_types)
types_set = {
"accounting", "airport", "amusement_park", "aquarium", "art_gallery",
"atm", "bakery", "bank", "bar", "beauty_salon", "bicycle_store",
"book_store", "bowling_alley", "bus_station", "cafe", "campground",
"car_dealer", "car_rental", "car_repair", "car_wash", "casino", "cemetery",
"church", "city_hall", "clothing_store", "convenience_store", "courthouse",
"dentist", "department_store", "doctor", "drugstore", "electrician",
"electronics_store", "embassy", "fire_station", "florist", "funeral_home",
# Retrieve the road distance from a start and end point
# Using Google's Distance Matrix API
import googlemaps
import config as cfg
gmaps_key = cfg.google['places_key']
gmaps = googlemaps.Client(key=gmaps_key)
def estimate(origin, destination):
origin_id = 'place_id:' + origin
destination_id = 'place_id:' + destination
distance_estimate = gmaps.distance_matrix(
origins=origin_id,
destinations=destination_id,
mode='driving'
)
# print(distance_estimate)
status = distance_estimate['rows'][0]['elements'][0]['status']
# print(status)
if status == 'ZERO_RESULTS':
return 0
else:
return distance_estimate['rows'][0]['elements'][0]
import smartcar
import googlemaps
from flask import Flask, redirect, request, jsonify, render_template, session
from flask_cors import CORS
from task import Task
from helpers import getVehicleFromId, getAddress, getTime, getDistance, getTimeAt
from datetime import datetime
import time
import os
app = Flask(__name__)
CORS(app)
app.secret_key = 'smartcar'
gmaps = googlemaps.Client(key='AIzaSyChhIkfCNJqOM7QYsBeQmOeG3LKE74RQa4')
start_coords = (43.663040, -79.398010)
# global variable to save our access_token
# access = None
print(os.environ.get('REDIRECT_URI'))
client = smartcar.AuthClient(client_id=os.environ.get('CLIENT_ID'),
client_secret=os.environ.get('CLIENT_SECRET'),
redirect_uri=os.environ.get('REDIRECT_URI'),
scope=[
'read_vehicle_info', 'read_location',
'read_odometer', 'control_security',
'control_security:unlock',
'control_security:lock'
],
test_mode=True)
import googlemaps
gmaps = googlemaps.Client(key='AIzaSyCJ2GhgOOCaoypV0JCC4NnxS-M0enWpN64')
reverse_geocode_result = gmaps.reverse_geocode((34.852733, -82.3915677))
print(reverse_geocode_result[0]['formatted_address'])
#####################################################################################
geocode_result = gmaps.geocode("650 N Academy St, Greenville, SC 29601, USA")
print(geocode_result[0]['geometry']['location'])
import agate
import agateremote
import googlemaps
import datetime
gmaps = googlemaps.Client(key='AIzaSyASamO-yIbsV9Ml6ySteFK12XD2xbleTHU')
def load_year_killed_data(year):
specified_types = {
'killed': agate.Number(),
'injured': agate.Number(),
'date_hour': agate.Text()
}
return agate.Table.from_url('https://s3.amazonaws.com/traffic-sd/accidents_killed_{}.csv'.format(year), column_types=specified_types)
def load_last_fatality():
return agate.Table.from_url('https://s3.amazonaws.com/traffic-sd/last_fatality.csv')
def load_last_collision():
return agate.Table.from_url('https://s3.amazonaws.com/traffic-sd/last_collision.csv')
def load_data(data):
data['table'] = agate.Table.from_url('http://seshat.datasd.org/pd/pd_collisions_datasd.csv')
return data
def load_all_data_by_year(year):
data = {}
data = load_data(data)
data = add_year_column(data)
return data['table'].where(lambda r: r['year'] == str(year))
def get_graph_from_csv(file_path):
mdg = nx.DiGraph()
gmaps = googlemaps.Client(key='AIzaSyBabsATfHAXSihzTwbxTjV9Jqh3MrmZVHs')
with open(file_path, 'r') as f:
header_line = f.readline()
header = {}
for head in header_line.split(','):
header[head] = len(header)
f.readline() # empty line
for data_line in f:
try:
data = data_line.split(',')
pickup_longitude = float(data[header['pickup_longitude']])
pickup_latitude = float(data[header['pickup_latitude']])
dropoff_longitude = float(data[header['dropoff_longitude']])
dropoff_latitude = float(data[header['dropoff_latitude']])
if not (-80.0 < pickup_longitude < -70.0) or \
not (35.0 < pickup_latitude < 45.0) or \
not (-80.0 < dropoff_longitude < -70.0) or \
not (35.0 < dropoff_latitude < 45.0):
# print('Skipping line due to strange geo: ' + str(pickup_longitude) + ' '
# + str(pickup_latitude) + ' '
# + str(dropoff_longitude) + ' '
# + str(dropoff_latitude) + ' ')
continue
if False: # True - use Google; False - hash lat and lng
startPointResponce = gmaps.reverse_geocode(
(pickup_latitude, pickup_longitude))
endPointResponce = gmaps.reverse_geocode(
(dropoff_latitude, dropoff_longitude))
startPointData = next(iter(startPointResponce), None)
endPointData = next(iter(endPointResponce), None)
startPointPlaceId = startPointData['place_id']
endPointPlaceId = endPointData['place_id']
else:
def my_hash(lat, lng):
precision = 3
lat_int = int(
round(abs(lat), precision) * 10**precision)
lng_int = int(
round(abs(lng), precision) * 10**precision)
hashed = int(str(lng_int) + str(lat_int))
return hashed
startPointPlaceId = my_hash(pickup_latitude,
pickup_longitude)
endPointPlaceId = my_hash(dropoff_latitude,
dropoff_longitude)
if mdg.has_edge(startPointPlaceId, endPointPlaceId):
mdg[startPointPlaceId][endPointPlaceId]['weight'] += 1
else:
mdg.add_edge(startPointPlaceId, endPointPlaceId)
mdg[startPointPlaceId][endPointPlaceId]['weight'] = 1
except ValueError:
print("Bad line: " + data_line)
return mdg
# -*- coding: utf-8 -*-
"""However, We found google API charges when there are more than 2500 elements per day. Therefore
we will use R to calculate to distance
"""
import googlemaps
file = open("INFM600_0201_Fabulous_distance.txt")
result = open("IFNM600_result.txt", "w")
google_api = "AIzaSyDfkpkSBEkcJCk4mGTQ19feimIwm-wh5Vc"
gmaps = googlemaps.Client(key=google_api)
x = gmaps.distance_matrix('New York City', 'Chicago')
for line in file:
line = line.rstrip()
llist = line.split()
startLat = llist[2]
startLong = llist[3]
endLat = llist[5]
endLong = llist[6]
start = startLat + "," + startLong
end = endLat + "," + endLong
gmaps = googlemaps.Client(key=google_api)
x = gmaps.distance_matrix(start, end)
for each in x['rows']:
a = each['elements'][0]
b = a['distance']
distance = b['value']
import foursquare
import csv
import sys
import subprocess
import googlemaps
from foursquare_secrets import client_id, client_secret
gmaps = googlemaps.Client(key='AIzaSyDSbRjoLe-fnM_NLiQz_yscPNXoEx05vtw')
def get_coordinates(address):
results = gmaps.geocode(address)
location = results[0]['geometry']['location']
return [location['lat'], location['lng']]
# parse command line args
if len(sys.argv) != 2:
print '''
Incorrect number of arguments - first argument should be the city name, and the second argument should be the id of the city
e.g. `python importer.py "London, UK"
'''
sys.exit(2)
[_, CITY_NAME] = sys.argv
# geocode the city to get the coordinates
[LAT, LNG] = get_coordinates(CITY_NAME)
# run command to create new city
template_command = """mix CreateCity "{CITY_NAME}" {LAT} {LNG} | grep 'NEW-CITY-ID' | cut -d "'" -f 2"""
CITY_ID = int(
if indicator_list[i] == '0': # things to do
places.append(x_coord_list[i] + "," + y_coord_list[i])
pid[(x_coord_list[i], y_coord_list[i])] = pid_list[i]
duration.append(60)
else:
restaurants.append(x_coord_list[i] + "," + y_coord_list[i])
pid[(x_coord_list[i], y_coord_list[i])] = pid_list[i]
duration.append(30)
# places = ["40.109760744757,-88.227207813792", "310 E Springfield Ave, Champaign, IL",
# "406 E Green St, Champaign, IL", "509 E Green St, Champaign, IL",
# "1401 W Green St, Urbana, IL", "301 N Neil St, Champaign, IL"]
#
# restaurants = ["320 N Chestnut St, Champaign, IL", "60 E Green St, Champaign, IL", "410 E Green St, Champaign, IL", "1214 W University Ave, Urbana, IL"]
gmaps = gm.Client(key="AIzaSyDRj-IVV1g8aqKOZZiRXyHP4CURyFQg4PQ")
result = gmaps.distance_matrix(places, restaurants, mode="walking")
place_to_rest = []
place_to_rest_time = []
dist_list = result['rows']
for li in dist_list:
rest = []
time = []
for dist in li['elements']:
if (dist['distance']['text'].split(" ")[1] == 'm'):
rest.append(
float(dist['distance']['text'].split(" ")[0]) / 1000)
time.append(int(dist['duration']['text'].split(" ")[0]))
else:
rest.append(float(dist['distance']['text'].split(" ")[0]))
time.append(int(dist['duration']['text'].split(" ")[0]))
async def extract_lat_long_via_address(self, ctx, *args):
try:
# First error check - indicating the user to be more specific so that the search works.
if (len(args) < 2):
embed = discord.Embed(title="Nearby Places", color=0xf2680c)
embed.add_field(
name="Error",
value=
"Please input the command -places followed by a SPACE and the address as specifically as you can. E.G. -places Kaivokatu 1, Helsinki, Finland. This ensures that you get as accurate information as possible.",
inline=False)
# Sending error message.
await ctx.channel.send(embed=embed)
else:
# Splitting the "-places" start-predicative from the actual wanted String.
address_initial = ' '.join(args)
# Replacing unwanted characters.
address_initial = address_initial.replace("ä", "a")
# Replacing unwanted characters.
address_initial = address_initial.replace("ö", "o")
# Splitting the string given, only the address-part remains. E.G. -places Marsinkuja 1, Vantaa => "Marsinkuja 1, Vantaa".
addressForReplacement = address_initial
# Error checking for the below IF-clause.
#address_error_check = addressForReplacement.split(" ")
if (len(args) < 2 or len(args) < 1):
embed = discord.Embed(title="Nearby Places",
color=0xf2680c)
embed.add_field(
name="Error",
value=
"Please input the command -places followed by a SPACE and the address as specifically as you can. E.G. -places Kaivokatu 1, Helsinki, Finland. This ensures that you get as accurate information as possible.",
inline=False)
await ctx.channel.send(embed=embed)
else:
# Replacing every SPACE string with another string that indicates space. Replace() -function, built-in with Python.
address = addressForReplacement.replace(" ", "%20")
url = "https://www.mapquestapi.com/geocoding/v1/address?key=" + api_key + \
"&inFormat=kvp&outFormat=json&location=" + address + "&thumbMaps=false"
# Opening and reading and converting to JSON the coordinates-dict with location attributes.
with urllib.request.urlopen(url) as response:
html = response.read()
# Loads the whole datapoint as JSON.
data = json.loads(html)
# Setting the desired coordinates from the JSON-output.
coordLat = data["results"][0]["locations"][0]["latLng"][
"lat"]
coordLng = data["results"][0]["locations"][0]["latLng"][
"lng"]
# Getting the google platform key
gmaps = googlemaps.Client(key=GOOGLE_API_KEY)
# Google maps own dictionary methods and places find
# Using the desired coordinates with gmaps-API. Making int to String conversion for the URL so that it is not N/A.
places_result = gmaps.places_nearby(
location=str(coordLat) + "," + str(coordLng),
radius=1000,
open_now=False,
type="restaurant")
print(places_result)
# Bot message awakening and later on adding the address
# Opening the list and checking if there are any results - no ERRORS are given when there are no places, THUS creating an informative output.
if (len(places_result["results"]) <= 0):
embed = discord.Embed(title="Nearby Places",
color=0xf2680c)
embed.add_field(
name="Error",
value=
"Could not find any nearby places. Maybe be more specific? Please input the command -places followed by a SPACE and the address as specifically as you can. E.G. -places Kaivokatu 1, Helsinki, Finland. This ensures that you get as accurate information as possible.",
inline=False)
await ctx.channel.send(embed=embed)
else:
# Limiting the results to 7 from the desired list...
for place in places_result['results'][:5]:
# ... These are within 1 km of the desired address. 20 places is the default - too much SPAM on the user's part.
# naming place id
my_place_id = place['place_id']
# naming fields that we want to be seen from the json list
my_fields = [
'name', 'formatted_address',
'formatted_phone_number'
]
# goooglemaps' own method for place find with my_fields and place_id
place_details = gmaps.place(place_id=my_place_id,
fields=my_fields)
# discords own embed style for clean message
embed = discord.Embed(color=0xf2680c,
title="Places: ")
embed.add_field(
name="Name: ",
value=place_details['result']['name'],
inline=True)
embed.add_field(name="Address: ",
value=place_details["result"]
["formatted_address"],
inline=True)
# Correcting Keyerrors
try:
embed.add_field(name="Phone number: ",
value=place_details["result"]
['formatted_phone_number'],
inline=True)
except KeyError:
embed.add_field(name="Phone number: ",
value="No number",
inline=True)
# Sending places to discord bot
await ctx.channel.send(embed=embed)
except: # ERROR checking. The last resort. Cacthes anything that went by the above ERROR checks.
embed = discord.Embed(title="Nearby Places", color=0xf2680c)
embed.add_field(
name="Error",
value=
"Please input the command -places followed by a SPACE and the address as specifically as you can. E.G. -places Kaivokatu 1, Helsinki, Finland. This ensures that you get as accurate information as possible.",
inline=False)
import googlemaps
import json
import string
import time
gmaps = googlemaps.Client(key='KEY') #@@@@@@@@REPLACE WITH API KEY!!!!@@@@@
s_num = 1 #step number
origin = None
print(
"For input below please follow the format: City, State Code /n Example: Boston, MA"
)
if origin == None:
origin = input("Enter a place of origin:")
#if ("," not in origin): google client accepts other formats
#origin = input("Enter a place of origin following format above:")
destination = None
if destination == None:
destination = input("Please enter the city would you like directions to:")
#if ("," not in destination): google client accepts other formats
#origin = input("Where you would like to go? Please follow format above:")
trans_mode = ""
while trans_mode.lower() != "driving" and trans_mode.lower(
) != "bicycling" and trans_mode.lower() != "walking" and trans_mode.lower(
) != "transit":
print(
"Please enter ond of the following options below: Driving, Bicycling, Walking, or Transit"
)
trans_mode = input("Preferred mode of transprotation from above:").lower()
#goog_directions = "https://maps.googleapis.com/maps/api/directions/json?origin=Boston,+MA&destination=Santa+Carla,+CA&mode=driving&key=AIzaSyAg1ZGxNcWd_pefV6ZG3i_uJ30g-5TTY5c"
#directions from link used for reference to loate items in googlemaps library module
google_directions = gmaps.directions(origin,
with open(csv_name, newline='') as csvfile:
reader = csv.reader(csvfile, delimiter=';')
i = 0
for value, row in enumerate(reader, 1):
if (i != 0):
address = row[2] + ", " + row[3]
result = gmaps.geocode(address)
filewriter.writerow([
row[0], result[0]["geometry"]["location"]["lat"],
result[0]["geometry"]["location"]["lng"]
])
elif (i == 0):
i += 1
#_________________________________________________________________________________
gmaps = googlemaps.Client(key='YOUR KEY')
with open('dataset/coordinates.csv', 'w') as csvfile:
filewriter = csv.writer(csvfile,
delimiter=';',
quotechar='|',
quoting=csv.QUOTE_MINIMAL)
filewriter.writerow(["URL", "LAT", "LON"])
hotel_csv = 'dataset/HOTEL BARI E PROVINCIA.csv'
restaurants_csv = 'dataset/RISTORANTI BARI E PROVINCIA.csv'
places_csv = 'dataset/LUOGHI D_INTERESSE BARI E PROVINCIA.csv'
getCoordinates(gmaps, hotel_csv, filewriter)
getCoordinates(gmaps, restaurants_csv, filewriter)
getCoordinates(gmaps, places_csv, filewriter)
import pandas as pd
import googlemaps
from pprint import pprint
from glmTf import googleUClientCreater
dt_bs = pd.read_csv('data/map_states_in_taipei_copy_NaN.csv')
dt_bs
# dt_bs.to_csv('data/incorrect.csv')
dt_bs[~dt_bs['dist'].isnull()].to_csv("data/map_states_in_taipei_clean_complete.csv")
key = 'AIzaSyDmjTq17LmNHYeoWhf5R57QsxqM92bvaaE'
gms = googlemaps.Client(key=key)
number = 843
dt_bs.iloc[number]['center']
point = (24.985530052272686, 121.61951637420566)
test_res = gms.reverse_geocode(point,language='zh-TW')
pprint(test_res)
political_1 = test_res[0]['address_components'][3]['long_name']
political_2 = test_res[0]['address_components'][2]['long_name']
print(political_1,political_2)
dt_bs.loc[number,'dist'] = '深坑區'
dt_bs.loc[number,'vil'] = '阿柔里'
dt_bs.iloc[number]
# DROP
dt_bs = dt_bs.drop([356],axis=0)
# OUTPUT FILE
# -*- coding: utf-8 -*-
"""
Created on Mon Feb 15 18:25:48 2016
@author: kameelperd64
"""
import googlemaps
gmaps = googlemaps.Client('AIzaSyATRIUPX1HUczj6VZwrEdPmG62ufZG1cpI')
class Node:
def __init__(self, value, parent, loc, children=[]):
self.value = value
self.children = children
self.parent = parent
self.loc = loc
self.shortest = 0
def Build(node, loc=[]):
node.children = []
for location in loc:
node2 = node
while 1 == 1:
if node2 == None:
dist = node.value + getDist(node.loc, location)
node.children.append(Node(dist, node, location))
break
if (node2.loc == location):
break
node2 = node2.parent
import googlemaps
import csv
from selenium import webdriver
from time import sleep
from urllib.request import urlopen #for load web page
from bs4 import BeautifulSoup #for analysis web page
gmaps = googlemaps.Client(key='AIzaSyCvmftDhP4yEN-as8P7pYiT-fwwIjpRhpI')
class MovieTheater:
def __init__(self):
f = open('movietheater.csv', 'r')
csvreader = csv.reader(f)
self.allData = []
self.timetable = {}
for row in csvreader:
self.allData.append(row)
f.close()
def getTheaterInformation(self, theatername):
ans = {}
for i in range(len(self.allData)):
if self.allData[i][0] == theatername:
ans['addr'] = self.allData[i][1]
ans['phone'] = self.allData[i][2]
if i <= 12:
ans['url'] = 'https://www.vscinemas.com.tw/'
elif 12 < i <= 24:
ans['url'] = 'http://www.ambassador.com.tw/'
else:
import googlemaps
import sys
gm = googlemaps.Client(key="AIzaSyAdBrRjT1naXA3PbjKcMyZU1WP0SIoFvCU")
def getLocation(address_string):
coords = gm.geocode(address_string)
lat = coords[0]['geometry']['location']['lat']
lon = coords[0]['geometry']['location']['lng']
return lat, lon
if __name__ == "__main__":
query = sys.argv[1]
x = getLocation(query)
print x
import googlemaps
from googlemaps import places
from tools.json_to_yaml import write_yaml
gmaps = googlemaps.Client(key='AIzaSyCWOSz0D-dfNnfv7FJh6pP3dghHM9NmyuQ')
" https://maps.googleapis.com/maps/api/place/nearbysearch/json?location=-33.8670522,151.1957362&radius=1500&type=restaurant&keyword=cruise&key=AIzaSyCWOSz0D-dfNnfv7FJh6pP3dghHM9NmyuQ"
# Geocoding an address
geocode_result = places.places_nearby(gmaps,
location='-33.8670522,151.1957362',
radius=1500,
type='restaurant',
keyword='cruise')
write_yaml(geocode_result, 'nearbysearch_result.yaml')
def __init__(self, api_id):
self.KEY = api_id
self.gmaps = googlemaps.Client(key=self.KEY)
self.result = None
def create_gmaps(self):
gmaps = googlemaps.Client(key='...')
# print(gmaps.geocode('서울중부경찰서', language='ko'))
return gmaps
import pandas as pd
import googlemaps
import sys
gcp_key = open('gcp.key', 'r').read()
gmaps = googlemaps.Client(key=gcp_key)
filename = 'l_city_market_id.csv'
df = pd.read_csv('../data/lookups/' + filename)
df = df.sample(n=600)
lookup = {}
def get_gmaps_info(s):
g = gmaps.geocode(s)[0]['geometry']['location']
timezone = gmaps.timezone((g['lat'], g['lng']))
g.update({
'rawOffset': timezone['rawOffset'],
'timeZoneName': timezone['timeZoneName']
})
return g
i = 0
for index, row in df.iterrows():
try:
lookup[int(row['Code'])] = get_gmaps_info(row['Description'])
i += 1
print "%d / 600" % i
from flask import Flask, render_template, request, jsonify
import requests
import json
from twilio.rest import Client
import googlemaps
account_sid = "AC6b46e74d4a54465a3e4fc824849d121a"
auth_token = "e4ef218b04c5f93d7eba8b17a94ba1c3"
api_key = "AIzaSyBRl0KG9bvh6DD4kGVoTqM2aRLfjw40VNk"
gmaps = googlemaps.Client(key=api_key)
app = Flask(__name__)
@app.route('/')
def index():
return render_template('form.html')
@app.route('/process', methods=['POST', 'GET'])
def process():
if request.method == 'POST':
email = request.form['email']
name = request.form['name']
client = Client(account_sid, auth_token)
message = client.messages.create(
to = "+91" + str(email),
from_="+13346002011",
body = str(name) + " Ticket has been Booked! QR Code " )
data = "OTP has been sent to " + str(email);
])
layout = Layout(
autosize=True,
hovermode='closest',
mapbox=dict(
accesstoken=mapbox_access_token,
bearing=0,
style='streets',
center=dict(
lat=np.mean([float(step[0]) for step in steps]),
lon=np.mean([float(step[1]) for step in steps]),
),
pitch=0,
zoom=zoom
),
)
fig = dict(data=data, layout=layout)
return fig
gmap_api_key = 'AIzaSyCpKt7PVTMeHKPOODBwS3fx3ZJneCNG_w0'
gmaps = googlemaps.Client(gmap_api_key)
address_start = '55 Parsonage Rd.'
address_end = '150th Ave and 147th St'
zoom=12.2
endpt_size=20
fig = plot_route_between_tesla_stations(address_start, address_end, zoom=12.2, endpt_size=20)
py.iplot(fig, filename='tesla-driving-directions-between-superchargers')
client = gspread.authorize(creds)
sheet = client.open('Thane_travel_data').sheet1
eef_lat = [
18.952563, 18.909179, 18.956634, 18.981705, 19.017676, 19.142981, 19.21418,
19.267896
]
eef_long = [
72.960334, 72.986411, 73.036789, 73.088119, 73.106271, 73.046689,
73.012196, 73.080997
]
timestamp = time.strftime('%H:%M')
present_time = time.time()
gmaps = googlemaps.Client(key='AIzaSyBVd5uRVv5gGyvs8Zh9nDWVV96rCVU7LvI')
i = int(sheet.cell(189, 2).value)
for x in range(0, 7):
origins = (eef_lat[x], eef_long[x])
destinations = (eef_lat[x + 1], eef_long[x + 1])
my_distance = gmaps.distance_matrix(origins,
destinations,
departure_time=present_time)
live_data = my_distance['rows'][0]['elements'][0]['duration_in_traffic'][
'text']
sheet.update_cell(i + 2, x + 2, live_data)
sheet.update_cell(i + 2, 1, timestamp)
i = i + 1
def lockin():
if request.method == 'POST':
# Variable used to search for a manual price
priceOveride = False
# Get the form submission method
submissionMethod = request.form['submit']
# If we didn't try to confirm a manual price
if(submissionMethod != "confirm_price"):
# Get the fuel type we want
fuelType = str(request.form['fueltype'])
session['fuelType'] = fuelType
# Clear previous messages
session.pop('ErrorMessage', None)
session.pop('SuccessMessage', None)
# Get the postcode and price of the cheapest fuel
locationResult = functions.cheapestFuel(fuelType)
# They tried to do something different from the manual and automatic form, so throw up an error
if(submissionMethod != "manual" and submissionMethod != "automatic"):
session['ErrorMessage'] = "Invalid form submission. Either use the manual or automatic one on the main page."
return redirect(url_for('index'))
# If they have manually chosen a postcode/suburb set the price overide to true
if(submissionMethod == "manual"):
postcode = str(request.form['postcode'])
priceOveride = True
# Get the latitude and longitude from the store
storeLatLng = functions.getStoreAddress(postcode)
# If we have a match, set the coordinates. If we don't, use Google Maps
if (storeLatLng):
locLat = float(storeLatLng[0])
locLat += (random.uniform(0.01,0.000001) * random.choice([-1,1]))
locLong = float(storeLatLng[1])
locLong += (random.uniform(0.01,0.000001) * random.choice([-1,1]))
else:
# If we have entered the wrong manual postcode for a store, and haven't
# set the Google Maps API, return an error since we cant use the API
if not custom_coords:
# If it is, get the error message and return back to the index
session['ErrorMessage'] = "Error: You entered a manual postcode where no 7-Eleven store is. Please set a Google Maps API key or enter a valid postcode."
return redirect(url_for('index'))
# Initiate the Google Maps API
gmaps = googlemaps.Client(key = API_KEY)
# Get the longitude and latitude from the submitted postcode
geocode_result = gmaps.geocode(str(request.form['postcode']) + ', Australia')
locLat = geocode_result[0]['geometry']['location']['lat']
locLong = geocode_result[0]['geometry']['location']['lng']
else:
# It was an automatic submission so we will now get the coordinates of the store
# and add a random value to it so we don't appear to lock in from the service station
locLat = locationResult[2]
locLat += (random.uniform(0.01,0.000001) * random.choice([-1,1]))
locLong = locationResult[3]
locLong += (random.uniform(0.01,0.000001) * random.choice([-1,1]))
# The payload to start the lock in process.
payload = '{"LastStoreUpdateTimestamp":' + str(int(time.time())) + ',"Latitude":"' + str(locLat) + '","Longitude":"' + str(locLong) + '"}'
tssa = functions.generateTssa(functions.BASE_URL + "FuelLock/StartSession", "POST", payload, session['accessToken'])
# Now we start the request header
headers = {'User-Agent':'Apache-HttpClient/UNAVAILABLE (java 1.4)',
'Authorization':'%s' % tssa,
'X-OsVersion':functions.OS_VERSION,
'X-OsName':'Android',
'X-DeviceID':session['DEVICE_ID'],
'X-VmobID':functions.des_encrypt_string(session['DEVICE_ID']),
'X-AppVersion':functions.APP_VERSION,
'X-DeviceSecret':session['deviceSecret'],
'Content-Type':'application/json; charset=utf-8'}
# Send the request
response = requests.post(functions.BASE_URL + "FuelLock/StartSession", data=payload, headers=headers)
# Get the response content so we can check the fuel price
returnContent = response.content
# Move the response json into an array so we can read it
returnContent = json.loads(returnContent.decode('utf-8'))
# If there is a fuel lock already in place we get an error!
try:
if returnContent['ErrorType'] == 0:
session['ErrorMessage'] = "An error has occured. This is most likely due to a fuel lock already being in place."
return redirect(url_for('index'))
except:
pass
# Get the fuel price of all the types of fuel
for each in returnContent['CheapestFuelTypeStores']:
x = each['FuelPrices']
for i in x:
if(str(i['Ean']) == fuelType):
LockinPrice = i['Price']
session['LockinPrice'] = LockinPrice
# If we have performed an automatic search we run the lowest price check
# LockinPrice = the price from the 7/11 website
# locationResult[1] = the price from the master131 script
# If the price that we tried to lock in is more expensive than scripts price, we return an error
if not(priceOveride):
if not(float(LockinPrice) <= float(locationResult[1])):
session['ErrorMessage'] = "The fuel price is too high compared to the cheapest available. The cheapest we found was at " + locationResult[0] + ". Try locking in there!"
return redirect(url_for('index'))
if(priceOveride):
return redirect(url_for('confirm'))
# Now we want to lock in the maximum litres we can.
NumberOfLitres = int(float(session['cardBalance']) / session['LockinPrice'] * 100)
# Lets start the actual lock in process
payload = '{"AccountId":"' + session['accountID'] + '","FuelType":"' + session['fuelType'] + '","NumberOfLitres":"' + str(NumberOfLitres) + '"}'
tssa = functions.generateTssa(functions.BASE_URL + "FuelLock/Confirm", "POST", payload, session['accessToken'])
headers = {'User-Agent':'Apache-HttpClient/UNAVAILABLE (java 1.4)',
'Authorization':'%s' % tssa,
'X-OsVersion':functions.OS_VERSION,
'X-OsName':'Android',
'X-DeviceID':session['DEVICE_ID'],
'X-VmobID':functions.des_encrypt_string(session['DEVICE_ID']),
'X-AppVersion':functions.APP_VERSION,
'X-DeviceSecret':session['deviceSecret'],
'Content-Type':'application/json; charset=utf-8'}
# Send through the request and get the response
response = requests.post(functions.BASE_URL + "FuelLock/Confirm", data=payload, headers=headers)
# Get the response into a json array
returnContent = json.loads(response.content.decode('utf-8'))
try:
# Check if the response was an error message
if(returnContent['Message']):
# If it is, get the error message and return back to the index
session['ErrorMessage'] = returnContent['Message']
return redirect(url_for('index'))
# Otherwise we most likely locked in the price!
if(returnContent['Status'] == "0"):
# Update the fuel prices that are locked in
functions.lockedPrices()
# Get amoount of litres that was locked in from the returned JSON array
session['TotalLitres'] = returnContent['TotalLitres']
session['SuccessMessage'] = "The price was locked in for " + str(session['LockinPrice']) + " cents per litre"
# Pop our fueltype and lock in price variables
session.pop('fuelType', None)
session.pop('LockinPrice', None)
return redirect(url_for('index'))
# For whatever reason it saved our lock in anyway and return to the index page
except:
# Update the fuel prices that are locked in
functions.lockedPrices()
session['SuccessMessage'] = "The price was locked in for " + str(session['LockinPrice']) + " cents per litre"
# Get amoount of litres that was locked in from the returned JSON array
session['TotalLitres'] = returnContent['TotalLitres']
# Pop our fueltype and lock in price variables
session.pop('fuelType', None)
session.pop('LockinPrice', None)
return redirect(url_for('index'))
else:
# They just tried to load the lock in page without sending any data
session['ErrorMessage'] = "Unknown error occured. Please try again!"
return redirect(url_for('index'))
] # change here according to your columns in the original file (additional columns)
SHEET_NAME = "Sheet 1"
OUTPUT_NAME = "output_example.xlsx"
if __name__ == "__main__":
script_name = os.path.relpath(__file__)
if len(sys.argv) != 2:
print("Usage: {} <excel file>".format(script_name))
exit()
filename = sys.argv[1]
file = pd.read_excel(filename)
streets = file['Street']
numbers = file['House']
gmaps = googlemaps.Client(key=KEY)
columns = ['Address', 'x', 'y'] + COLUMNS
df = dict()
for col in columns:
df[col] = []
for i in tqdm(range(len(file))):
street = streets[i]
number = numbers[i]
address = f"{street} {number}, ירושלים"
loc = gmaps.geocode(address)
for l, name in zip(['lng', 'lat'], ['x', 'y']):
add = loc[0]['geometry']['location'][l]
df[name].append(add)
df['Address'].append(address)
for col in COLUMNS:
# Código desenvolvido para o desafio Nasa Space App pela equipe #430
# Este código solicita sua localização( cidade, país, local específico) e retorna a latitude e longitude
api_key = 'AIzaSyCIUu5YFfu5A_nwFb_E4BkfhqM38OSzOUo'
import pandas as pd
import googlemaps
local_input = input('Digite sua localização (Cidade e Estado):'
) # pode inserir neste local qualquer informação
df = pd.DataFrame(
{ # sobre o local que deseja, podendo utilizar até código postal
'address': [local_input]
})
gmaps_key = googlemaps.Client(key='AIzaSyCIUu5YFfu5A_nwFb_E4BkfhqM38OSzOUo')
df['Lat'] = None
df['Lon'] = None
for i in range(len(df)):
geocode_result = gmaps_key.geocode(df.loc[i, 'address'])
try:
lat = geocode_result[0]['geometry']['location']['lat']
lng = geocode_result[0]['geometry']['location']['lng']
df.loc[i, 'Lat'] = lat
df.loc[i, 'Lon'] = lng
except:
lat = None
lng = None
print(df)
# !pip3 install -U googlemaps
# https://github.com/chncyhn/simulated-annealing-tsp/blob/master/anneal.py
#
import math
import time
import json
import random
import datetime
from decimal import Decimal
import googlemaps
import collections
# Calling the distance matrix API
gmaps = googlemaps.Client(key='AIzaSyBx0n2ciqzWa6er_BjaDJvXZ6eYr1jKmN0 ')
print("Maximum number of vehicle = 6")
numVehicles = int(input("VEHICLES NUMBERS : "))
def convert(seconds):
seconds = seconds % (24 * 3600)
hour = seconds // 3600
seconds %= 3600
minutes = seconds // 60
seconds %= 60
return "%d:%02d:%02d" % (hour, minutes, seconds)
# -------------------------------------------------------------------------------------
################################# SimulatedAnneling ##################################
def test_clientid_not_accepted(self):
client = googlemaps.Client(client_id="asdf", client_secret="asdf")
with self.assertRaises(ValueError):
client.speed_limits("foo")
