def get_latlong_address(address):
geocoder = OpenCageGeocode(key)
results = geocoder.geocode(address)
return results
# 21.023783719336993,105.84760665893556
# print(get_district_coordinates(21.023783719336993,105.84760665893556))
# geocoder = OpenCageGeocode(key)
#
# results = geocoder.reverse_geocode(21.047324, 105.779932)
# pprint(results)
# geocoder = OpenCageGeocode(key)
# results = geocoder.reverse_geocode(44.8303087, -0.5761911)
#
# query = u'Hoàng Quốc Việt, Cầu Giấy, Hanoi'
# results = geocoder.geocode(query)
# print(u'%f,%f;%s;%s' % (results[0]['geometry']['lat'],
# results[0]['geometry']['lng'],
# results[0]['components']['country_code'],
# results[0]['annotations']['timezone']['name']))
def get_coordinates(location, df):
'''
gets specific geometric location given a fuzzy address using OpenCage Geocoder.
accepts a string address
outputs latitude and longitude
'''
# print(location, df)
postal_code = [int(s) for s in location.split() if s.isdigit()]
# place_name = [str(s) for s in location.split() if not s.isdiget()]
numbers = str(postal_code[-1])
geocoder = OpenCageGeocode(OpenCageKey)
locate = geocoder.geocode(location)
geometry = locate[0]['geometry']
lat_long = list(geometry.values())
lat = lat_long[0]
long = lat_long[1]
# appends 1 reading for every hour in the day
for i in range(96):
# results['Latitude [deg]'].append(lat)
# results['Longitude [deg]'].append(long)
df['Latitude [deg]'] = lat
df['Longitude [deg]'] = long
lat = str(lat)
long = str(long)
return df, lat, long
def save(self, *args, **kwargs):
initial_start = self.start
self.slug = slugify(self.name)
super().save(*args, **kwargs)
# Check if the start location has changed
start_location_changed = False
if not self.start:
self.start = self.calculate_walk_start()
start_location_changed = True
if self.start != initial_start:
start_location_changed = True
# check if the cache_has expired
if self.reverse_geocode_cache_time is None:
cache_expired = True
else:
cache_expired = self.reverse_geocode_cache_time < (
now() - timedelta(days=180)
)
# update the location details if we need to
if start_location_changed or cache_expired:
if settings.OPENCAGE_API_KEY:
geocoder = OpenCageGeocode(settings.OPENCAGE_API_KEY)
try:
results = geocoder.reverse_geocode(
round(self.start[1], 6),
round(self.start[0], 6),
language="en",
limit=1,
)
if results and len(results):
self.what3words = (
results[0].get("annotations").get("what3words").get("words")
)
self.geohash = results[0].get("annotations").get("geohash")
self.continent = results[0].get("components").get("continent")
self.country = results[0].get("components").get("country")
self.state = results[0].get("components").get("state")
self.county = results[0].get("components").get("county")
self.city = results[0].get("components").get("city")
self.suburb = results[0].get("components").get("suburb")
self.road = results[0].get("components").get("road")
self.postcode = results[0].get("components").get("postcode")
self.formatted = results[0].get("formatted")
self.reverse_geocode_cache_time = now()
super().save(*args, **kwargs)
except RateLimitExceededError as e:
print(e)
self.route.transform(3857)
self.route_length = D(m=self.route.length).mi
super().save(*args, **kwargs)
def __init__(self):
self.point = [0, 0]
self.range = 100
ctx = ssl.create_default_context(cafile=certifi.where())
geopy.geocoders.options.default_ssl_context = ctx
self.locator = geopy.Nominatim(user_agent="BDS_project")
self.geocoder = OpenCageGeocode("f3d708b60c224f75959258777933a2ec")
def getLatituteAndLongitute(place):
try:
key = '6c81f22653b6405cb3e5db02b048dbcb' # get api key from: https://opencagedata.com
geocoder = OpenCageGeocode(key)
results = geocoder.geocode(place)
if results:
lat, lng = results[0]['geometry']['lat'], results[0][
'geometry']['lng']
else:
results = geocoder.geocode(place.split(' ', 1)[1])
if results:
lat, lng = results[0]['geometry']['lat'], results[0][
'geometry']['lng']
else:
results = geocoder.geocode(place.rsplit(' ', 1)[1])
if results:
lat, lng = results[0]['geometry']['lat'], results[
0]['geometry']['lng']
else:
results = geocoder.geocode(place.rsplit(' ', 2)[1])
lat, lng = results[0]['geometry']['lat'], results[
0]['geometry']['lng']
return lat, lng
except RateLimitExceededError:
return "Your rate limit has expired"
def __init__(self):
super(Geocode, self).__init__()
load_dotenv()
self.api_key = os.getenv('OPENCAGEDATA_API_KEY')
assert self.api_key is not None, 'Opencagedata api key missing'
self.geocoder = OpenCageGeocode(self.api_key)
def __init__(self, parser):
args = parser.parse_args()
self.vt_api_key = args.vt_api_key
self.oc_api_key = args.oc_api_key
self.samples_path = args.spath
self.reports_path = args.rpath
if not self.vt_api_key:
self.vt_api_key = os.environ.get("VT_API_KEY")
if not self.vt_api_key:
parser.print_help()
print('[-] No VirusTotal Enterprise API key supplied')
if not self.oc_api_key:
self.oc_api_key = os.environ.get("OC_API_KEY")
if not self.oc_api_key:
parser.print_help()
print('[-] No OpenCage API key supplied')
gc = OpenCageGeocode(self.oc_api_key)
sl = get_filename(self.samples_path)
# Comment this line if you do want to query VirusTotal
query_vt(sl, self.reports_path, self.vt_api_key)
rl = get_filename(self.reports_path)
attacks = parse_vt_report(rl, self.reports_path, self.samples_path, gc)
dump_data(attacks, pd)
def _get_data():
response = client.Transactions.get(access_token,
start_date= enddate(),
end_date= startdate())
transactions = response['transactions']
# Manipulate the count and offset parameters to paginate
# transactions and retrieve all available data
while len(transactions) < response['total_transactions']:
response = client.Transactions.get(access_token,
start_date=enddate(),
end_date=startdate(),
offset=len(transactions)
)
transactions.extend(response['transactions'])
key = 'Enter Geocoder Key'
geocoder = OpenCageGeocode(key)
for i in range(len(transactions)):
query = transactions[i]['location']['address']
results = geocoder.geocode(query)
transactions[i]['lat'] = results[0]['geometry']['lat']
transactions[i]['lng'] = results[0]['geometry']['lng']
myList = []
return jsonify({'data': transactions})
def weather_forecast(city):
"""
Get weather forecast. Here used Open Cage Geocoder (link on README.md). It's for getting lat and lon of city
because free type of API OpenWeather cannot send you result on just city name.
:param city: str, name of city
:return: dict, with key (category) and value from result of API for displaying on the page
"""
geocoder = OpenCageGeocode(GEOCODE_TOKEN)
results = geocoder.geocode(city)
weather_url = requests.get(
'https://api.openweathermap.org/data/2.5/onecall?lat={}&lon={}&exclude=current,minutely,hourly,alerts&units=metric&appid={}'
.format(results[0]['geometry']['lat'],
results[0]['geometry']['lng'], OPEN_WEATHER_TOKEN))
weather_data = weather_url.json()
forecast = []
for day in weather_data['daily'][:5]:
timestamp = datetime.datetime.fromtimestamp(day['dt'])
forecast.append({
'date': timestamp.strftime('%Y-%m-%d'),
'weather': day['weather'][0]['description'].lower(),
'temp': round(day['temp']['day']),
'humidity': day['humidity'],
'wind_speed': round(day['wind_speed']),
'wind_degree': round(day['wind_deg'])
})
return forecast
def f():
global root, lat, lon
city_name = s.get()
complete_url = base_url + "appid=" + api_key + "&q=" + city_name
response = requests.get(complete_url)
x = response.json()
if x['cod'] != "404":
y = x["main"]
current_temperature = y["temp"]
l3['text'] = '%.2f' % (current_temperature - 273.15)
current_pressure = y["pressure"]
l5['text'] = current_pressure
current_humidity = y["humidity"]
l7['text'] = current_humidity
z = x["weather"]
weather_description = z[0]["description"]
l9['text'] = weather_description
llkey = 'd39bcd9700844b8290f3e10ce6272965'
geocoder = OpenCageGeocode(llkey)
query = city_name
results = geocoder.geocode(query)
lat = results[0]['geometry']['lat']
lng = results[0]['geometry']['lng']
#print (lat, lng)
else:
messagebox.showinfo("OOPS", "Invalid City Name")
s.set('')
def update_location_dictionary(data):
'''
Identify cities that are not in the location data dictionary
Use OpenCageGeocode to find location info
Append location data dictionary
'''
data.city = data.city.apply(lambda x: x[9:] if type(x) != float else x)
new = data[-data.city.isna()]
cities = new.city.unique().tolist()
still_need = []
locations = list(location_dict)
for each in cities:
if each not in locations:
still_need.append(each)
key = "94b38715f5b64f4db83c6313faf5893e"
geocoder = OpenCageGeocode(key)
location_cache = {}
for each in still_need:
try:
location_cache[each] = geocoder.geocode(each)[0]['geometry']
location_cache[each]['country'] = geocoder.geocode(
each)[0]['components']['country']
if location_cache[each]['country'] == "United States of America":
location_cache[each]['state'] = geocoder.geocode(
each)[each][0]['components']['state']
except:
pass
with open("loc_data.json", "r+") as file:
info = json.load(file)
info.update(location_cache)
file.seek(0)
json.dump(info, file)
def get_zipcode_location(zipcode):
geocoder = OpenCageGeocode(key)
query = str(zipcode)
results = geocoder.geocode(query)
address = results[0]['formatted']
latitude = results[0]['geometry']['lat']
longitude = results[0]['geometry']['lng']
return [address, longitude, latitude]
# from geopy.geocoders import Nominatim
# geolocator = Nominatim(user_agent="geoapiExercises")
# def get_zip_code_location(zipcode):
# location = geolocator.geocode({"postalcode": zipcode})
# if location is None:
# print('location not available')
# print('input another zipcode')
# return None
# else:
# print(location.address)
# print(location.longitude)
# print(location.latitude)
# return location.point
# print(get_zip_code_location(81929))
def result(self):
"""
Returns a list of geocoded data
"""
result = []
if isinstance(self.title, list):
place = ' '.join(self.title)
else:
place = self.title
if place is not None:
if Geolocation.api_count < 0:
raise ValueError('Negative api count')
elif Geolocation.api_count <= Geolocation.api_limit:
result = OpenCageGeocode(GEOCODE_KEY).geocode(place)
self.api_count_inc()
self.geocode_attempted = True
if len(result) == 0:
self.geocode_array = None
return self.geocode_array
else:
self.geocode_array = result
self.location()
return self.geocode_array
elif Geolocation.api_count >= Geolocation.api_limit:
raise ValueError('Api limit reached')
self.geocode_array = None
return self.geocode_array
def update_location_dictionary(data):
'''
Identify cities that are not in the location data dictionary
Use OpenCageGeocode to find location info
Append location data dictionary
'''
new = data[-data.city.isna()]
cities = new.city.unique().tolist()
still_need = []
locations = list(location_dict)
for each in cities:
if each not in locations:
still_need.append(each)
key = "94b38715f5b64f4db83c6313faf5893e"
geocoder = OpenCageGeocode(key)
location_cache = {}
for each in still_need:
try:
location_cache[each] = geocoder.geocode(each)[0]['geometry']
except:
pass
with open("loc_data.json", "r+") as file:
info = json.load(file)
info.update(location_cache)
file.seek(0)
json.dump(info, file)
def geometry():
geokey = '92244e2e0ea946d3ac6a1024ef5a74dc'
data = [] # create empty lists
geocoder = OpenCageGeocode(geokey)
df = SLDataPreprocess()
df.drop(['Number', 'Date_Added', 'Date_Announced'], axis=1, inplace=True)
newDataSet = df['Detected_Prefecture'].value_counts()
for index, row in newDataSet.items(): # iterate over rows in dataframe
lat = 0
long = 0
location = ''
try:
City = str(index)
query = str(City) + ', Sri Lanka'
geolocator = Nominatim(user_agent="slcovidprediction")
location = geolocator.geocode(query)
if len(location.raw) > 0:
lat = location.latitude
long = location.longitude
data.append({
'City': index,
'Cases': row,
'lat': lat,
'long': long
})
except AttributeError:
continue
df4 = pd.DataFrame(data)
print('geomatry csv created!!')
df4.to_csv('geometry.csv')
def geocoding(postal, key, country="Singapore"):
query = str(postal) + ", " + country
result = OpenCageGeocode(key).geocode(query, no_annotations=1,
language="en",
proximity='1.29823, 103.85392')
return result[0]["geometry"]["lat"], result[0]["geometry"]["lng"]
def __get_address_lat_lng(self):
geocoder = OpenCageGeocode(self.location_api)
self.whole_location_info = geocoder.geocode(self.address)[0]
geo = self.whole_location_info['geometry']
lat, lng = geo['lat'], geo['lng']
self.lat = lat
self.lng = lng
def find_coordinates(city_name):
key = '85f15821952a4e2d9aa204ba3336b3d2'
geocoder = OpenCageGeocode(key)
results = geocoder.geocode(city_name)
coordinates = (results[0]['geometry']['lat'],
results[0]['geometry']['lng'])
return coordinates
def get_coords(combination, p_results, n_places, geokey):
geocoder = OpenCageGeocode(geokey)
print('\nStart searching coordinates for %d new places' % n_places)
t0 = time()
t1 = time()
# Num of allready examined places
previous = len(p_results)
count = 0
# Searh only non examined places
for place in combination[previous:]:
if (count % 100 == 0):
print('\tExamined %d new places in %d sec' %
(count, int(time() - t1)))
t1 = time()
if (count == n_places):
break
if (len(place) > 0):
result = geocoder.geocode(place)
# If an actual result is returned
if (result):
long = result[0]['geometry']['lng']
lat = result[0]['geometry']['lat']
p_results.append([long, lat])
count += 1
else:
p_results.append('')
print('Total time %d secs' % int(time() - t0))
return (p_results)
def get_coordinates(place, verbosity=0):
"""
Get coordinates for the given place
:param place: Place name
:param verbosity: Verbosity level
:return: dictionary with place info
"""
geocoder = OpenCageGeocode(API_KEY)
results = geocoder.geocode(place, language='native', limit=1)
if results and len(results):
data = {
"lat":
results[0]["geometry"]["lat"],
"lng":
results[0]["geometry"]["lng"],
"place":
results[0]["formatted"],
"city":
results[0]['components']['city']
if 'city' in results[0]['components'] else None,
"flag":
results[0]["annotations"]["flag"],
"timezone":
results[0]['annotations']['timezone']['name']
}
if verbosity > 0:
print(u"Latitude: %f, Longitude: %f" % (data["lat"], data["lng"]))
print(u"Detected City: %s %s - %s" %
(data["city"], data["flag"], data["timezone"]))
return data
else:
raise InvalidPlaceError(place)
def verificarCoordenadas(
self
): #Verifica se as coordenadas da ocorrência correspondem ao estado indicado.
key = '5b7a26bfcd904e07a49f085037f6d7ba'
geocoder = OpenCageGeocode(key)
if self.data is None:
self.listdata()
count = 0
for linha in self.data:
try:
results = geocoder.reverse_geocode(float(linha[29]),
float(linha[30]),
no_annotations='1',
language='pt')
if results and len(results):
count += 1
coord = (results[0]['components']['state_code'])
#print (coord)
#if coord == linha[26]:
# print ("A coordenada corresponde ao estado.")
if coord != linha[26]:
print("A coordenada da ocorrência", count + 1,
"não correspode ao estado da ocorrência.")
print("Estado indicado: ", linha[26],
"| Estado indicado pela coordenada: ", coord)
except InvalidInputError as ex:
print(ex)
def addressService(request):
key = 'deccf3b07191435ab3be48da9c0c883d'
geocoder = OpenCageGeocode(key)
#Reading The data from Excel
getting_current_path = r'%s' % os.getcwd().replace('\\','/')
df = pd.read_excel(getting_current_path+'/File/Input.xlsx')
latitude = []
longitude = []
recent_address = []
try:
for single_address in df['Address']:
address = single_address.strip()
address_results = geocoder.geocode(address, no_annotations='1')
if address_results and len(address_results):
recent_address.append(address)
latitude.append( address_results[0]['geometry']['lat'])
longitude.append(address_results[0]['geometry']['lng'])
else:
sys.stderr.write("not found: %s\n" % address)
#Creating Dataframe
output_df = pd.DataFrame({'Address':recent_address, 'latitude': latitude,'longitude':longitude})
#Writing DataFrame into Excel
output_df.to_excel(getting_current_path+'/File/Output.xlsx')
result_data = output_df.T.to_dict().values() #Convert Datadrame into List Of Dict
except IOError:
print('Error: File %s does not appear to exist.' % df )
except RateLimitExceededError as ex:
print(ex)
return HttpResponse(json.dumps(result_data))
def association_between_oc(key, nameEntity, factList, stack, replaceNameEntity,
bounds):
geocoder = OpenCageGeocode(key)
top_admin1Code = stack.top().getAdmin1code()
top_featureValue = stack.top().getFeatureValue()
query = geocoder.geocode(nameEntity,
countrycode='mx',
language='es',
bounds=bounds,
limit=1,
no_annotations=1)
try:
state_code = query[0]["components"]["state_code"]
except Exception as e:
coordinates = Point(query[0]["geometry"]["lng"],
query[0]["geometry"]["lat"])
state_code = getAdmin1.bridge(coordinates)
if (state_code == top_admin1Code):
factList.append("(association_between {0} {1} yes)".format(
replaceNameEntity,
stack.top().getName()))
else:
factList.append("(association_between {0} {1} no)".format(
replaceNameEntity,
stack.top().getName()))
def map_countries():
country_list = {}
key = 'key'
geocoder = OpenCageGeocode(key)
addressfile = 'countries.txt'
try:
with open(addressfile, 'r') as f:
for line in f:
address = line.strip()
result = geocoder.geocode(address, no_annotations='1')
if result and len(result):
longitude = result[0]['geometry']['lng']
latitude = result[0]['geometry']['lat']
print(u'%f;%f;%s' % (latitude, longitude, address))
country_list[address] = [latitude, longitude]
else:
#sys.stderr.write("not found: %s\n" % address)
print("not found: %s\n" % address)
country_list[address] = [0, 0]
except IOError:
print('Error: File %s does not appear to exist.' % addressfile)
filehandler = open(dump_file, 'wb')
pickle.dump(country_list, filehandler)
def GetCoordinatesOfCity(self, city='Saratoga,ca, us'):
''' Convert a city to coordinates (latitude, lobgitude)
input: city {, country} String
output: return coordinates (latitude, lobgitude)
'''
from geopy.geocoders import Nominatim
self.geolocator = Nominatim(user_agent="Project X Get UVI of a City")
try:
self.location = self.geolocator.geocode(city)
except:
# if geopy failed, use OpenCageGeocode wensite
from opencage.geocoder import OpenCageGeocode
self.geocoder = OpenCageGeocode(OCD_API_KEY)
self.results = self.geocoder.geocode(city)
self.coordinates = {
'latitude': self.results[0]['geometry']['lat'],
'longitude': self.results[0]['geometry']['lng']
}
else:
self.coordinates = {
'latitude': self.location.latitude,
'longitude': self.location.longitude
}
return (self.coordinates)
def geocoder_upsert(self, addresses):
geocoder = OpenCageGeocode(OPENCAGE_KEY)
for address in addresses:
if not self.address_exist_check(address):
query = address
result = geocoder.geocode(query)
try:
lat = result[0]['geometry']['lat']
lng = result[0]['geometry']['lng']
except:
print(address)
print(result)
lat = 0
lng = 0
id_ = self.get_max_geo_id() + 1
row = (id_, address, lat, lng)
sql_ = "insert into " + self.geocode_table +\
"(id, address, lat, long) values" +\
"(?,?,?,?)"
self.cursor.execute(sql_, row)
self.conn.commit()
def geoencode(city):
print("\n\n\n\n\n\n\n", city, "\n\n\n\n\n\n\n")
key = 'd89606c6137941b8a4b6ab98eb1dea4c'
geocoder = OpenCageGeocode(key)
results = geocoder.geocode(city)
print(results[0])
return results[0]['geometry']['lat'], results[0]['geometry']['lng']
def command(self, fromcall, message, ack):
api_key = self.config["services"]["aprs.fi"]["apiKey"]
try:
aprs_data = plugin_utils.get_aprs_fi(api_key, fromcall)
except Exception as ex:
LOG.error("Failed to fetch aprs.fi data {}".format(ex))
return "Failed to fetch location"
# LOG.debug("LocationPlugin: aprs_data = {}".format(aprs_data))
lat = aprs_data["entries"][0]["lat"]
lon = aprs_data["entries"][0]["lng"]
try:
utils.check_config_option(self.config, "opencagedata", "apiKey")
except Exception as ex:
LOG.error("Failed to find config opencage:apiKey {}".format(ex))
return "No opencage apiKey found"
try:
opencage_key = self.config["opencagedata"]["apiKey"]
geocoder = OpenCageGeocode(opencage_key)
results = geocoder.reverse_geocode(lat, lon)
except Exception as ex:
LOG.error("Couldn't fetch opencagedata api '{}'".format(ex))
# Default to UTC instead
localzone = pytz.timezone("UTC")
else:
tzone = results[0]["annotations"]["timezone"]["name"]
localzone = pytz.timezone(tzone)
return self.build_date_str(localzone)
def get_address_location(city):
geocoder = OpenCageGeocode(key)
query = str(city)
results = geocoder.geocode(query)
address = results[0]['formatted']
latitude = results[0]['geometry']['lat']
longitude = results[0]['geometry']['lng']
return [address, longitude, latitude]
def __init__(self, debug=False, **kwargs):
self.__setup_engine(**kwargs)
self.__id = 0
self.debug = debug
key = os.environ['OPENCAGE_KEY']
self.__geocoder = OpenCageGeocode(key)
# THIS SHOULD ALREADY EXIST! IN THE DATA. THOMAS, PLEASE UPDATE
self.city = 'kitchener-waterloo'
