def extract_information(nct_list):
result_list = []
pure_lat_long_list = []
selected_df = aact_trial[aact_trial['nct_id'].isin(nct_list)]
for index, zipcode, b in zip(selected_df.nct_id, selected_df.zip_codes,
selected_df.brief_title):
if pd.isnull(zipcode) == False:
zipcodelist = zipcode.split('|')
for z in zipcodelist:
z = z[:5]
if zipcodes.matching(z):
current_location = [
zipcodes.matching(z)[0]['lat'],
zipcodes.matching(z)[0]['long']
]
result_list.append([
index,
zipcodes.matching(z)[0]['lat'],
zipcodes.matching(z)[0]['long'], b
])
pure_lat_long_list.append(current_location)
return result_list, pure_lat_long_list
def get(self, request):
username = request.user
records = TrackerRecordSerializer(TrackRecord.objects.filter(user__username=username), many=True).data
covid_cases = CovidCase.objects.latest('timestamp')
zipcode = User.objects.get(username=username).postal_code
local_info = {}
if zipcodes.matching(zipcode):
county = zipcodes.matching(zipcode)[0]['county']
county_name = county.split(' ')[0]
if county_name in covid_cases.counties_json:
local_info['local_cases'] = covid_cases.counties_json[county_name]['total']
local_info['local_deaths'] = covid_cases.counties_json[county_name]['deaths']
return Response(data={
'tracker': records,
'covid_cases': {
**CovidCaseSerializer(covid_cases).data,
**local_info
},
'pollen': {
**get_pollen_data(zipcode)
},
'bewei': {
**self._get_beiwe(username)
}
}, status=status.HTTP_200_OK)
def map(data_visited):
zips = pd.read_csv("data/zips/zips.csv")
unique_zips = []
counties = []
cities = []
states = []
map_of_hikes = folium.Map(location=[34.9, -118.8863],
tiles='Stamen Terrain',
zoom_start=6,
zoom_control=True,
left=75)
for index, row in data_visited.iterrows():
country = row["Location"].split(", ")[-1].lower()
epsilon = 0
if row["Zip"] not in unique_zips:
unique_zips.append(row["Zip"])
if zipcodes.matching(row["Zip"])[0]['county'] not in counties:
counties.append(zipcodes.matching(row["Zip"])[0]['county'])
else:
epsilon = epsilon + random.uniform(0, 1) / 100
if country == "us":
info = zips.loc[zips["Zip"] == int(row["Zip"])]
lat = info["Latitude"] + epsilon
lon = info["Longitude"] + epsilon
else:
# loc = geolocator.geocode(row["Location"] + ", " + row["Zip"])
# lat = loc.latitude
# lon = loc.longitude
pass
text = row["Name"] + "\t" + "Date: " + str(
row["Date"]) + "\t" + "Length: " + str(row["Length"])
folium.Marker(location=[lat, lon],
icon=folium.Icon(color='lightred'),
popup=folium.Popup(text,
max_width=100)).add_to(map_of_hikes)
map_of_hikes.save("temp.html")
with open("map.html", "w") as infile:
with open("header.html", "r") as outfile1:
for line in outfile1:
infile.write(line)
with open("temp.html", "r") as outfile2:
for line in outfile2:
infile.write(line)
infile.close()
outfile1.close()
outfile2.close()
return len(unique_zips), len(counties)
def calculateDistance(zip1, zip2):
zipcode1 = zipcodes.matching(str(zip1))
zipcode2 = zipcodes.matching(str(zip2))
z1 = (float(zipcode1[0]["lat"]), float(zipcode1[0]["long"]))
z2 = (float(zipcode2[0]["lat"]), float(zipcode2[0]["long"]))
dist = mpu.haversine_distance(z1, z2)
dist = round((dist / 2) + (((dist / 2)) / 4), 2)
return dist
def check_restaurant(restaurant):
print('checking restaurant data: {}'.format(restaurant['id']))
restaurant = Restaurant(restaurant['Address'], restaurant['id'],
restaurant['GeoLocation']['Latitude'],
restaurant['GeoLocation']['Longitude'])
try:
zipcode = restaurant.address['PostCode'].encode('UTF-8').strip()
returned_json = zipcodes.matching(zipcode)
except:
zipcode = restaurant.address['PostCode']
if zipcode is None:
restaurant.problem = 'no zipcode'
else:
restaurant.problem = 'zipcode couldn\'t be parsed: {}'.format(
zipcode.encode('UTF-8'))
dirty_restaurants.append(restaurant)
return
if len(returned_json) == 0:
restaurant.problem = 'could not match zipcode: {}'.format(
zipcode.encode('UTF-8'))
dirty_restaurants.append(restaurant)
return
returned_address = returned_json[0]
check_city(restaurant, returned_address)
check_state(restaurant, returned_address)
check_zipcode(restaurant, returned_address)
def get_data_from_zipcode(zipcode):
"""get data from NYT csv based on a zip-code lookup"""
#return -1 if zipcode doesn't exist
if not zipcodes.is_real(zipcode):
return -1
try:
zipcode_result = zipcodes.matching(zipcode)
state = states_code_to_full[zipcode_result[0]['state']]
county = zipcode_result[0]['county'].replace('County', '').strip()
#special case for NYC for NYT data
if "New York" in county:
county = "New York City"
return {
'state':
state,
'county':
county,
'confirmed':
data[data.county == county][data.state == state][['cases']].iat[0,
0],
'deaths':
data[data.county == county][data.state == state][['deaths'
]].iat[0, 0],
}
except:
return -1
def validate_zips(df):
df_out = pd.DataFrame()
for index, row in df.iterrows():
record = zipcodes.matching(row['zip_code'])
if len(record) > 0:
row['validated_state'] = record[0]['state']
row['validated_city'] = record[0]['city']
if row['validated_state'] == row['state'].upper():
row['state_match'] = 'Y'
else:
row['state_match'] = 'N'
if row['validated_city'] == row['city'].upper():
row['city_match'] = 'Y'
else:
row['city_match'] = 'N'
else:
row['validated_state'] = ''
row['validated_city'] = ''
df_out = df_out.append(row)
return df_out
def sanitize_event_payload(payload):
"""
Remove potentially sensitive fields from the Mobilize America API event
response.
This method is required because we fetch events using the authenticated GET
/events API, which can return private fields that we don't want to serve
"""
location = payload.pop("location", None)
address_vis = payload.pop("address_visibility", None)
sanitized = {k: v for k, v in payload.items() if k in __MA_FIELD_WHITELIST}
if address_vis == PUBLIC_VISIBILITY:
sanitized["location"] = location
elif location and location.get("postal_code"):
matching_codes = zipcodes.matching(location.get("postal_code"))
if len(matching_codes) > 0:
zip_code_data = matching_codes[0]
location_from_zip = {
"location": {
"longitude": float(zip_code_data["long"]),
"latitude": float(zip_code_data["lat"]),
}
}
sanitized["location"] = location_from_zip
return sanitized
def begin(self, data):
self.perc_complete(10)
vals, keys = get_args_from_form(data)
try:
zip_code = vals[4]
zips = zipcodes.matching(zip_code)
city = zips[0]['city']
state = zips[0]['state']
except:
city = "not defined"
state = "not defined"
zip_code = "00000"
new_vals = [city, state]
vals += new_vals
new_keys = ['city', 'state']
keys += new_keys
dbactions = DBActions(owner_id=self.id,
table='customer_basic',
keys=keys,
vals=vals)
query = dbactions.update()
query += " WHERE id = %s" % (self.id, )
db.execute(query, False, vals, commit=True)
def zipno(list):
zipnomi = (input('enter zip code in 12345 format pls: '))
if zipnomi == 'state':
pass
else:
while True:
try:
ziplist = len(str(zipnomi))
if ziplist == 5:
zipper =[0]
from pprint import pprint
import zipcodes
zipper[0] = (zipcodes.matching(zipnomi))
if len(zipper[0]) == 0:
print('not there try again')
zipno(list)
else:
list[8] = zipper[0][0]['zip_code']
list[7] = zipper[0][0]['state']
list[6] = zipper[0][0]['city']
else:
print('nooooo')
zipno(list)
except ValueError :
print('Exceptumondo Dude! this thing just takes numbers!!!Try again!')
zipno(list)
break
else:
break
def getForecastData(zipcode, response, dayNum, dayOfWeek):
"""
Use "null" for dayOfWeek param
unless using string format id = 2
"""
# Uses zipcode to get city name and state.
zipCodeInfo = zipcodes.matching(zipcode)
zipCodeInfo = zipCodeInfo[0]
# Store in easy to use variables
city = zipCodeInfo["city"].lower().title()
state = zipCodeInfo["state"]
currentTemp = response["main"]["temp"]
currentTemp = int(currentTemp)
description = response["weather"][0]["description"]
winds = response["wind"]["speed"]
winds = int(winds)
# Take current date's high's and lows
highLow = getHighLows(zipcode, dayNum)
high = highLow[0]
low = highLow[1]
# Forecast array
forecast = [
city, state, currentTemp, description, winds, high, low, dayOfWeek
]
return forecast
def update():
st.write("Bot: " + "What is your zip code?")
code = talk("What is your zip code?")
try:
x = zipcodes.matching(code)
c = x[0]['county']
s = x[0]['state']
cases = int(new_cases[(new_cases['county'] == c)
& (new_cases['state'] == s)].cases)
deaths = int(new_cases[(new_cases['county'] == c)
& (new_cases['state'] == s)].deaths)
cases2 = int(counties[(counties['county'] == c)
& (counties['state'] == s)].cases)
deaths2 = int(counties[(counties['county'] == c)
& (counties['state'] == s)].deaths)
msg = "There have been " + str(cases) + " new cases and " + str(
deaths) + " new deaths in " + c + " as of " + date2
msg += ". There have been " + str(cases2) + " total cases and " + str(
deaths2) + " total deaths in " + c + "."
st.write("Bot: " + msg)
say(msg)
except:
st.write("Bot: " + "Sorry I did not get that. Please try again.")
say("Sorry, I did not get that. Please try again.")
update()
def grab_weather(wi, zc):
call = make_request(zc)
wi.set_city(call['name'])
wi.set_state(zipcodes.matching(str(zc))[0]['state'])
grab_information(call, wi)
show_weather(wi)
def isZipValid(z):
try:
if not zipcodes.matching(z):
return False
else:
return True
except ValueError:
pass
def merchantSearch(merchantName,merchantPostalCode):
country=zipcodes.matching(merchantPostalCode)[0]["country"]
merchantCountryCode = pycountry.countries.get(alpha_2=country).numeric
payload["searchAttrList"]["merchantName"]=merchantName
payload["searchAttrList"]["merchantPostalCode"]=merchantPostalCode
payload["searchAttrList"]["merchantCountryCode"]=merchantCountryCode
response = requests.request("POST", url,cert=(cert,key), headers=headers, json = payload)
return(response.text.encode('utf8'))
def lf_contains_zipcode(x):
try:
match = zipcodes.matching(str(x.text))
if len(match) > 0:
return ZIPCODE
else:
return ABSTAIN
except:
return ABSTAIN
def read_county_stats_zip_ny(zipcode: str) -> Dict:
"""Return stats for New York State zip_codes
"""
zip_info = zipcodes.matching(str(zipcode))[0]
county = zip_info["county"].rsplit(" ", 1)[0]
state = zip_info["state"]
try:
deaths = pd.read_csv(app_config.STATE_DEATH)
confirmed_df = pd.read_csv(app_config.STATE_CONFIRMED)
except:
raise DataReadingError(
f"Data reading error State: {state}, and County: {county}.")
try:
confirmed_df = confirmed_df[confirmed_df["Province_State"] ==
reverse_states_map[state]]
confirmed_df = confirmed_df[confirmed_df["Admin2"] == county]
confirmed = confirmed_df.iloc[:, -1]
new_confirmed = (confirmed_df.iloc[:, 12:].astype("int32").diff(
axis=1).iloc[:, -1].values[0])
# used data source 2 for new death number
deaths = deaths[deaths["Province_State"] == reverse_states_map[state]]
deaths = deaths[deaths["Admin2"] == county]
# 4/15/20: force cast into int before diff as pd sometimes read as
# float and throws nan.
death = deaths.iloc[:, -1]
new_death = (deaths.iloc[:, 12:].astype("int32").diff(
axis=1).iloc[:, -1].values[0])
try:
fatality_rate = int(death) / int(confirmed)
except: # pylint: disable=W0702
fatality_rate = 0
data = {
"county_name": county,
"state_name": reverse_states_map[state],
"confirmed": int(confirmed),
"new": int(new_confirmed),
"death": int(death),
"new_death": int(new_death),
"fatality_rate": f"{fatality_rate}%",
"latitude": float(zip_info["lat"]),
"longitude": float(zip_info["long"]),
"last_update": str("2020-04-17 19:50 EDT"),
}
print(data)
# data = json.dumps(data)
# print(data)
except:
raise DataValidationError(
f"Can't find State: {state}, and County: {county} combination.")
return data
def _zip_to_lat_long(zipcode):
""" Returns the lat / long for a zip code, or None if none is found. """
zip_location_list = zipcodes.matching(zipcode)
try:
first_location = zip_location_list.pop()
lat = float(first_location.get("lat"))
lon = float(first_location.get("long"))
except Exception:
return None, None
return lat, lon
def parse_zipcode(self, value):
try:
result = zipcodes.matching(value)
if (len(result) > 1):
return result[0]
else:
return None
except ValueError:
return None
except TypeError:
raise TypeError
def getInvalidZips(self):
zipCodeFields = [self.patientZip, self.providerZip]
invalidZips = []
for zip in zipCodeFields:
if not zip:
continue
if not (re.match("^\d{5}$", zip)
or re.match("^\d{5}-\d{4}$", zip)):
issue = (zip, "Invalid zip format")
invalidZips.append(issue)
elif not zipcodes.matching(zip):
issue = (zip, "Zip appears not to exist")
invalidZips.append(issue)
return invalidZips
def validate(self, document):
"""Validates zipcodes
Args:
document: User input to questionary prompt
References:
Zipcodes: https://pypi.org/project/zipcodes/
Returns:
True if user zipcode is valid number with len=5 and according to zipcodes package
"""
ok = False
if document.text.isdigit() and len(document.text) == 5:
# Only take non-Hawaii and non-Alaska zipcodes
ok = zipcodes.is_real(document.text) and \
(zipcodes.matching(document.text)[0]['state'] != 'HI') and \
(zipcodes.matching(document.text)[0]['state'] != 'AK')
if not ok:
raise ValidationError(
message='Please enter a valid zipcode',
cursor_position=len(document.text)) # Move cursor to end
def correctLostLeadingZeroZipcode(zip: str, expectedState: str):
if not zip:
return zip
if not expectedState:
return zip
try:
zipData = zipcodes.matching(zip)
except ValueError:
return zip
if zipData:
return zip
if len(zip) < 5:
proposedZip = zip.zfill(5)
try:
proposedZipInfo = zipcodes.matching(proposedZip)
except ValueError:
return zip
proposedState = proposedZipInfo[0]["state"]
if proposedState.upper().strip() == expectedState.upper().strip():
return proposedZip
else:
return zip
return zip
def get_zipcode_info(zipcode_str):
"""
:param zipcode_str: -> String; zipcode for which the info is required
:return: -> dict; keys :- isValid, city, state.
"""
zipcode_info = zipcodes.matching(zipcode_str)
result = {__IS_VALID__:False, __CITY__: None, __STATE__: None}
if zipcode_info:
result[__IS_VALID__] = True
result[__CITY__] = zipcode_info[0]["city"]
result[__STATE__] = zipcode_info[0]["state"]
return result
def valid_zip(field_value, field_name):
"""Validates the zip code by using the python zipcodes library.
Args:
field_value:str
field_name:str
Returns:
returns Validation Result Object
"""
try:
zip_code_normal = zipcodes.matching(field_value)
return ValidationResult('passed', field_value, field_name)
except:
return ValidationResult('failed', field_value, field_name)
def fetch_data(zip_code=72204):
'''
This function uses the input zipcode to generate city location and also
create the url where the weather data will be fetched from.
The weather data is then fetched from this url using the date generated.
zipcode = 5 digit US zipcode only.
'''
#Get today's date
today = date.today()
todays_date = today.strftime("%a %#m/%d/%Y").replace('x0', '')
year = today.strftime("%Y")
#Generate url using zipcode
city = z.matching(zip_code)[0]['city']
state = z.matching(zip_code)[0]['state']
city_state = city.replace(' ', '-').lower() + '/' + zip_code
state_url = 'https://www.accuweather.com/en/browse-locations/nam/us/' + state.lower(
)
#Generate url specific location id
agent = {"User-Agent": 'Chrome/80.0.3987.132'}
res = requests.get(state_url, headers=agent)
s = BeautifulSoup(res.text, features="lxml")
# Getting the specific location of the url_location_id requires looking through the text extracted from the url
text_list = s.findAll('script')
city_id = text_list[2].get_text().strip()
pattern = '"' + city + '","id":"(.+?)","localizedName":"' + city + '"'
url_location_id = re.search(pattern, city_id).group(1)
location_url = 'https://www.accuweather.com/en/us/' + city_state + '/daily-weather-forecast/' + url_location_id
#Extract entire data from location_url
res = requests.get(location_url, headers=agent)
soup = BeautifulSoup(res.content, features="lxml")
return soup, year, location_url, todays_date, city
def addr_to_latlong(self, str_address, add_delay=False):
"""
:param str_address: The string expression of address. Most accurate when OSM Geocrawler is initialized with region_search set to "city_name, state_name"
:return: Tuple of (lat, long) in floating points
"""
# zip_code = re.search(r'.*(\d{5}(\-\d{4})?)$', str_address)
# zip_code = re.search(r"(.*\d{5}-\d{4}\b|.*\d{5})", str_address)
if add_delay:
gc = RateLimiter(self.locator.geocode,
min_delay_seconds=1,
error_wait_seconds=10,
swallow_exceptions=True,
max_retries=5000)
regex = re.compile(r"[0-9]{5}(?:-[0-9]{4})?")
matches = re.findall(regex, str_address)
# print(matches)
try:
assert len(matches) == 1
zip_code_str = matches[0]
# zip_code_str = zip_code.groups()[0]
print(f"*** zip_code_str:{zip_code_str}")
except:
zip_code_str = None
if zip_code_str is not None:
try:
CITY = zipcodes.matching(zip_code_str)[0]["city"]
City = CITY[:1] + CITY[1:].lower()
str_address = str_address.replace(zip_code_str, City)
print(str_address)
except:
print(
"No zipcode and/or cannot replace zipcode with city name.")
try:
location = self.locator.geocode(str_address)
# print("Latitude = {}, Longitude = {}".format(location.latitude, location.longitude))
except GeocoderTimedOut:
time.sleep(2)
return self.addr_to_latlong(str_address)
if location is not None:
return (location.latitude, location.longitude)
else:
return None
def zip2FIPS(zip:str):
if not zip:
return ""
try:
zipData = zipcodes.matching(zip)
except ValueError:
return ""
if not zipData:
print("Warning: Zipcode %s does not have any associated information." % zip)
return ""
state = zipData[0]["state"]
county = zipData[0]["county"]
try:
return fipsData[state][county]
except KeyError:
return ""
def is_valid_zip_code(zip_code):
# This function validates the pattern of the zip code. The regular expression below
# returns valid for five digit value as well as five digits with hyphen followed by four or 5 digits.:
# Example of valid patterns : 78133, 78133-3212
# Example pf invalid patterns: Los Angels, 8976541,87676-123456
result = False
try:
result = zipcodes.matching(zip_code.split('-')[0])
if result.__len__() > 0:
result = True
else:
result = False
except:
print("Error matching zip code.")
return result
def normalize_zip(entry, field_name):
"""Returns a zip code that is 5 digits long, utilizes python zipcodes package
Args:
entry:custom entry (Ex.EligibilityEntry, CensusEntry)
field_name: str
Returns:
None (modifies object attr)
"""
try:
zip_code_normal = zipcodes.matching(getattr(entry,
field_name))[0]['zip_code']
setattr(entry, field_name, zip_code_normal)
except:
setattr(entry, field_name, None)
def get_message(phone):
account_sid = "ACd3dbda8dd8bf0f40cec66339052a9eca"
auth_token = "INSERT TOKEN HERE (TWILIO DEACTIVATES TOKENS THAT ARE SHARED ON PUBLIC GITHUB REPOSITORIES) "
try:
x = zipcodes.matching(code)
c = x[0]['county']
s = x[0]['state']
cases = int(new_cases[(new_cases['county'] == c)
& (new_cases['state'] == s)].cases)
deaths = int(new_cases[(new_cases['county'] == c)
& (new_cases['state'] == s)].deaths)
cases2 = int(counties[(counties['county'] == c)
& (counties['state'] == s)].cases)
deaths2 = int(counties[(counties['county'] == c)
& (counties['state'] == s)].deaths)
msg = "There have been " + str(cases) + " new cases and " + str(
deaths) + " new deaths in " + c + " as of " + date2
msg += ". There have been " + str(
cases2) + " total cases and " + str(
deaths2) + " total deaths in " + c + "."
temp = msg
r = requests.get('https://www.reddit.com/r/Coronavirus/top/.json',
headers={'user-agent': 'Mozilla/5.0'})
top_headers = []
for i in range(10):
post = r.json()['data']['children'][i]['data']['title']
top_headers.append(post)
temp2 = (' | '.join(top_headers[0:5]))
client = Client(account_sid, auth_token)
message = client.messages.create(body="Update: " + temp +
"\nNews: " + temp2,
from_='+14242971568',
to='+1' + phone.replace('-', ''))
print(message.sid)
st.write("Bot: " + "Updates and news successfully sent to " +
phone + ".")
except:
st.write("Bot: " + "Sorry I did not get that. Please try again.")
say("Sorry, I did not get that. Please try again.")
mobile()
