def main(zips):
featfile='../../../../Data/Model_Runs/Model_15sept.pkl'
df=pd.read_pickle(featfile)
#load model
regzips=df['zip'].values
slope=df['slope'].values
ints=df['intercept'].values
idzips=[np.where(regzips==z)[0][0] for z in zips if z in regzips]
clf = joblib.load('../../../../Data/Model_Runs/LinearRegression.pkl')
#build inputs
ip1=slope[idzips]
flag=np.where(np.isnan(ip1))
ip=ip1[~np.isnan(ip1)]
ip=np.reshape(ip,[ip.shape[0],1])
#run model
op=clf.predict(list(ip))
op=samNormalize(op)
#return ZipCodeDatabase
zipnew=np.asarray(zips)
zips=regzips[idzips][np.where(op>1.1)]
zjson=[]
zcdb=ZipCodeDatabase()
for zid in zips:
z=zcdb[zid]
temp= {'lat': z.latitude, 'lng': z.longitude, 'name':z.city}#'zip':int(z.zip),
zjson.append(temp)
# zjson=zjson.append(dict({'zip':z.zip, 'lat': z.latitude, 'lon': z.longitude}))
# print str(json.dumps(zjson))
return json.dumps(zjson)
def serviceAbilityScoreAlgorithm(target,distance,CollegeEnrollment,GapCompany,GapLibrary):
from pyzipcode import ZipCodeDatabase
zcdb = ZipCodeDatabase()
DF=pd.DataFrame(columns=['Zip','zip'])
center=target['Zip'].unique()
for i in center:
in_radius=[z.zip for z in zcdb.get_zipcodes_around_radius(i,distance)] # ('ZIP', radius in miles)
df=pd.DataFrame({'zip':in_radius})
df['Zip']=i
DF=DF.append(df,ignore_index=True)
school_college_distance=Distance(target,CollegeEnrollment,DF)
writerschool_college_distance=pd.ExcelWriter('school_college_distance.xlsx')
school_college_distance.to_excel(writerschool_college_distance,index=False)
school_company_distance=Distance(target,GapCompany,DF)
writerschool_company_distance=pd.ExcelWriter('school_company_distance.xlsx')
school_company_distance.to_excel(writerschool_company_distance,index=False)
school_library_distance=Distance(target,GapLibrary,DF)
writerschool_library_distance=pd.ExcelWriter('school_library_distance.xlsx')
school_library_distance.to_excel(writerschool_library_distance,index=False)
ServiceAbilityIndexCollegeNearby=serviceAbilityIndexCollegeMap(school_college_distance,0,200,1000)
ServiceAbilityIndexCompanyNearby=serviceAbilityIndexCompanyMap(school_company_distance,0,200,1000)
ServiceAbilityIndexHostNearby=serviceAbilityIndexLibraryMap(school_library_distance,1,5)
ServiceAbilityIndexScore=ServiceAbilityIndexCollegeNearby.merge(ServiceAbilityIndexCompanyNearby,on='Code',left_index=True).merge(ServiceAbilityIndexHostNearby,on='Code',left_index=True)
ServiceAbilityIndexScore['ServiceAbilityIndexTotalScore']=ServiceAbilityIndexScore.apply(lambda row: row.ServiceabilityIndexCollegeNearby+row.ServiceabilityIndexCompanyNearby+row.ServiceabilityIndexLibraryNearby,axis=1)
target=ServiceAbilityIndexScore[ServiceAbilityIndexScore.ServiceAbilityIndexTotalScore>=100].sort_values(['ServiceAbilityIndexTotalScore'],ascending=[False]).reset_index(drop=True)
return target
def clean(self):
super().clean()
# validate applicant date of birth
zip_code = self.cleaned_data.get('zip_code', None)
applicant_dob = self.cleaned_data.get('dob', None)
policy = self.cleaned_data.get('policy_type',None)
if applicant_dob and policy:
applicant_age = self._process_dob_for_age(applicant_dob)
if applicant_age < 18 and self.cleaned_data['policy_type'] == 'Family':
self.cleaned_data['dob'] = ''
self.add_error('dob', forms.ValidationError(
_("for policy type family, minimum age must be 18"),
code='invalid'
))
if applicant_age < 2 and self.cleaned_data['policy_type'] == 'Self':
self.cleaned_data['dob'] = ''
self.add_error('dob', forms.ValidationError(
_("for policy type Self, minimum age must be 2"),
code='invalid'
))
if zip_code:
try:
self.cleaned_data['state'] = ZipCodeDatabase()[zip_code].state
except IndexError as err:
pass
return self.cleaned_data
def __init__(self, key, city='San Francisco'):
"""
The construct for the YelpCity class.
Parameters
----------
key : str
The yelp API key needed to call Yelp Fusion API.
city : str
The city to search over.
"""
api_host = 'https://api.yelp.com'
search_path = '/v3/businesses/search'
business_path = '/v3/businesses/'
zcdb = ZipCodeDatabase()
url = api_host + search_path
header = {
'Authorization': 'Bearer %s' % key,
}
param = {
'location': city,
'limit': 1,
'offset': 0,
'term': 'restaurants',
'sort_by': 'best_match',
}
response = requests.get(url=url, headers=header, params=param)
self.business_id_set = set()
self.business_list = []
for zip_obj in zcdb.find_zip(city=city):
self.business_list += self.find_businesses(zip_obj, url, header)
self.region = response.json()['region']
def fake_df():
zcdb = ZipCodeDatabase()
zipcodes = zcdb.get_zipcodes_around_radius(94533, 20)
cities = [z.city for z in zipcodes]
zipcodes = [z.zip+"," for z in zipcodes]
zips_and_cities_df = pd.DataFrame({"zip": zipcodes, "city": cities})
zips_and_cities_df = zips_and_cities_df.groupby("city", as_index=False).agg(sum)
df = from_exported(3)
ints_to_cols = {i: df.columns[i] for i in range(df.shape[1])}
dfs = []
for _, row in zips_and_cities_df.iterrows():
df = fake_pm_for_zipcode(row.zip, row.city)
dfs.append(df)
df = pd.concat(dfs)
df.sort_index(axis=1, inplace=True)
df.columns = [ints_to_cols[i] for i in range(df.shape[1])]
df.rename({"Unnamed: 3": ""}, axis=1, inplace=True)
df.to_csv('/tmp/faked_pms.csv', index=False)
return df
def search_caregivers(request, *args, **kwargs):
context = {}
# zcdb = ZipCodeDatabase()
# in_radius = [z.zip for z in zcdb.get_zipcodes_around_radius('90007', 8)] # ('ZIP', radius in miles)
# radius_utf = [x.encode('UTF-8') for x in in_radius] # unicode list to utf list
# context['data'] = radius_utf
# zip, gender, radius
if request.method == 'POST':
zip_code = request.POST['zip']
radius = int(request.POST['radius'])
zcdb = ZipCodeDatabase()
in_radius = [
z.zip for z in zcdb.get_zipcodes_around_radius(zip_code, radius)
] # ('ZIP', radius in miles)
#radius_utf = [x.encode('UTF-8') for x in in_radius] # unicode list to utf list
radius_arr = [
x.encode('utf-8').decode('unicode-escape') for x in in_radius
]
caregivers = Caregiver.objects.filter(zip_code__in=radius_arr)
context['caregivers'] = caregivers
context['isPostRequest'] = True
else:
context['caregivers'] = []
context['isPostRequest'] = False
return render(request, 'search_caregivers.html', context)
def dashboard(request):
zipcode = request.GET.get('zip_code')
if zipcode:
zcdb = ZipCodeDatabase()
try:
profiles = Profile.objects.filter(
is_teacher=True,
zip_code__in=[
z.zip
for z in zcdb.get_zipcodes_around_radius(zipcode, 10)
])
except Exception as e:
logging.error(traceback.format_exc())
profiles = Profile.objects.filter(phone_number=0)
# Logs the error appropriately.
else:
profiles = Profile.objects.filter(is_teacher=True)
page = request.GET.get('page', 1)
paginator = Paginator(profiles, 10)
try:
profiles = paginator.page(page)
except PageNotAnInteger:
profiles = paginator.page(1)
except EmptyPage:
profiles = paginator.page(paginator.num_pages)
context = {'profiles': profiles}
return render(request, 'account/dashboard.html', context)
def get_zip(b):
zcdb = ZipCodeDatabase()
zipcode = zcdb[b]
longi = zipcode.longitude
Lati = zipcode.latitude
cord = str(longi) + ',' + str(Lati)
return cord
def search_distance(self, search_zip):
zcdb = ZipCodeDatabase()
customer_zip = zcdb[search_zip]
customer_location = [customer_zip.latitude, customer_zip.longitude]
location_distance = distance.distance(self.location,
customer_location).mi
rounded_distance = round(location_distance, 1)
self.search_distance = rounded_distance
def get_nct_list_from_zip(input_zip, mile_range=50):
zcdb = ZipCodeDatabase()
zip_list = [
z.zip for z in zcdb.get_zipcodes_around_radius(input_zip, mile_range)
] # default mile range set at 100
conn = general_pool_criteria.connection()
cur = conn.cursor()
# conn.execute("USE trial_knowledge_base_COVID19") ##
sql = '''
;with cte (code, DeclarationItem, Declaration) as
(
select nct_id,
cast(left(zip_codes, charindex('|',zip_codes+'|')-1) as varchar(50)) DeclarationItem,
stuff(zip_codes, 1, charindex('|',zip_codes+'|'), '') Declaration
from dbo.aact_trial_info
union all
select code,
cast(left(Declaration, charindex('|',Declaration+'|')-1) as varchar(50)) DeclarationItem,
stuff(Declaration, 1, charindex('|',Declaration+'|'), '') Declaration
from cte
where Declaration > ''
)
select code as nct_id, DeclarationItem as zip
from cte
order by nct_id asc
option (maxrecursion 0);
'''
cur.execute(sql)
trial_zips = cur.fetchall()
cur.close()
conn.close()
# compare nearby zip codes to trial zip codes
nearby_nct_list = []
for item in trial_zips:
test_nct = item[0]
if item[1] is not None:
test_zip = item[1].split('-')[0]
else:
test_zip = 00000
if test_zip in zip_list:
nearby_nct_list.append(
test_nct
) # some zip codes stored with '-xxxx' after primary 5 digit, pyzipcode no like that
nearby_nct_list = list(set(nearby_nct_list))
# temp loop to add trial number, to be removed in the future
temp_return_list = []
i = 1
for item in nearby_nct_list:
temp_return_list.append('%s;%d' % (item, i))
i += 1
# return temp_return_list
# fengyang: also return the nearby zipcode list
return [temp_return_list, zip_list]
def find_neighbors_str(store_zip1, radius=5):
zcdb = ZipCodeDatabase()
in_radius = []
for neighbors in zcdb.get_zipcodes_around_radius(store_zip1, radius):
in_radius.append(neighbors.zip)
zipcode_reach2 = find_neighbors_list(store_zip, radius=radius)
return (list(set(in_radius).difference(set(zipcode_reach2))))
def find_neighbors_list(store_zip, radius=5):
zcdb = ZipCodeDatabase()
in_radius = []
for sz in store_zip:
for neighbors in zcdb.get_zipcodes_around_radius(sz, radius):
in_radius.append(neighbors.zip)
zipcode_reach = list(set(in_radius)) # remove dupplicate zipcode
return (zipcode_reach)
def get_zipcodes_in_radius():
zipcode_input = get_zipcode_input() #getting zipcode from input
if not zipcode_input:
return None
radius = get_search_radius() #getting radius from input
zcdb = ZipCodeDatabase() #using zipCodeDatabase
try:
in_radius = [z.zip for z in zcdb.get_zipcodes_around_radius(zipcode_input, radius)] #('ZIP', radius in miles)
return in_radius
except Exception: #catch when zipcode is not found in database
show_error_message(self, "Inputted zipcode was not found")
def search_caregivers(request, *args, **kwargs):
context = {}
context['user_type'] = request.session['user_type']
# zcdb = ZipCodeDatabase()
# in_radius = [z.zip for z in zcdb.get_zipcodes_around_radius('90007', 8)] # ('ZIP', radius in miles)
# radius_utf = [x.encode('UTF-8') for x in in_radius] # unicode list to utf list
# context['data'] = radius_utf
# zip, gender, radius
if request.method == 'POST':
zip_code = request.POST['zip']
radius = int(request.POST['radius'])
zcdb = ZipCodeDatabase()
# start_date = datetime.datetime.strptime(request.POST['start_date'], "%Y-%m-%d").date()
# end_date = datetime.datetime.strptime(request.POST['end_date'], "%Y-%m-%d").date()
# availability = request.POST['availability']
# in_radius = [z.zip for z in zcdb.get_zipcodes_around_radius(zip_code, radius)] # ('ZIP', radius in miles)
# # radius_utf = [x.encode('UTF-8') for x in in_radius] # unicode list to utf list
# radius_arr = [x.encode('utf-8').decode('unicode-escape') for x in in_radius]
# # radius_arr = 10 #added 28/10
# # caregivers = Caregiver.objects.filter(zip_code__in = radius_arr)
# caregivers = Caregiver.objects.filter(zip_code__in = radius_arr, availability=availability, start_date__lte=start_date, end_date__gte=end_date)
start_date = datetime.datetime.strptime(
request.POST['start_date'],
"%Y-%m-%d").date() if request.POST['start_date'] != '' else ''
end_date = datetime.datetime.strptime(
request.POST['end_date'],
"%Y-%m-%d").date() if request.POST['end_date'] != '' else ''
availability = request.POST[
'availability'] if request.POST['availability'] != '' else ''
if zip_code.strip() != '':
in_radius = [
z.zip
for z in zcdb.get_zipcodes_around_radius(zip_code, radius)
] # ('ZIP', radius in miles)
radius_arr = [
x.encode('utf-8').decode('unicode-escape') for x in in_radius
]
else:
radius_arr = []
print(start_date, end_date, "datessssss")
# caregivers = Caregiver.objects.filter(zip_code__in = radius_arr) | Caregiver.objects.filter(availability=availability) | Caregiver.objects.filter(start_date__lte=start_date,end_date__gte=end_date )
caregivers = Caregiver.objects.filter(zip_code__in=radius_arr,
availability=availability,
start_date__lte=start_date,
end_date__gte=end_date)
context['caregivers'] = caregivers
context['isPostRequest'] = True
else:
context['caregivers'] = []
context['isPostRequest'] = False
return render(request, 'search_caregivers.html', context)
def get_city_data(zipc):
"""Given a zip code, return latlon and city name"""
geolocator = ZipCodeDatabase()
try:
zip_data = geolocator[str(zipc)]
lat = zip_data.latitude
lon = zip_data.longitude
name = '%s, %s' % (zip_data.city, zip_data.state)
return lat, lon, name
except:
return 'None', 'None', 'None'
def tz_ids_for_address(country, state=None, city=None, zipcode=None, **kwargs):
""" Get the TZ identifiers for a given address, e.g.:
>>> tztrout.tz_ids_for_address('US', state='CA', city='Palo Alto')
[u'America/Los_Angeles']
>>> tztrout.tz_ids_for_address('PL')
[u'Europe/Warsaw']
>>> tztrout.tz_ids_for_address('CN')
[
u'Asia/Shanghai',
u'Asia/Harbin',
u'Asia/Chongqing',
u'Asia/Urumqi',
u'Asia/Kashgar'
]
"""
if country == 'US':
if zipcode:
if not isinstance(zipcode, basestring):
zipcode = str(zipcode)
# If an extended zipcode in a form of XXXXX-XXXX is provided,
# only use the first part
zipcode = zipcode.split('-')[0]
return td.us_zip_to_tz_ids.get(zipcode)
elif state or city:
if city and 'city:%s' % city.lower() in data_exceptions:
return data_exceptions['city:%s' % city.lower()]['include']
if len(state) != 2:
state = td.normalized_states['US'].get(state.lower(), state)
zcdb = ZipCodeDatabase()
zipcodes = zcdb.find_zip(city=city,
state=state,
exact=True,
limit=1)
if zipcodes:
return td.us_zip_to_tz_ids.get(zipcodes[0].zip)
elif city is not None:
zipcodes = zcdb.find_zip(state=state, exact=True, limit=1)
if zipcodes:
return td.us_zip_to_tz_ids.get(zipcodes[0].zip)
elif country == 'CA' and state:
if len(state) != 2:
state = td.normalized_states['CA'].get(state.lower(), state)
return td.ca_state_to_tz_ids.get(state)
elif country == 'AU' and state:
if len(state) != 2:
state = td.normalized_states['AU'].get(state.lower(), state)
return td.au_state_to_tz_ids.get(state)
return pytz.country_timezones.get(country)
def eventbrite_api(request):
profile = Profile.objects.get(user=request.user)
interests = profile.interests.filter(interests__in=['MUSIC', 'TECHNOLOGY', 'COMEDY', 'CAR', 'FOOD', 'SPORTS'])
zcdb = ZipCodeDatabase()
#geocodes users zipcode to use lat and lng in search
zipcode = zcdb[profile.zipcode]
free_times = FreeTimes.objects.filter(user=request.user)
eventbrite_url='https://www.eventbriteapi.com/v3/events/search/?'
for free_time in free_times:
# formats time to match eventbrite api
start_time = "{}Z".format(free_time.free_time_start[:-6])
end_time = "{}Z".format(free_time.free_time_end[:-6])
for interest in interests:
eventbrite_params = {
"token": eventbrite_token,
'popular': True,
'q': str(interest.interests),
'location.latitude': zipcode.latitude,
'location.longitude': zipcode.longitude,
'location.within': '20mi',
'start_date.range_start': start_time,
'start_date.range_end': end_time
}
eventbrite_resp = get(url=eventbrite_url, params=eventbrite_params)
eventbrite_data = json.loads(eventbrite_resp.text)
# Saves returned events to database
for event in eventbrite_data['events']:
formatted_start = event['start']['utc'][:-1] + '-7:00'
formatted_end = event['end']['utc'][:-1] + '-7:00'
# Creates a datetime object from the time returned by Api
datetime_start = dateutil.parser.parse(event['start']['utc'])
datetime_end = dateutil.parser.parse(event['end']['utc'])
Event.objects.create(
name=event['name']['text'],
category=interest.interests,
venue=event['venue']['name'],
description=event['description']['text'],
latitude=event['venue']['latitude'],
longitude=event['venue']['longitude'],
start_time=formatted_start,
end_time=formatted_end,
picture=event['logo_url'],
event_url=event['url'],
user=request.user,
start_dateTime=datetime_start,
end_dateTime=datetime_end
)
success = {'success': 'success'}
return HttpResponse(json.dumps(success), content_type="application/json")
def zipcode_coordinates(zipcd):
print zipcd
zcdb = ZipCodeDatabase()
try:
zipcode = zcdb[zipcd]
coordinates = (zipcode.latitude, zipcode.longitude)
except IndexError:
if zipcd == '60290':
coordinates = (41.881, -87.6247)
else:
coordinates = (np.nan, np.nan)
return coordinates
def getCiti(self):
""" write the city and state given the postcode"""
if self.postcode:
zcdb = ZipCodeDatabase()
regexp = re.compile(r'-\d*')
try:
postcode = re.sub(regexp, "", self.postcode)
zipcode = zcdb[postcode]
self.citi = zipcode.city
self.state = zipcode.state
except:
self.citi = "NA-citi"
self.state = "NA-state"
def state_from_zip(zipcode):
try:
zip_info = ZipCodeDatabase()[zipcode]
except IndexError:
return None
if zip_info.city in ('APO', 'FPO', 'DPO'):
# we cannot lookup state names for APO/FPO/DPO zipcodes;
# probably we need better handling in audb for military PO addresses
return zip_info.state
state = us.states.lookup(zip_info.state)
return state.name if state else None
def post(self):
# force to accept only JSON posted data
try:
data = request.get_json(force=True)
except Exception as err:
return {'error': settings.INVALID_JSON}, 400
# make sure user has submitted JSON data i.e list of zip codes. Format: {"zip_codes": ["44000", "10008"]}
if data and data.get('zip_codes') and isinstance(
data.get('zip_codes'), list):
try:
# get user's Geo Data from user's IP address
g = geocoder.ip(request.remote_addr)
except Exception as err:
return {'error': settings.CONNECTION_ERROR}, 400
# if user is from local machine instead of a real IP (server machine) then get user's real IP address
if g.ip == '127.0.0.1':
user_ip = urlopen('http://ip.42.pl/raw').read()
# get user's Geo Data from user's IP address
g = geocoder.ip(user_ip)
user_lat_lng = g.lat, g.lng
result = dict()
# iterate through each zip code and calculate distance relative to user's lat, long
for zip_code in data.get('zip_codes', []):
# This package contains geo data for US zip codes only.
zcdb = ZipCodeDatabase()
try:
# get zip code's Geo Data for lat, long
zip_code_data = zcdb[zip_code]
zip_code_lat_lng = zip_code_data.latitude, zip_code_data.longitude
"""
Calculate the geodesic distance between two points using the formula devised by Thaddeus Vincenty,
with an accurate ellipsoidal model of the earth. using geopy package
"""
distance = round(
vincenty(zip_code_lat_lng, user_lat_lng).miles, 2)
result[zip_code] = '{0} Miles'.format(distance)
except IndexError as err:
result[zip_code] = settings.INVALID_ZIP_CODE
return result, 200
else:
return {'error': settings.INVALID_JSON}, 400
def create_data_table(state_choose='MA',
radius=5,
Number=0,
tran_type=['Sale', 'Return'],
min_date=min_date1,
max_date=max_date1):
zip_dict = {}
sea_zipcode = result['ShipToZipCode'][result['State'] ==
state_choose].unique().tolist()
try:
sea_zipcode.remove('00000')
except:
pass
zipcode_reach2 = find_neighbors_list(store_zip, radius=radius)
# add more parameter here
ecom_filter = result[(result['TransactionType'].isin(tran_type))
& (result['TheDate'] >= min_date) &
(result['TheDate'] <= max_date)][[
'ShipToZipCode', 'Transactions'
]].groupby('ShipToZipCode').sum()
try:
for i in sea_zipcode:
zcdb = ZipCodeDatabase()
in_radius = []
for neighbors in zcdb.get_zipcodes_around_radius(i, radius):
in_radius.append(neighbors.zip)
zipcode_reach_search = list(
set(in_radius).difference(set(zipcode_reach2)))
zip_dict[i] = ecom_filter[ecom_filter.index.isin(
zipcode_reach_search)]['Transactions'].sum()
except:
pass
predict1 = pd.DataFrame.from_dict(zip_dict,
orient='index',
columns=['Transactions'
]).sort_values('Transactions',
ascending=False)
store_future_zip = predict1.index
store_future = table_from_zipcodelist(list(store_future_zip))
store_future['Transactions'] = predict1['Transactions'].tolist()
return ColumnDataSource(store_future)
class UrlBuilder(object):
"""Build URL list for CareerBuilder searches"""
zcdb = ZipCodeDatabase()
def __init__(self, zipcode, search=None):
"""Validate zipcode, prompt user for all query parameters"""
self.search = search
try:
# Check zipcode DB for valid zip
self.zcdb[zipcode]
except IndexError:
# Default to Baltimore Catalyte office zipcode
print 'Invalid zipcode code. Defaulting to 21201'
self.zipcode = '21201'
else:
self.zipcode = zipcode
self.base = 'http://www.careerbuilder.com/'
self.params = []
self.params.append(Posted.cmd_append())
self.params.append(Radius.cmd_append())
self.params.append(Pay.cmd_append())
self.params.append(Emp.get_formatted())
def build_url(self):
"""Add path and query parameters based on filters specified by user"""
if not self.has_filters():
return '{}{}?cat1=JN008'.format(self.base, self.build_path())
else:
return '{}{}{}&cat1=JN008'.format(self.base, self.build_path(), self.format_filters())
def build_path(self):
"""Compose URL substring for endpoint path"""
if not self.search or not self.search.split():
return 'jobs-in-{}'.format(self.zipcode)
else:
return 'jobs-{}-in-{}'.format('-'.join(self.search.split()), self.zipcode)
def has_filters(self):
"""Check for user input query parameters"""
if any(param is not None for param in self.params):
return True
else:
return False
def format_filters(self):
"""Compose URL substring for all query parameters"""
base = '?'
for param in self.params:
if param is not None:
base += param + '&'
return base
def zipcode_state(df):
from pyzipcode import ZipCodeDatabase
zip=ZipCodeDatabase()
for i in df[pd.isnull(df['State'])&pd.notnull(df['ZIP code'])].index:
try:
df['State'][i]=str(zip[df['ZIP code'][i]].state)
except:
continue
# fill the rest of the missing values of state and zipcode with string "Not provided"
df['State'].fillna('Not provided',inplace=True)
df['ZIP code'].fillna('Not Provided',inplace=True)
return df
def get_zips_list(center_zipcode, distance):
# use the ZipCodeDatabase package to get a list of zipcodes within the provided radius
try:
zcdb = ZipCodeDatabase()
zip_objects = zcdb.get_zipcodes_around_radius(center_zipcode, distance)
except ZipNotFoundException:
error = "Zip code not found. Please check your zip code and try again."
return error
# grab the .zip property from each returned zipcode object
def get_zip(zipObj):
return zipObj.zip
return list(map(get_zip, zip_objects))
def findCoordinates():
try:
zcdb = ZipCodeDatabase()
code = int(sys.argv[1])
nomi = zcdb[code]
URL = "http://127.0.0.1:" + sys.argv[3] + "/fetchdata"
obj = {
"latitude": nomi.latitude,
"longitude": nomi.longitude,
"username": sys.argv[2]
}
res = requests.post(URL, data=obj)
print(obj)
except:
raise TypeError("Only integers are allowed")
def getWeather(location):
if location.isdigit():
zipData = ZipCodeDatabase()
zipCode = zipData[int(location)]
location = zipCode.city
units = lower(
raw_input(
"What units would you like the temperatur in? ('c' or 'metric' for example): "
))
if units == 'f':
units = 'imperial'
elif units == 'c':
units = 'metric'
check_units(units)
country = "us"
else:
location = quote(location)
units = raw_input(
"What units would you like the temperature in? You may choose 'imperial' or 'metric': "
)
check_units(units)
country = raw_input(
"Please enter the name of country this city is located in. You may also enter its common two letter abbreviation. (Ex: Fr = France, JP = Japan, US = United States: "
)
cnt = raw_input(
"How many days would you like the forecast for? Please enter a number between 1 and 14: "
)
while cnt > 14 and cnt < 1:
print "That is not a valid entry"
cnt = raw_input("Please enter a number between 1 and 14: ")
searchParam = "http://api.openweathermap.org/data/2.5/forecast/daily?q=" + location + "," + country + '&mode=xml&units=' + units + '&cnt=' + cnt
weatherData = urllib2.urlopen(searchParam)
rawData = str(weatherData.read())
root = ET.fromstring(rawData)
forecastHi = []
forecastLo = []
date = []
if units == 'imperial':
degreeUnit = 'F'
else:
degreeUnit = 'C'
for time in root.iter('time'):
date.append(time.attrib['day'])
for temperature in root.iter('temperature'):
forecastHi.append(temperature.attrib['max'])
for temperature in root.iter('temperature'):
forecastLo.append(temperature.attrib['min'])
return location, degreeUnit, forecastHi, forecastLo, date
def getCoords(zipcode):
zcdb = ZipCodeDatabase()
search = SearchEngine()
try:
entry = zcdb[zipcode]
tempZip = zipStruct(zipcode,
entry.latitude,
entry.longitude)
return tempZip
except IndexError:
entry = search.by_zipcode(zipcode)
tempZip = zipStruct(zipcode,
entry.lat,
entry.lng)
return tempZip
def go():
zcdb = ZipCodeDatabase()
stateinput = request.args.get('query', '')
everythingOK = True
# try:
# everythingOK=True
# zips=zcdb.find_zip(state=stateinput)
# zips=[int(z.zip) for z in zips]
# except:
# everythingOK=False
if everythingOK:
predict = Model_Run_22sep.main(stateinput)
else:
predict = 'Input not understood'
# new= [render_template('go.html',query = item) for item in predicttown]
return render_template('go.html', query=predict)
def getzip(x):
zcdb = ZipCodeDatabase()
try:
zipcode = zcdb[x]
now = datetime.datetime.now()
# '2016-07-31'
startDate = now.strftime("%Y-%m-%d")
#print startDate
# zip = zipcode.zip
city = zipcode.city
state = zipcode.state
long = zipcode.longitude
lat = zipcode.latitude
return lat, long, startDate, city, state
except IndexError:
zipcode = 'null'
return zipcode
