import pandas
from geopy.geocoders import ArcGIS
arc_gis = ArcGIS()
# geo_coord = arc_gis.geocode("3995 23rd st, San Francisco, CA 94114")
# print(geo_coord.address)
# print(geo_coord.latitude, geo_coord.longitude, geo_coord.altitude)
# geo_coord = arc_gis.geocode("Robert Bosch, Hildesheim")
# print(geo_coord.address)
# print(geo_coord.latitude, geo_coord.longitude, geo_coord.altitude)
# geo_coord = arc_gis.geocode("Robert Bosch, Hosur Road, Bangalore")
# print(geo_coord.address)
# print(geo_coord.latitude, geo_coord.longitude, geo_coord.altitude)
def get_lat_lon(address):
arc_gis = ArcGIS()
geo_code = arc_gis.geocode(address)
return str(geo_code.latitude) + "," + str(geo_code.longitude)
df = pandas.read_excel('supermarkets.xlsx')
df["Address"] = df["Address"] + "," + df["City"] + "," + df[
"State"] + "," + df["Country"]
print(df["Address"])
df["LatLong"] = df["Address"].apply(get_lat_lon)
print(df["LatLong"])
def setUpClass(cls):
cls.geocoder = ArcGIS(timeout=3)
def setUpClass(cls):
cls.geocoder = ArcGIS(username=env['ARCGIS_USERNAME'],
password=env['ARCGIS_PASSWORD'],
referer=env['ARCGIS_REFERER'],
timeout=3)
from geopy.geocoders import ArcGIS
import pandas
geoService = ArcGIS()
addrLocation = geoService.geocode("3666 21st St, San Francisco, CA 94114, USA")
print("Latitude: " + str(addrLocation.latitude))
print("Longitude: " + str(addrLocation.longitude))
######
superMarketData = pandas.read_csv("supermarkets.csv")
#City,State,Country
superMarketData["Full_Address"] = superMarketData[
"Address"] + " , " + superMarketData["City"] + " , " + superMarketData[
"State"] + " , " + superMarketData["Country"]
superMarketData["Location"] = superMarketData["Full_Address"].apply(
geoService.geocode)
superMarketData["Latitude"] = superMarketData["Location"].apply(
lambda loc: loc.latitude if loc is not None else None)
superMarketData["Longitude"] = superMarketData["Location"].apply(
lambda loc: loc.longitude if loc is not None else None)
superMarketData.drop("Full_Address", axis=1, inplace=True)
print(superMarketData)
import folium
import pandas
from geopy.geocoders import ArcGIS
n = ArcGIS()
z = n.geocode('Siriu, Buzau, Coltu Pietrii, Romania')
data = pandas.read_csv(r'C:\Users\Leau\Desktop\Python\Mapping\Volcanoes.txt')
lon = list(data['LON'])
lan = list(data['LAT'])
name = list(data['NAME'])
elev = list(data['ELEV'])
def elevation_interval(el):
if 0 <= el < 1000:
return 'green'
elif 1000 <= el < 2000:
return 'orange'
else:
return 'red'
map_create = folium.Map(location=[-32.5, 20],
zoom_start=6,
tiles="Stamen Terrain") # map creation
fg = folium.FeatureGroup(name='My Map')
mk = folium.FeatureGroup(name='Markers')
for la, lo, nm, ev in zip(lan, lon, name, elev):
async def test_missing_password_error(self):
with pytest.raises(exc.ConfigurationError):
ArcGIS(username='******')
def test_user_agent_custom(self):
geocoder = ArcGIS(user_agent='my_user_agent/1.0')
assert geocoder.headers['User-Agent'] == 'my_user_agent/1.0'
def find_address(coords):
geolocator = ArcGIS()
loc = geolocator.reverse(coords)
return loc.raw['Match_addr']
if bottom <= lat <= top and left <= lng <= right:
return True
return False
# In[83]:
from geopy.geocoders import Nominatim, ArcGIS
from geopy.extra.rate_limiter import RateLimiter
import pycountry
df_coord = pd.DataFrame(columns=('Latitude', 'Longitude'))
geolocator = ArcGIS(timeout=10)
i = 0
for location in locations:
if location:
loc = geolocator.geocode(location, exactly_one=True)
if loc:
print(loc.address)
if(cull(loc.latitude, loc.longitude)):
df_coord.loc[i] = (loc.latitude, loc.longitude)
print(loc.latitude, loc.longitude)
i+=1
# In[84]:
def markers_to_dataframe():
"""This function takes the https://covid19.sokat.ai/ web map as input to generate a CSV file of drive-thru testing locations.
"""
# URL of web map with data
url = "https://covid19.sokat.ai/"
# Download webpage data with requests
page = requests.get(url)
# Rarse the webpage data with BeautifulSoup
soup = BeautifulSoup(page.content, 'html.parser')
# Select scripts in HTML file
scripts = list(soup.find_all('script'))
# Subset for the script with marker data and begin string splitting
html = str(list(scripts[7])).split('var marker')
# Use for-loops to generate the names, coordinates, and URLs of drive-thru testing locations
list_of_names = []
list_of_coords = []
list_of_urls = []
for i in range(2, len(html) - 1):
list_of_names.append(
html[i].split('target="_blank">')[1].split('</a></div>')[0])
list_of_coords.append(html[i].split('target="_blank">')[0].split(
"L.marker(\\n [")[1].split("]")[0])
list_of_urls.append(html[i].split('target="_blank">')[0].split(
'><a href="')[1].split('"')[0])
# Concatenate lists into a pandas DataFrame
dataframe = pd.DataFrame([list_of_names, list_of_coords, list_of_urls]).T
# Rename the columns with appropriate titles
dataframe.columns = ["Name", "Coordinate", "URL"]
# Convert coordinates column to a string type to pass to reverse geocoder
dataframe["Coordinate"] = dataframe["Coordinate"].astype(str)
# Instantiate a geocoder and impose a rate limiter
geolocator = ArcGIS(user_agent="drive-thru-testing-reverse-geocoding")
geocode = RateLimiter(geolocator.geocode, min_delay_seconds=1)
# Define a convenience function to clean and reverse geocode coordinates cell contents, returns address
def reverse_geocode(cell_contents):
cellcontents = cell_contents.replace("(", "").replace(")", "")
location = geolocator.reverse(cellcontents)
return location.address
# Apply function to dataframe
dataframe["Addresses"] = dataframe["Coordinate"].apply(reverse_geocode)
# Remove repetitive USA suffix
dataframe["Addresses"] = dataframe["Addresses"].str.replace(", USA", "")
# Create columns for state, city, and street address with string splitting and regular expressions
dataframe["State"] = dataframe["Addresses"].str.split(
",").str[-1].str.replace('\d+', '')
dataframe["City"] = dataframe["Addresses"].str.split(",").str[-2]
dataframe["Street Address"] = dataframe["Addresses"].str.split(",").str[-3]
# Drop the addresses column with unpleasantly long string data
dataframe.drop(["Addresses"], axis=1, inplace=True)
# Save results as a CSV file
dataframe.to_csv(
"../drive_thru_testing_locations/drive-thru-testing-data.csv", index=0)
"VT": "Vermont",
"VA": "Virginia",
"WA": "Washington",
"WV": "West Virginia",
"WI": "Wisconsin",
"WY": "Wyoming"
}
"""
begin!
"""
clear_terminal()
print_logo()
"""
initialize geocoders (just using ArcGIS for now)
"""
arcgis = ArcGIS(timeout=100)
nominatim = Nominatim(user_agent="WQTS", timeout=100)
# opencage = OpenCage('your-API-key', timeout=100)
openmapquest = OpenMapQuest('vooH8ziES69RZKTpR4LLUyuImVpaSY78')
geolocator = Nominatim(user_agent="WQTS")
geocoders = [openmapquest, arcgis, nominatim]
"""
Progress bar function courtesy of StackOverflow :)
"""
def printProgressBar(iteration,
total,
prefix='',
suffix='',
def parse_item(self, response):
item = Amthuc365Item()
geolocator = ArcGIS()
#get name
try:
item['name'] = response.css(
"div.h-info h1::text").extract_first().encode("utf-8")
except:
pass
#get location
try:
location = ''.join(
response.xpath(
'//div[contains(concat(" ",normalize-space(@class)," ")," h-info ")]/p[contains(concat(" ",normalize-space(@class)," ")," address ")]//text()'
).extract()).strip().encode("utf-8")
item['location'] = location
address = geolocator.geocode(location)
item['lat'] = address.latitude
item['lng'] = address.longitude
except:
pass
#get url
try:
source_url = response.css(
"p.rest-web a::attr(href)").extract_first().encode("utf-8")
if source_url.count("/") == 1:
source_url = "http://www.amthuc365.vn" + source_url
item['source_url'] = source_url
except:
pass
#get time
try:
time = response.css(
"#container > div.page-container > div.page-content > div > div.box-info__rest.clearfix > div.rest-info > div:nth-child(3) > p.mb0.closeTime::text"
).extract_first()
item['time'] = time.encode("utf-8").replace(" Giờ đóng cửa:", "")
except:
pass
#get price
try:
price = response.css(
"#container > div.page-container > div.page-content > div > div.box-info__rest.clearfix > div.rest-info > div.row-span.mt10.timeRest.no-border > p.mb0.closeTime::text"
).extract_first()
item['price'] = price.encode("utf-8").replace("Từ ", "").replace(
"Dưới ", "")
except:
pass
#get phone number
try:
item['phone'] = response.css("p.rest-phone.mb5 a::attr(title)"
).extract_first().encode("utf-8")
except:
pass
#get image:
try:
item['image_url'] = response.css(
"div.img-info img::attr(src)").extract_first().encode("utf-8")
except:
pass
#get description
try:
item['description'] = ''.join(
response.xpath(
'//div[contains(concat(" ",normalize-space(@class)," ")," tinimce__content ")]//text()'
).extract()).strip().encode("utf-8")
except:
pass
yield item
#to check how to convert address to laptitude and longtitude
import pandas, geopy
from geopy.geocoders import ArcGIS
arcgis = ArcGIS()
dataFrame = pandas.read_csv("examplefile1.csv")
a = dataFrame["address"].apply(arcgis.geocode)
dataFrame["Longitude"] = a.apply(lambda loc: loc.longitude
if loc != None else None)
dataFrame["Latitude"] = a.apply(lambda loc: loc.latitude)
print(dataFrame)
dataFrame.to_csv("examplefile1.csv")
def get_lat_lon(address):
arc_gis = ArcGIS()
geo_code = arc_gis.geocode(address)
return str(geo_code.latitude) + "," + str(geo_code.longitude)
def make_geocoder(cls, **kwargs):
return ArcGIS(username=env['ARCGIS_USERNAME'],
password=env['ARCGIS_PASSWORD'],
referer=env['ARCGIS_REFERER'],
timeout=3,
**kwargs)
scrape_time = datetime.now() - begin_time
print(f"Total scrape time: {scrape_time}")
begin_time = datetime.now()
print(f"Totally scrape {data_queue.qsize()} ads")
while not data_queue.empty():
data = data_queue.get()
for index, key in enumerate(kijiji_dict):
kijiji_dict[key].append(data[index])
print("Begin to check and geocode address...")
while None in kijiji_dict["latitude"]:
for index, value in enumerate(kijiji_dict["address"]):
if kijiji_dict["latitude"][index] is None:
try:
geo_location = ArcGIS().geocode(value)
kijiji_dict["latitude"][index] = geo_location.latitude
kijiji_dict["longitude"][index] = geo_location.longitude
except Exception as e:
pass
geocode_time = datetime.now() - begin_time
print(f"Total geocode time: {geocode_time}")
print("Web scraping has been completed. Rental map will be generated.")
df = pd.DataFrame(kijiji_dict)
df.to_csv("unclean_data.csv", sep='\t', encoding='utf-8')
df = clean_df(df)
df.to_csv("clean_data.csv", sep='\t', encoding='utf-8')
houseLocation = [
(latitude, longitude)
def make_geocoder(cls, **kwargs):
return ArcGIS(timeout=3, **kwargs)
import folium
import pandas
from geopy.geocoders import ArcGIS
def color_producer(name):
if 'Muthu' in name:
return 'orange'
elif 'Kavin' in name:
return 'purple'
else:
return 'blue'
nm = ArcGIS()
n = nm.geocode('115, Nainar Street, Tenkasi, Tirunelveli, Tamil Nadu')
#print(n.latitude, n.longitude)
df = pandas.read_csv('house.txt')
df['Address'] = df['Address'] + ', ' + df['City'] + ', ' + df['State']
df['Coordinates'] = df['Address'].apply(nm.geocode)
df['Latitude'] = df['Coordinates'].apply(lambda x: x.latitude)
df['Longitude'] = df['Coordinates'].apply(lambda x: x.longitude)
print(df['Name'])
lat = list(df['Latitude'])
lon = list(df['Longitude'])
name = list(df['Name'])
html = """<h4>Welcome to %s</h4>
"""
map = folium.Map(location=[8.5, 77], zoom_start=10, tiles='Stamen Terrain')
async def test_scheme_config_error(self):
with pytest.raises(exc.ConfigurationError):
ArcGIS(username='******',
password='******',
referer='http://www.example.com',
scheme='http')
import pandas
from geopy.geocoders import ArcGIS
#establish geofinder object
nom = ArcGIS(timeout=300)
#csv file to pull data from
info = pandas.read_csv('fatal-police-shootings-data.csv')
# create an address that can be used by ARCGIS to create longitudinal and latitudinal coordinates
info['Address'] = info['city'] + ', ' + info['state'] + ', ' + 'USA'
total_length = len(info)
def make_file(data):
data.to_csv('updated_shootings.csv', mode='a')
query_start = 3499
query_end = query_start + 50
while query_start < total_length + 1:
brevinfo = info[query_start:query_end]
brevinfo['Coordinates'] = brevinfo['Address'].apply(nom.geocode)
brevinfo["Latitude"] = brevinfo["Coordinates"].apply(lambda x: x.latitude if x != None else None)
brevinfo["Longitude"] = brevinfo["Coordinates"].apply(lambda x: x.longitude if x != None else None)
print(brevinfo)
make_file(brevinfo)
query_start += 50
query_end += 50
NVilles = len(listTrueCities)
loc = [(np.random.uniform(0,1), np.random.uniform(0,1)) for i in range(NVilles)]
TSP_method = 'GPU' # different options are GPU, CPU, Threading, No_Par
rho_exp = 0.02
d_exp = 3
N_exp = 20000
alpha_exp = 0.95
init_exp = 1
# Example of experiment
if __name__ == '__main__':
if trueCities:
# geocoding
print("Geocoding...")
geolocator = ArcGIS()
loc = []
for v in listTrueCities:
vl = geolocator.geocode(v)
loc.append((vl.latitude, vl.longitude))
dMat = np.matrix(np.zeros((NVilles, NVilles))) # Generation of a distance matrix
for i in range(NVilles):
for j in range(NVilles):
dMat[i,j] = np.sqrt((loc[i][0] - loc[j][0])**2 + (loc[i][1] - loc[j][1])**2)
# Traveler salesman resolution
print("Computing shortest path...")
M = opencl_file.TSP_GPU(rho=rho_exp, d=d_exp, N=N_exp, distanceMatrix=dMat,
alpha=alpha_exp, init=init_exp,
graphics=False, loc=loc)
def test_user_agent_custom(self):
geocoder = ArcGIS(user_agent='my_user_agent/1.0')
self.assertEqual(geocoder.headers['User-Agent'], 'my_user_agent/1.0')
def Findall(place):
headers = requests.utils.default_headers()
headers.update({
'User-Agent':
'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0',
})
reqStatus = req = requests.get(
"https://www.yelp.com/search?find_desc=Restaurants&find_loc={}".format(
place),
headers=headers).status_code
print(reqStatus)
if reqStatus == 200:
pass
else:
return "fail"
req = requests.get(
"https://www.yelp.com/search?find_desc=Restaurants&find_loc={}".format(
place),
headers=headers)
content = req.content
soup = BeautifulSoup(content, "html.parser")
List = soup.find_all(
"div", {
"class":
"lemon--div__373c0__1mboc largerScrollablePhotos__373c0__3FEIJ arrange__373c0__UHqhV border-color--default__373c0__2oFDT"
})
try:
Pages = soup.find(
"div", {
"class":
"lemon--div__373c0__1mboc u-padding-b2 border-color--default__373c0__2oFDT text-align--center__373c0__1l506"
}).find("span").text
except:
print("Do Not server here yet Try again later! ")
return "fail"
try:
Pages = (int(Pages.text[-3:]))
except:
Pages = 1
Pages = Pages / (Pages / 1.5)
Pages = round(Pages)
print(Pages)
List_of_values = []
# print(List)
for Page in range(0, Pages * 30, 30):
req = requests.get(
"https://www.yelp.com/search?find_desc=Restaurants&find_loc={}&start={}"
.format(place, Page),
headers=headers)
content = req.content
soup = BeautifulSoup(content, "html.parser")
List = soup.find_all(
"div", {
"class":
"lemon--div__373c0__1mboc largerScrollablePhotos__373c0__3FEIJ arrange__373c0__UHqhV border-color--default__373c0__2oFDT"
})
i = 0
for items in List:
d = {}
try:
d["Headings"] = items.find(
"h3", {
"lemon--h3__373c0__sQmiG heading--h3__373c0__1n4Of alternate__373c0__1uacp"
}).find("a").text
except:
d["Headings"] = "None"
try:
d["Address"] = items.find(
"address", {
"class": "lemon--address__373c0__2sPac"
}).text
except:
d["Address"] = "None"
try:
d["Phone"] = items.find(
"p", {
"class":
"lemon--p__373c0__3Qnnj text__373c0__2pB8f text-color--normal__373c0__K_MKN text-align--right__373c0__3ARv7"
}).text
except:
d["Phone"] = "None"
try:
d["Ratings"] = items.find(
"div", {
"class":
"lemon--div__373c0__1mboc attribute__373c0__1hPI_ display--inline-block__373c0__2de_K u-space-r1 border-color--default__373c0__2oFDT"
}).find("div").get("aria-label")
i = i + 1
except:
d["Ratings"] = "None"
List_of_values.append(d)
df = pandas.DataFrame(List_of_values)
Arc = ArcGIS()
try:
df["Address"] = df["Address"] + "," + place
df["Coordinate"] = df["Address"].apply(Arc.geocode)
df["Longitude"] = df["Coordinate"].apply(lambda x: x.longitude
if x != None else "None")
df["Latitude"] = df["Coordinate"].apply(lambda x: x.latitude
if x != None else "None")
except:
return "fail"
ratingsNum = []
def Convo(r):
for x in r:
try:
try:
ratingsNum.append(float(x[:4]))
except:
ratingsNum.append(float(x[:3]))
except:
pass
ratings = list(df["Ratings"])
Convo(ratings)
def ratColor(r):
r = float(r)
if r > 4:
return "green"
elif 3 < r < 4:
return "beige"
else:
return "red"
Lati = list(df["Latitude"])
Longi = list(df["Longitude"])
Hedi = list(df["Headings"])
Addi = list(df["Address"])
map = folium.Map(location=[Lati[0], Longi[0]],
zoom_start=15,
tiles="Stamen Terrain")
html = """
<h5>Name: %s</h5>
<div>Ratings: %s Stars<div>
<div>Address: %s<div>
"""
fgv = folium.FeatureGroup(name="Main")
for lat, lon, tit, rating, add in zip(Lati, Longi, Hedi, ratingsNum, Addi):
iframe = folium.IFrame(html=html % (tit, rating, add),
width=200,
height=100)
fgv.add_child(
folium.Marker(location=[lat, lon],
popup=folium.Popup(iframe),
icon=folium.Icon(color=ratColor(rating),
icon='info-sign')))
map.add_child(fgv)
place = place.lower()
place = place.replace(" ", "")
dateString = datetime.today().strftime("%Y-%m-%d")
# this is when a new Map is created it is called !
sav.saveVal(dateString, place, 10)
map.save("static/maps/map-{}-{}.html".format(place, dateString))
return "pass"
# gazstao 2019-11-16 20h
import folium
from geopy.geocoders import ArcGIS
from datetime import datetime
endereco = "Vicente Spisla, 238, Curitiba"
alcance = 11
escala = 250
zoom = 15
coordenadas = ArcGIS()
local = coordenadas.geocode(endereco)
fg = folium.FeatureGroup(name="Aztech LABS")
fg.add_child(folium.Marker(location = [local.latitude,local.longitude], popup="AztechLABS CWB!", icon = folium.Icon(color="green")))
#fg.add_child(folium.RegularPolygonMarker(location = [local.latitude,local.longitude], popup="AztechLABS CWB!", icon = folium.Icon(color="green")))
#fg.add_child(folium.CircleMarker(location = [local.latitude,local.longitude], popup="AztechLABS CWB!", icon = folium.Icon(color="green")))
#fg.add_child(folium.Marker(location = [local.latitude,local.longitude], popup="AztechLABS CWB!", icon = folium.Icon(color="green")))
latstart = local.latitude-(alcance/escala)/2
lonstart = local.longitude-(alcance/escala)/2
for longitude in range(alcance):
for latitude in range(alcance):
lat = latstart+latitude/escala
lon = lonstart+longitude/escala
if not ( local.latitude == lat and local.longitude == lon):
fg.add_child(folium.Circle(location = [lat,lon],popup = "{} {}".format(lat,lon),radius=5))
'улица Семашко, 22, Нижний Новгород, Нижегородская обл., 603155',
'Ванеева улица, 127, Нижний Новгород, Нижегородская обл., 603105',
'улица Салганская, 10, Нижний Новгород, Нижегородская обл., 603105',
'проспект Гагарина, 23, к.5, Нижний Новгород, Нижегородская обл., 603022',
'улица Костина, 4, Нижний Новгород, Нижегородская обл., 603000',
'Гагарина проспект 23/6, Нижний Новгород, Нижегородская обл., 603022',
'улица Медицинская, 5А, Нижний Новгород, Нижегородская обл., 603104',
'улица Героя Шапошникова, 5, Нижний Новгород, Нижегородская обл., 603009',
'улица Маршала Голованова, 21, Нижний Новгород, Нижегородская обл., 603107',
'улица Журова, 2, Нижний Новгород, Нижегородская обл., 603011',
'Московское шоссе, 31, Нижний Новгород, Нижегородская обл., 603116',
'улица Марата, 51, Нижний Новгород, Нижегородская обл., 603002',
'проспект Гагарина, 176, Нижний Новгород, Нижегородская обл., 603009',
'улица Нартова, 6к6, Нижний Новгород, Нижегородская обл., 603104', ]}
geolocator = ArcGIS(user_agent="specify_your_app_name_here")
received_locations = dict.fromkeys(desired_locations.keys())
for wt in desired_locations.keys():
addresses = desired_locations[wt]
received_locations[wt] = dict.fromkeys(addresses)
for adr in addresses:
location = geolocator.geocode(adr)
received_locations[wt][adr] = [location.latitude, location.longitude]
def create_row(received_loc, build_type, row_name):
human_addr = received_loc[0].split(',')
coords = received_loc[1]
row = pd.Series(index=buildings.columns, data=None)
row['addr:housenumber'] = human_addr[1].strip()
row['addr:street'] = human_addr[0].strip()
import folium
import pandas
from geopy.geocoders import ArcGIS
from pathlib import Path
loc_obj = ArcGIS()
base_loc = list(loc_obj.geocode("India"))
map = folium.Map(location=base_loc[1], zoom_start=5, tiles='OpenStreetMap')
data = pandas.read_csv("data/pop2020.csv")
current_pop = list(data["Population"])
countries_list = list(data["Country"])
latitude = list(data["Latitude"])
longitude = list(data["Longitude"])
density = list(data["Density"])
feat_group_north = folium.FeatureGroup("Northern Hemisphere")
feat_group_south = folium.FeatureGroup("Southern Hemisphere")
feat_group_polygons = folium.FeatureGroup("Shape")
for lat, lon, country, population in zip(latitude, longitude, countries_list,
current_pop):
# pop_str = "{:,}".format(population)
popup_str = "{} : {:,}".format(country, population)
if lat >= 0:
feat_group_north.add_child(
folium.CircleMarker(location=[lat, lon],
radius=5,
popup=popup_str,
fill_color='red',
def test_config_error(self):
"""
ArcGIS.__init__ invalid authentication
"""
with self.assertRaises(exc.ConfigurationError):
ArcGIS(username='******')
msg['Subject'] = SUBJECT
msg['From'] = Sender
msg['To'] = Recp
# Send the message via the SMTP server
Host = "smtp.utah.edu"
s = smtplib.SMTP(Host)
s.sendmail(Sender, Recp, msg.as_string())
s.quit()
os.remove(inputFile)
#Set Up Workspace
workspace = arcpy.env.workspace = r"\\ad.utah.edu\sys\FM\gis\ags_10_3\ags_content\sde_connection_files\sdeadmin@FM-GISSQLHA_DEFAULT_VERSION.sde"
arcpy.env.overwriteOuput = True
geocoder = ArcGIS()
#Input Data
gisOffsiteLocations = r"\\ad.utah.edu\sys\FM\gis\ags_10_3\ags_content\sde_connection_files\sdeadmin@FM-GISSQLHA_DEFAULT_VERSION.sde\UUSD.DBO.network\UUSD.DBO.offsite_locations"
networkOffsiteLocations = r'\\ad.utah.edu\sys\FM\gis\ags_10_3\ags_content\sde_connection_files\Orion_GISView.sde\GIS.dbo.Offsite_Locations'
inputFile = r'\\ad.utah.edu\sys\FM\gis\gis_scheduled_tasks\nw_offsite.txt'
gisOffsiteList = []
networkOffsiteList = []
try:
#create list of offsite network buildings
sc = arcpy.SearchCursor(networkOffsiteLocations)
for row in sc:
networkOffsiteList.append(row.BuildingNumber)
del row
del sc
import pandas as pd
from geopy.geocoders import ArcGIS
df = pd.read_csv('supermarkets.csv')
nom = ArcGIS()
df['Full_Address'] = df['Address'] + ', ' + df['City'] + ', ' + df['State']
df['Coordinates'] = df['Full_Address'].apply(nom.geocode)
df['Latitude'] = df['Coordinates'].apply(lambda x: x.latitude
if x != None else None)
df['Longitude'] = df['Coordinates'].apply(lambda x: x.longitude
if x != None else None)
print(df)
print(df.Full_Address)
#!/usr/bin/env python
'''
Udemy Python Class: Experimenting with Pandas
'''
import pandas
from geopy.geocoders import ArcGIS
NOM = ArcGIS()
F = "E:\\Documents\\Scripts\\Udemy Classes\\UdemyPython\\Application 2\\PandasCSV\\supermarkets.csv"
DATAFRAME = pandas.read_csv \
(F)
DATAFRAME["Address"] = DATAFRAME["Address"] + ", " + DATAFRAME[
"City"] + ", " + DATAFRAME["State"] + ", " + DATAFRAME["Country"]
DATAFRAME["Coordinates"] = DATAFRAME["Address"].apply(NOM.geocode)
DATAFRAME["Latitude"] = DATAFRAME["Coordinates"].apply(lambda x: x.latitude
if x != None else None)
DATAFRAME["Longitude"] = DATAFRAME["Coordinates"].apply(lambda x: x.longitude
if x != None else None)
print(DATAFRAME)
#Work: U:\\Documents\\GitCode\\UdemyPython\\Application 2\\PandasCSV\\supermarkets.csv
#Home: E:\\Documents\\Scripts\\Udemy Classes\\UdemyPython\\Application 2\\PandasCSV\\supermarkets.csv
'''
dataFrame = pandas.DataFrame([[2, 4, 6], [10, 20, 30]], columns = ["Col 1", "Col 2", "Col 3"], index = ["First", "Second"])
print(dataFrame)
'''
#dataFrame = pandas.DataFrame(pandas.read_csv("E:\\Documents\\Scripts\\Udemy Classes\\UdemyPython\\Application 2\\PandasCSV\\supermarkets.csv"))
