def test_multi_results(): g = geocoder.arcgis(location, maxRows='5') assert len(g) == 5 expected_results = [ 'Ottawa, Ontario', 'Ottawa, Ontario', 'Ontario, Oklahoma' ] assert [result.address for result in g][:3] == expected_results
def get_location_geocoded(city_norm, city_real): geo_real = '' # send this to geocoder if one of the special cases if city_norm == 'bay area': geo_real = 'San Franciso' elif city_norm == 'nola': geo_real = 'New Orleans' elif city_norm == 'socal': geo_real = 'Anaheim' city, created = City.objects.get_or_create(norm_name=city_norm) if not created: return (city.lat, city.lng) city.real_name = city_real g = geocoder.arcgis(geo_real or city_real) city.lat, city.lng = g.latlng city.save() return (city.lat, city.lng)
def create_append2_std_address(): engine_con = sqlalchemy.create_engine(FRANKSALARY_INSERT_CONNSTR_CONSOLIDATE) sql = """ select work_location_city1, work_location_state1 from perm limit 10 """ df = pd.read_sql(sql, engine_con) # free geocoding service with no limit yet g_arc = geocoder.arcgis('New York, NY') js = g_arc.json if js['ok']: js['address'] js['lat'] js['lng']
def test_geocoder(address, method_name='geocoder'): """ geocoder - can use various providers (Google, OSM, etc.) https://geocoder.readthedocs.org/ - can output GeoJSON """ #g_geocoder = geocoder.google(address) g_geocoder = geocoder.osm(address) if g_geocoder.latlng == []: g_geocoder = geocoder.google(address) if g_geocoder.latlng == []: g_geocoder = geocoder.arcgis(address) if g_geocoder.latlng == []: g_geocoder = geocoder.yahoo(address) (latitude, longitude) = g_geocoder.latlng print ('{0}\t{1} {2}'.format(method_name, latitude, longitude)) print(pprint(g_geocoder.geojson))
def geocode_address(infile, outfile): """ This program takes the :param infile: and finds the ArcGIS geocoded address. It writes the result to :param outfile: and to results.json. if the address exists in results.josn, a call to ArcGIS isn't made """ print(f"Geocoding Polling Location addresses") addrs = pd.read_csv(infile) print(f"Read Addresses {infile} ({len(addrs)})") try: found = result_file() except FileNotFoundError: found = dict() else: if found is None: found = dict() pbar = tqdm(desc="Geocoding Addresses", total=len(addrs), unit=' addrs') for idx, address in addrs.iterrows(): address_1 = f"{address['addr']} {address['municipality']}, {address['province']} {address['post_code']} CANADA" pbar.set_postfix_str(address_1[:40]) if address_1 in found: result = found[address_1] else: geocoder_object = geocoder.arcgis(address_1) result = geocoder_object.json found[address_1] = result result_file(found) try: addrs.at[idx, 'lat'], addrs.at[idx, 'lon'], addrs.at[idx, 'confidence'], addrs.at[idx, 'quality'], addrs.at[ idx, 'score'] = \ result['lat'], result['lng'], result['confidence'], result['quality'], result['score'] easting, northing = to_lambert(result['lat'], result['lng']) addrs.at[idx, 'easting'], addrs.at[idx, 'northing'] = easting, northing except TypeError: print(f"Address: \n{address_1}\n\twas not found") pbar.update() addrs.to_csv(outfile, encoding="UTF-8") print("\n\nFin")
def geolocate(self, address, try_all=True): if address in self.geocache: return self.geocache[address] try: # should be installed from default skills from astral.geocoder import database, lookup # see https://astral.readthedocs.io/en/latest/#cities a = lookup(address, database()) self.geocache[address] = (a.latitude, a.longitude) return a.latitude, a.longitude except: pass # use online geocoder location_data = geocoder.osm(address) if not location_data.ok: location_data = geocoder.geocodefarm(address) if try_all: # more are just making it slow if not location_data.ok: location_data = geocoder.google(address) if not location_data.ok: location_data = geocoder.arcgis(address) if not location_data.ok: location_data = geocoder.bing(address) if not location_data.ok: location_data = geocoder.canadapost(address) if not location_data.ok: location_data = geocoder.yandex(address) if not location_data.ok: location_data = geocoder.tgos(address) if location_data.ok: location_data = location_data.json lat = location_data.get("lat") lon = location_data.get("lng") self.geocache[address] = (lat, lon) return lat, lon raise ValueError
def placeSingle(text): placeLists = [] longitudeList = [] latitudeList = [] words, ners = fool.analysis(text) for itemSun in ners[0]: if itemSun[2] == 'location': places = geocoder.arcgis(itemSun[3]) if places.latlng == None: continue placeLists.append(((places.address).split(','))[0]) longitudeList.append(str(round(places.lng, 2))) latitudeList.append(str(round(places.lat, 2))) if placeLists == []: place = '' longitude = '' latitude = '' return place, longitude, latitude place = max(placeLists, key=placeLists.count) indexdata = placeLists.index(place) longitude = longitudeList[indexdata] latitude = latitudeList[indexdata] return place, longitude, latitude
def fetchtweets(query): tweets = [] for tweet in tweepy.Cursor(api.search, q=query + ' -RT', lang="en").items(150): location = tweet._json['user']['location'] if len(location) != 0: jtweet = {} jtweet['created_at'] = tweet._json['created_at'] jtweet['text'] = tweet._json['text'] analysis = TextBlob((clean_tweet(jtweet['text']))) jtweet['sentiment'] = round(analysis.sentiment.polarity, 1) jtweet['location'] = tweet._json['user']['location'] tweets.append(jtweet) for tweet in tweets: g = geocoder.arcgis(tweet['location']) try: tweet['latitude'] = g.json['lat'] tweet['longitude'] = g.json['lng'] except: pass print(len(tweets)) return tweets
async def hour(self, ctx, *, city: str): """Get the hour of a city""" if city.lower() in ['mee6', 'mee6land']: return await ctx.send( '**Mee6Land/MEE6**:\nEverytime (NoWhere)\n (Mee6Land - lat: unknown - long: unknown)' ) g = geocoder.arcgis(city) if not g.ok: return await ctx.send(await self.translate(ctx.channel, "fun", "invalid-city")) timeZoneStr = self.tz.tzNameAt(g.json['lat'], g.json['lng'], forceTZ=True) if timeZoneStr == 'uninhabited': return await ctx.send(await self.translate(ctx.channel, "fun", "uninhabited-city")) timeZoneObj = timezone(timeZoneStr) d = datetime.datetime.now(timeZoneObj) format_d = await self.bot.cogs['TimeCog'].date( d, lang=await self.translate(ctx.channel, "current_lang", "current")) await ctx.send("**{}**:\n{} ({})\n ({} - lat: {} - long: {})".format( timeZoneStr, format_d, d.tzname(), g.current_result.address, round(g.json['lat'], 2), round(g.json['lng'], 2)))
def get_coordinates(self, address): """ Using geocoder to decode address - can use various providers (Google, OSM, etc.) https://geocoder.readthedocs.org/ - can output GeoJSON - proxies from http://www.proxy-listen.de/Proxy/Proxyliste.html """ #proxies = {'149.202.249.227:3128', '144.76.232.58:3128'} #g_geocoder = geocoder.osm(address, proxies=proxies) g_geocoder = geocoder.osm(address) # in case OSM didn't provide anything use Google Maps if g_geocoder.latlng == []: g_geocoder = geocoder.google(address) # in case Google Maps didn't provide anything use ArcGIS if g_geocoder.latlng == []: g_geocoder = geocoder.arcgis(address) (latitude, longitude) = g_geocoder.latlng if DEBUG: print ('[i] location : {0} {1}'.format(latitude, longitude)) return {'lat': latitude, 'lng': longitude}
try: for number in ('1','2','3','4','5'): storenameb = browser.find_element_by_xpath('//*[@id="results"]/table/tbody['+number+']/tr/td[2]').text if storenameb.find('@') != 0: storenameb = storenameb.replace('@', ' ') storename = storenameb[:storenameb.find("(",20)].replace('\n', ' ') storetype = browser.find_element_by_xpath('//*[@id="results"]/table/tbody['+number+']/tr/td[4]').text if browser.find_elements_by_xpath('//*[@id="results"]/table/tbody['+number+']/tr/td[5]/div') != []: storeplay = True else: storeplay = False if browser.find_elements_by_xpath('//*[@id="results"]/table/tbody['+number+']/tr/td[6]/div') != []: storedrive = True else: storedrive = False storelatlng = geocoder.arcgis(storename).latlng storefull = [storename.encode("utf-8"), storetype.encode("utf-8"), storeplay, storedrive, storelatlng] if storefull not in store_list: store_list.append(storefull) if storelatlng == []: print "lat-long for", storefull[0] , "is not found" except: count += 1 print zipcode, "error!, no such thing :", str(count) ,"out of", str(ziplen) else: count += 1 print zipcode, "is done :", str(count) ,"out of", str(ziplen) browser.close() #write all results to .csv
for c in casts: if c['RSS Feed'] and c['Link to Audiofile'] and 'guid' not in c: try: c['guid'] = getGuid(c['RSS Feed'], c['Link to Audiofile']) except Exception as e: print e by_location = defaultdict(list) for e in casts: if not e['Location']: continue by_location[e['Location']].append(e) coords = { l: geocoder.google(l).latlng or geocoder.arcgis(l).latlng for l in by_location } print[k for k, v in coords.iteritems() if not v] out = { "type": "FeatureCollection", "features": [{ "type": "Feature", "properties": { "name": l, "casts": casts }, "geometry": {
destination_latitude = 0 destination_name = "" departure_longitude = 0 departure_latitude = 0 departure_name = "" departure_id = 0 destination_id = 0 for word in words: for m in re.finditer(pattern, word): word_results.append(m.group(0)) if len(m.group(0)) > 3: with requests.Session() as session: searchString = m.group(0) print("Geocode: " + searchString) g = geocoder.arcgis(searchString, session=session) print(g.json) if not g.ok: pass else: lat = 0 lng = 0 name = "" for result in g: lat = result.lat lng = result.lng name = result.address pass if lng > 36.6 or lng < -9.2 or lat > 58.5 or lat < 33.2: pass else:
import geocoder import requests g = geocoder.arcgis('Redlands, CA') print(g.latlng) # latlng is a tuple with a length of 2. dest = [ 'Space Needle', 'Crater Lake', 'Golden Gate Bridge', 'Yosemite National Park', 'Las Vegas, Nevada', 'Grand Canyon National Park', 'Aspen, Colorado', 'Mount Rushmore', 'Yellowstone National Park', 'Sandpoint, Idaho', 'Banff National Park', 'Capilano Suspension Bridge' ] for point in dest: loc = geocoder.arcgis(point) print(f"{point} Located at {loc.latlng}")
#state = file.split('_')[0] state = 'Vietnam' filename = file.split('.')[0] with open(os.path.join(folder, file), 'r') as f: df = pd.read_csv(f, names=['PERSNBR','BRANCHNBR','TAXID','ADDRNAME','latitude','longitude'], skiprows=1) places = df['ADDRNAME'] count = 0 for place in places: time.sleep(random.random()) address = '{}, {}'.format(place, state) #print(address) #print(df.latitude[count]) g = geocoder.arcgis(address) trials = 5 for i in range(trials): #print(g.status) if g.status == 'OK': df.latitude[count] = g.latlng[0] df.longitude[count] = g.latlng[1] break elif g.status == 'ZERO_RESULTS': g = geocoder.arcgis(address) if i == trials - 1: print("ERROR: No Result") else: print('ERROR') print(g.current_result)
draw = ImageDraw.Draw(img) logging.info("Display dimensions: W %s x H %s", WIDTH, HEIGHT) display_weather = False if NEXT_DISPLAY == 'weather': weather_location = None if "WEATHER_LOCATION" in os.environ: weather_location = os.environ["WEATHER_LOCATION"] # Get the latitute and longitude of the address typed in the env variable if latitude and longitude are not set if weather_location and (not LAT or not LONG): logging.info(f"Location is set to {weather_location}") try: geo = geocoder.arcgis(weather_location) [LAT, LONG] = geo.latlng except Exception as e: print(f"Unexpected error: {e.message}") # If no address or latitute / longitude are found, retrieve location via IP address lookup if not LAT or not LONG: location = get_location() [LAT, LONG] = [float(x) for x in location['loc'].split(',')] weather = get_weather(LAT, LONG) # Set latitude and longituted as environment variables for consecutive calls os.environ['LATLONG'] = f"{LAT},{LONG}" # If weather is empty dictionary fall back to drawing quote if len(weather) > 0: img = draw_weather(weather, img, SCALE) display_weather = True
def find_location(city: str) -> str: """ find geocode by city """ g = geocoder.arcgis(city) return str(g.latlng)
+ "Coordinates" + " " + "City" + " " + "State" + " " + "Postal" + "\n" ) # In[9]: for i in xrange(3113, len(add_list)): print i arcResult = geocoder.arcgis(add_list[i].decode("utf8")) print arcResult coordinates = arcResult.latlng address = arcResult.address gooResult = geocoder.google(coordinates, method="reverse") print gooResult city = gooResult.city postal = gooResult.postal state = gooResult.state if arcResult.status == "OK" and gooResult.status == "OK": geo_file.write( str(i) + " " + add_list[i].strip("\n") + " " + address
address = address.replace(" ","") #format postcode list = address.split(', '); postcode = list[len(list)-1] #format station name stationname = str(header[0].contents[0]) stationname = stationname[:-2] except: #error calling url. Continue to next crs code print 'Networkrail ERROR:' + crscode continue try: #geocode postcode. Try arcgis and then mapquest if arcgis fails. g = geocoder.arcgis(postcode) if not g.lat: g = geocoder.mapquest(postcode, key='PXstG2wqhxmTuWThW0lC6RhDWJ89DHTe') line = '"' + crscode +'", "'+ str(g.lat) +'", "'+ str(g.lng) +'", "'+stationname +'", "'\ + postcode +'", "' + operator + '", "'+ address +'"' print line f.write(line+'\n') # python will convert \n to os.linesep except: print 'geocoding ERROR:' + crscode continue f.close()
import geocoder add_list = list(open('address')) print len(add_list) geo_file = open('geo_file-left','w') geo_file.write('LineID' + ' ' + 'OrignalAddress' + ' ' + 'NewAddress' + ' ' + 'Coordinates' + ' ' + 'City' + ' ' + 'State' + ' ' + 'Postal' + '\n') # In[9]: LeftIDList = list(open('Left LineID', 'r')) for i in LeftIDList: i = int(i.strip()) print i arcResult = geocoder.arcgis(add_list[i].decode('utf8')) print arcResult coordinates = arcResult.latlng address = arcResult.address gooResult = geocoder.google(coordinates, method = 'reverse') print gooResult city = gooResult.city postal = gooResult.postal state = gooResult.state if arcResult.status == 'OK' and gooResult.status == 'OK': geo_file.write(str(i) + ' ' + add_list[i].strip('\n') + ' ' + address + ' ' + str(coordinates) + ' ' + city + ' ' + state + ' ' + str(postal) + '\n')
def test_arcgis(): g = geocoder.arcgis(location) assert g.ok osm_count, fields_count = g.debug()[0] assert osm_count == 0 assert fields_count == 8
def blocking_refresh(self): self._g = geocoder.arcgis(self._name) self._result = QGeoCoordinate(self._g[0].lat, self._g[0].lng) self.geocodeUpdated.emit(self._result)
def test_arcgis_reverse(): g = geocoder.arcgis(ottawa, method='reverse') assert g.ok
import geocoder g = geocoder.arcgis(u"上海") dir(g) help(g.y) help(g) g.street type(g) type(g.street) l = [2,34,5] type(l) isinstance(l, list) l = [12,"a"] l s = {"a":1} s type(s) ll ll pwd ls ll g.ok g.latl g.latlng type([]) frozenset help("frozenset") f = frozenset() f.difference f.difference() d = {"a":1,"b":2}
import geocoder with open("assets/native-seattle-places-geocoded.csv", "w", encoding="utf8") as geofp: geofp.write("name, frequency, lat, lng\n") with open("assets/native-seattle-places.csv", "r", encoding="utf8") as fp: for line in fp.readlines(): location = line.split(",")[0] freq = int(line.split(",")[1]) try: g = geocoder.arcgis(location) lat = g.current_result.lat lng = g.current_result.lng geofp.write("%s, %d, %f, %f\n" % (location, freq, lat, lng)) print(location, freq, lat, lng) except: pass print("finished!")
import requests import geocoder api_base_url = "https://api.darksky.net/forecast/71321cb803dc4539cd35795c6b9d3d78/" destinations = [ "Space Needle", "Crater Lake", "Golden Gate Bridge", "Yosemite National Park", "Las Vegas, Nevada", "Grand Canyon National Park", "Aspen, Colorado", "Mount Rushmore", "Yellowstone National Park", "Sandpoint, Idaho", "Banff National Park", "Capilano Suspension Bridge" ] for place in destinations: lat = geocoder.arcgis(place).lat lng = geocoder.arcgis(place).lng full_api_url = (f"{api_base_url}{lat},{lng}") result = requests.get(full_api_url).json() summ = result["currently"]["summary"] temp = "{0:.1f}".format(result["currently"]["temperature"]) print( f"{place} is located at ({lat}, {lng}). The weather is {summ} with a temperature of {temp}\u00B0F.\n" )
def get_location(location): try: g = geocoder.arcgis(location) return g.latlng except: return "Not found"
# one approach is to use pandas json functionality: elevation = pd.io.json.json_normalize(r, 'results')['elevation'].values[0] return elevation def get_coords(text): """ Returns (latitude, longitude, elevation) triple geocoded text. """ g = geocoder.osm(text) lat = g.json['lat'] lon = g.json['lng'] print("%.4f, %.4f" % (lat, lon)) h = get_elevation(lat, lon) return (lat, lon, h) g = geocoder.arcgis('Lysa hora, okres Frydek') g.json g = geocoder.yahoo('Lysa hora, okres Frydek') g.json h = get_elevation(g.json['lat'], g.json['lng']) get_coords('Lysa hora, okres Frydek') # https://cgiarcsi.community/data/srtm-90m-digital-elevation-database-v4-1/ # http://www.viewfinderpanoramas.org/dem3.html graphhopper_api_key = "3aa82fd4-5229-4983-9ec3-27a49339cd4e" geocode_url = "https://graphhopper.com/api/1/geocode?q=berlin&locale=de&debug=true&key=%s" % graphhopper_api_key r = requests.get(geocode_url).json()
def test_arcgis(): g = geocoder.arcgis(location) assert g.ok
def getLatLngArcGIS(key, address): ##key is not used. Only present to support googleMaps. g = geocoder.arcgis(address) if g.latlng == []: return 0 h = [str(g.latlng[0]), str(g.latlng[1])] return h
<b>Rating:</b> {rating} """.format( link_href=link.attrs["href"], alert_msg=alert_msg, reserve_phone=reserve_phone, info_phone=info_phone, email=email, rv_checkout_checkin=rv_checkout_checkin, address_1=address_1, address_2=address_2, rating=rating, ) # note: this is a free and simple geocoder but not the most accurate # google might be best but costs $$ geocode_result = geocoder.arcgis(", ".join([address_1, address_2])) latlng_str = ",".join( [str(_) for _ in geocode_result.current_result.latlng[::-1]]) placemark = KML.Placemark( KML.name(name), KML.description(description), KML.Point(KML.coordinates(latlng_str), ), ) folder.append(placemark) with open("koa-campgrounds.kml", "w") as fh: fh.write( etree.tostring( format_xml_with_cdata(folder), method="xml", encoding="unicode",
stationDict = {} #but bike stations and location into local dict with open('bikeShareData.csv', 'w', newline='') as f: fieldnames = ['id', 'name', 'lat', 'long'] for each in stationJson['data']['stations']: #print(each['name']) id = int(each['station_id']) stationDict[id] = [each['name'], each['lat'], each['lon']] #print(stationDict) loc = input("Please enter your address or zipcode: ") g = geocoder.arcgis(loc) #coodinates of your address print("Your location: \n", g.latlng) while 1: coords_1 = g.latlng ebikeDict = {} sum = 0 timeNow = datetime.datetime.now() print("\nLast checked: {:%m/%d/%Y %I:%M %p}\n".format(timeNow)) for each in stationStatus['data']['stations']: id = int(each['station_id']) ebikeNum = each['num_ebikes_available'] #print(stationDict[id][0])
import geocoder spots = [ 'Space Needle', 'Crater Lake', 'Golden Gate Bridge', 'Yosemite National Park', 'Las Vegas, Nevada', 'Grand Canyon National Park', 'Aspen, Colorado', 'Mount Rushmore', 'Yellowstone National Park', 'Sandpoint, Idaho', 'Banff National Park', 'Capilano Suspension Bridge' ] # g = geocoder.arcgis(spots) locationList = [] for location in spots: print("{} is in: {}".format(location, geocoder.arcgis(location).latlng)) # print(geocoder.arcgis(location).latlng)
import pandas as pd import numpy as np postcode = pd.read_csv( '/Users/luhao/Desktop/Geocoder_tool/Registered_Landfills.csv', usecols=[8]) postcode_list = np.array(postcode['SitePostCode'].tolist()).tolist() poco = [x.replace('nan', 'NA') for x in postcode_list] location = pd.read_csv( '/Users/luhao/Desktop/Geocoder_tool/Registered_Landfills.csv', usecols=[2, 3, 4, 5, 6, 7]) location_array = np.array(location.values.tolist()) loc_list = [','.join(x) for x in location_array] loc = [x.replace('nan,', '') for x in loc_list] regi_code = [] for i in range(0, 564): if poco[i] != 'NA': if geocoder.arcgis(poco[i]).latlng != None: geocode = geocoder.arcgis(poco[i]).latlng print('Done +1 using poco') else: geocode = geocoder.arcgis(loc[i]).latlng print('Done +1 using loc') if geocode != None: regi_code.append(geocode) print('-------Success +1--------') regi_array = np.array(regi_code) regi_df = pd.DataFrame({'Lat': regi_array[:, 0], 'Lon': regi_array[:, 1]}) regi_df.to_csv('regi_code.txt', index=None)
import geocoder destinations = [ "The Space Needle", "The Golden Gate Bridge", "Yosemite National Park", "Las Vegas, Nevada", "Grand Canyon National Park", "Aspen,Colorado", "Mount Rushmore", "Yellowstone National Park", "Sandpoint, Idaho", "Banff National Park", "Capilano Suspension Bridge" ] for point in destinations: location = geocoder.arcgis(point) print("{0} is located at ({1:.4f}, {2: .4f})".format( point, location.latlng[0], location.latlng[1]))
with arcpy.da.UpdateCursor( Locations, [MatchStatus, "X", "Y", Address, city, state, zipCode, MatchAddress, "Addr_type"] ) as cursor: for row in cursor: # check if row has unmatched status if row[0] == "U": addr = "{0}, {1} {2} {3}".format(row[3], row[4], row[5], int(row[6])) # ------------------------------------------------------------------------------------------- # Check if the current address is in the dictionary. If it isn't, go ahead and geocode it. # ------------------------------------------------------------------------------------------- if not AddressDict[addr]: arcpy.SetProgressorLabel("Locating {0}".format(addr)) loc = geocoder.arcgis(addr) st = stDict[row[5]] z = str(row[6]) # check that the quality is sufficient, and zip code and state match the current candidate location if loc.quality in qualList: # and loc.postal == z: #and st == loc.address.split(',')[-2].strip(): arcpy.SetProgressorLabel("Match found for {0}".format(addr)) row[2] = loc.lat row[1] = loc.lng row[0] = "M" row[7] = loc.address row[8] = loc.quality cursor.updateRow(row)
import os import unicodecsv wd = "I:/Dropbox/NDAD/Visualizing-Empire/OpeNER/test" os.chdir(wd) filename = "1880-p1-test.csv" # In[ ]: with open(filename, 'r') as f: cfile = unicodecsv.reader(f, delimiter=",") output = codecs.open(filename + ".geocoded.csv", "w", encoding="utf8") output.write("LOC,FREQ,LAT,LON\n") for row in cfile: #g=geocoder.google(row[0]) #google also includes g.city,g.state,g.country, g = geocoder.arcgis(row[0]) if g.latlng: lat = g.latlng[0] lon = g.latlng[1] l = [unicode(row[0]), row[1], lat, lon] export_text = ",".join(unicode(x) for x in l) + "\n" output.write(export_text) print "OUTPUT: " + export_text, output.close() # In[50]: output.close() # In[ ]:
import csv import geocoder f = open('latlng-arcgis.csv', 'w') reader = csv.reader(open("train/train.tsv"), delimiter=" ") flats = [] for xi in reader: flats.append(xi) i = 1 for flat in flats: g = geocoder.arcgis(flat[4]) print(i) if ('lat' in g.json and 'lng' in g.json): f.write(str(g.json['lat']) + "," + str(g.json['lng']) + "\n") else: g2 = geocoder.google(flat[4]) if (hasattr(g2, 'latlng')): f.write(str(g.latlng) + "\n") else: f.write("brak, brak") i += 1 f.close()
def address_to_latlng(self, address): g = geocoder.arcgis(address) return (g.lat, g.lng)
geo_df[1:50] # In[ ]: # create a separate dataframe for visualization geo_df = df_all[['from_user_location', 'content', 'coordinates','from_user_followers_count', 'RT_or_not']] # In[51]: for index, row in geo_df[50001:].iterrows(): a = row['from_user_location'] if a!='': try: g = geocoder.arcgis(a) #print g, '\n', '\n', '\n' k = abs(g.lat)+abs(g.lng) #used to minimize errors in geodecoding process if k >0: print ("currently processing index number:", index) print ([unicode(g.lat)], [unicode(g.lng)]) #geo_df.ix[index,'lat'] = g.lat geo_df.loc[index,'lat'] = g.lat #geo_df.ix[index,'lng'] = g.lng geo_df.loc[index, 'lng'] = g.lng except: pass # In[ ]:
state = line.split(",")[-3] county = line.split(",")[-2] try: note = line.split(",")[3].replace("\n", " ").replace( "\r", " ").replace("\t", " ").replace('"', '').replace('"', '').replace( ' ', ' ').replace(' ', ' ').replace(' ', ' ').strip() except: note = "" try: reference = line.split(",")[-1].strip().replace("\n", " ") except: reference = "" try: g = geocoder.arcgis(county + " county, " + state + ", U.S.A.") lat = g.current_result.lat lng = g.current_result.lng except: lat = 0 lng = 0 # time.sleep(1) id += 1 print(no, date, county, state, lat, lng, note, reference) output = '%d,"%s","%s","%s","%s",%f,%f,"%s","%s"\n' % ( id, no, date, county, state, lng, lat, note, reference) outputs.append(output) with open("reformed.csv", "a", encoding="utf-8") as fp: #fp.write("id,no,date,county,state,lng,lat,note,reference\n") for output in outputs:
import requests from secrets import API_KEY # Vars API_BASE_URL = "http://api.openweathermap.org/data/2.5/weather" destinations = [ 'Space Needle', 'Crater Lake', 'Golden Gate Bridge', 'Yosemite National Park', 'Las Vegas, Nevada', 'Grand Canyon National Park', 'Aspen, Colorado', 'Mount Rushmore', 'Yellowstone National Park', 'Sandpoint, Idaho', 'Banff National Park', 'Capilano Suspension Bridge' ] #Loop for point in destinations: lat, lon = geocoder.arcgis(point).latlng result = requests.request( 'GET', f'{API_BASE_URL}?lat={lat}&lon={lon}&APPID={API_KEY}').json() weather = result["weather"][0]["description"] # print(weather) temp_data = result["main"] temp = temp_data["temp"] f_temp = (temp - 273.15) * 9 / 5 + 32 f_temp_rounded = float("{:.2f}".format(f_temp)) rounded_lat = float("{:.2f}".format(lat)) rounded_lon = float("{:.2f}".format(lon)) print( f'🌐 {point}:\n latitude: {rounded_lat}, longitude: {rounded_lon}).\n 🌀 Weather: {weather}, 🌡 Temperature: {f_temp_rounded} ℉ \n' )
def geocode_address(address, s): g = geocoder.arcgis(address, session=s.Arcgis) if (g.ok == False): g = geocoder.komoot(address, session=s.Komoot) return g
def get_coords(address): g = geocoder.arcgis(address) coords = g.latlng logging.info("Location coordinates: %s", coords) return coords
destinations = [ "Space Needle", "Crater Lake", "Golden Gate Bridge", "Yosemite National Park", "Las Vegas, Nevada", "Grand Canyon National Park", "Aspen, Colorado", "Mount Rushmore", "Yellowstone National Park", "Sandpoint, Idaho", "Banff National Park", "Capilano Suspension Bridge", ] import geocoder # Declare destinations list here. # Loop through each destination. for point in destinations: g = geocoder.arcgis(point) print(point, " is located at ", g.latlng) # Get the lat-long coordinates from `geocoder.arcgis`. # Print out the place name and the coordinates.