def form_valid(request, form):
zcdb = ZipCodeDatabase()
agent1_zipcode = form.cleaned_data['zipcode_agent1']
agent2_zipcode = form.cleaned_data['zipcode_agent2']
agent1, created = Agent.objects.update_or_create(
name='Agent 1',
defaults={'zipcode': agent1_zipcode}
)
agent2, created = Agent.objects.update_or_create(
name='Agent 2',
defaults={'zipcode': agent2_zipcode},
)
nearestzipcode_a1 = []
nearestzipcode_a2 = []
try:
nearestzipcode_a1 = [z.zip for z in zcdb.get_zipcodes_around_radius(agent1_zipcode, DEFAULT_RAIDUS)]
except ZipNotFoundException:
pass
try:
nearestzipcode_a2 = [z.zip for z in zcdb.get_zipcodes_around_radius(agent2_zipcode, DEFAULT_RAIDUS)]
except ZipNotFoundException:
pass
if nearestzipcode_a1 or nearestzipcode_a2:
nearestzipcode_a2 = [x for x in nearestzipcode_a2 if not (x in nearestzipcode_a1)]
contacts_agent1 = Contact.objects.filter(zipcode__in=nearestzipcode_a1).all()
contacts_agent2 = Contact.objects.filter(zipcode__in=nearestzipcode_a2).all()
if contacts_agent1 or contacts_agent2:
data = {
'agent1': agent1,
'contact_agent1': contacts_agent1,
'agent2': agent2,
'contact_agent2': contacts_agent2
}
content = render_to_string('website/matchs-agent-modal.html', data)
context = {
'success': True,
'matchs': content
}
else:
context = {
'hasErrors': False,
'hasMessage': True,
'message': utils.NOT_MATCH_EXIST,
'success': False,
}
else:
context = {
'hasErrors': False,
'hasMessage': True,
'message': utils.NOT_MATCH_EXIST,
'success': False,
}
return utils.render_to_json(context)
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 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 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_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 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 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 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)
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 search_results(request):
query = request.GET.get('query') # grab user query
zcdb = ZipCodeDatabase() # create instance of zip code database object
zipcode = zcdb[
query] # not too sure. Maybe this is a really long list of zip codes and this is how you access one?
zip_codes_in_radius = [
z.zip for z in zcdb.get_zipcodes_around_radius(query, 15)
]
jobs = []
for zip in zip_codes_in_radius:
jobs_in_zip = Job.objects.filter(business__zip_code=zip)
if jobs_in_zip:
jobs += jobs_in_zip
form = JobSeekerEmailForm() # pass email subscription from to template
return render(request, 'job/search_results.html', {
'query': query,
'jobs': jobs,
'form': form
})
def hospital(request):
g = geocoders.GoogleV3()
place, (lat, lng) = g.geocode('Charlotte')
g = geocoder.google([request.GET['latitude'], request.GET['longitude']], method='reverse')
zcdb = ZipCodeDatabase()
conn=connect()
cur=conn.cursor()
zip_list = zcdb.get_zipcodes_around_radius(g.postal, 35)
results=[]
for z in zip_list:
# print z.zip
cur.execute("select f1.provider_id,f1.hospital_name,f2.score from (select * from findhospital_hospitalgeneralinformation where hospital_type='"+ request.GET['type']+" ' and zip_code = '"+ z.zip +"') as f1, findhospital_hospitalperformance f2 where f1.provider_id=f2.provider_id");
for row in cur.fetchall():
results.append(hospitals(row[0],row[1],row[2]))
conn.close()
for i in range( 1, len( results ) ):
obj = results[i]
tmp = results[i].score
print results[i].score
k = i
while k > 0 and tmp > results[k - 1].score:
results[k] = results[k - 1]
k -= 1
results[k]=obj
#for z in zip_list:
# print z.zip
code = read('/home/sairam/Desktop/healthapp/findhospital/templates/results.html')
t= Template(code)
c = Context({'results':results})
return HttpResponse(t.render(c))
def get_weatherInfos_py27(weatherData, stationData, stationName):
## find weather available at the station zipcode, if not available in data, find weather at the closest zipcode(s) nearby
from geopy.geocoders import Nominatim
from pyzipcode import ZipCodeDatabase
geolocator = Nominatim()
(lat, lon) = get_station_coordinates(stationName, stationData)
location = geolocator.reverse((lat, lon))
#print("Address station from coordinates: "+location.address)
zipcode = location.raw['address']['postcode']
#print("Station post code: ", zipcode)
zcDB = ZipCodeDatabase()
stationWeather = pd.DataFrame()
radius = 0
while radius < 10 and stationWeather.shape[0] == 0:
zipNearby = [
int(z.zip)
for z in zcDB.get_zipcodes_around_radius(zipcode, radius)
]
#print(zipNearby)
stationWeather = weatherData[weatherData['Zip'].isin(zipNearby)]
#print("radius: ", radius)
radius += 0.05 ## ?? 50m?, 0.05 miles?
#print("post codes of neighborhood: ", zipNearby)
def fixPrecip(x):
try:
return float(x)
except:
return 0.005 # maybe 0.01 or something?
precipitation_inch = stationWeather[u'PrecipitationIn'].apply(fixPrecip)
temperature_fahrenheit = stationWeather[u'Mean TemperatureF']
temperature_celcius = (temperature_fahrenheit - 32.) / 1.8
precipitation_mm = 25.4 * precipitation_inch ## in millimeters
#sfPrecipitation.max() #[sfPrecipitation != 0.0]
#sfTemp.head
return (precipitation_mm, temperature_celcius)
def accept_all_in_region(db,
collection,
zipcode,
radius,
travel_method,
reimburse_val,
out_file,
group,
overwrite=False):
zcdb = ZipCodeDatabase()
zips = [z.zip for z in zcdb.get_zipcodes_around_radius(zipcode, radius)]
if (overwrite):
query = {'profile.travel.zipcode': {'$in': zips}}
else:
query = {
'profile.travel.zipcode': {
'$in': zips
},
'settings.accepted.flag': False
}
users = db[collection].find(query, {
'_id': 1,
'profile.name': 1,
'emails': 1
})
tot = users.count()
def func(user):
accept_user(db, collection, user['_id'], group, travel_method,
reimburse_val)
if (out_file):
save_users(users, out_file, func)
else:
print_users(users, func)
print('Accepted {0} user{1} witin {2} miles of {3}'.format(
tot, 's' if tot != 1 else '', radius, zipcode))
def getZipCodes(source, radius):
from pyzipcode import ZipCodeDatabase
zcdb = ZipCodeDatabase()
zipcodes = [z.zip for z in zcdb.get_zipcodes_around_radius(source, radius)]
return zipcodes
def _get_close_zips(zipcode=MYZIP):
zcdb = ZipCodeDatabase()
return {int(z.zip) for z in zcdb.get_zipcodes_around_radius(zipcode, 25)}
Then shoots me a text if some become available."""
import json
import requests
import smtplib
import time
from pyzipcode import ZipCodeDatabase
from_email = ""
to_email = ""
password = ""
zdb = ZipCodeDatabase()
in_radius = [z.zip for z in zdb.get_zipcodes_around_radius('68506', 30)]
zip_set = set(in_radius)
# Email/Text stuff
port = 465
session = smtplib.SMTP("smtp.gmail.com", 587)
session.starttls()
session.login("", password)
while True:
r = requests.get("https://www.vaccinespotter.org/api/v0/states/NE.json")
data = r.json()
for feature in data["features"]:
if not feature["properties"]["appointments_available"]:
continue
def execute(trial=False):
startTime = datetime.datetime.now()
# Set up the database connection.
client = dml.pymongo.MongoClient()
repo = client.repo
repo.authenticate('ggelinas', 'ggelinas')
propData = []
for prop in repo['ggelinas.property'].find():
propData.append(prop)
zipval = [(c['mail_zipcode'], (int(c['av_total']))) for c in propData]
totalPropVal = PropertyMean.aggregate(zipval, sum)
zipcount = [(c['mail_zipcode'], 1) for c in propData]
totalZipCount = PropertyMean.aggregate(zipcount, sum)
P = PropertyMean.product(totalPropVal, totalZipCount)
S = PropertyMean.select(P, lambda t: t[0][0] == t[1][0])
CV = PropertyMean.project(S, lambda t: (t[0][0], t[0][1], t[1][1]))
AvgValueZip = [(i[0], (i[1] / i[2])) for i in CV]
# print(AvgValueZip)
repo.dropPermanent("propertymean")
repo.createPermanent("propertymean")
for i in AvgValueZip:
repo['ggelinas.propertymean'].insert({
'zip_code': i[0],
'avg_value': i[1]
})
zcdb = ZipCodeDatabase()
stations = []
stationProperty = []
stationCount = []
for station in repo['ggelinas.stations'].find():
stations.append(station)
for s in stations:
in_radius = [
z.zip for z in zcdb.get_zipcodes_around_radius(
s['location_zip'], 1.61)
]
for zipcode in repo['ggelinas.propertymean'].find():
for i in in_radius:
if zipcode['zip_code'] == i:
stationProperty.append(
(s['location_zip'], zipcode['avg_value']))
stationCount.append((s['location_zip'], 1))
SPS = PropertyMean.aggregate(stationProperty, sum)
SPC = PropertyMean.aggregate(stationCount, sum)
Prod = PropertyMean.product(SPS, SPC)
Sele = PropertyMean.select(Prod, lambda t: t[0][0] == t[1][0])
Proj = PropertyMean.project(Sele, lambda t:
(t[0][0], t[0][1], t[1][1]))
AvgDisProp = [(i[0], (i[1] / i[2])) for i in Proj]
repo.dropPermanent("districtvalue")
repo.createPermanent("districtvalue")
for i in AvgDisProp:
repo['ggelinas.districtvalue'].insert({
'zip_code': i[0],
'avg_value': i[1]
})
repo.logout()
endTime = datetime.datetime.now()
return {"start": startTime, "end": endTime}
def get_zip_near_me(myzip, miles):
"""Shows all zipcodes near you"""
zcdb = ZipCodeDatabase()
in_radius = [z.zip for z in zcdb.get_zipcodes_around_radius(myzip, miles)]
return in_radius
