def latlong_to_address(img_list): # run get_coordinates function for lat, long addresses = [] #add your api keys here to use this function bing_key = 'your_key_here' zillow_key = 'your_key_here' #instantiating the zillow api zillow_api = zillow.ValuationApi() for img in img_list: #get address from Lat/lon coords = get_coordinates(img) #instantiate bing geocoder bing_locator = geocoders.Bing(bing_key) #pulling mailing address from bing address = bing_locator.reverse(coords).raw street_address = address['name'] house = address['address']['addressLine'] postal_code = address['address']['postalCode'] #zillow api call try: #attempt to pull a price from the zillow api house_data = zillow_api.GetSearchResults(zillow_key, house, postal_code) price = house_data.zestimate.amount except: #if no zillow price leave empty price='$__' #add zillow price to address addresses.append(f'{street_address}: ${price}') #sleep so that we are not pinging api in too rapid of sucession time.sleep(.5) return addresses
def __init__(self, apikey, ad, city, state, zipcode, COMPNUMBER=25): self.compnum = COMPNUMBER api = zillow.ValuationApi() # initialize api address = ad + "," + city + "," + state postal_code = str(zipcode) self.data = api.GetDeepSearchResults( apikey, address, postal_code).get_dict() # basic data retrieved from address self.city = self.data['full_address']['city'] self.state = self.data['full_address']['state'] self.region = self.data['local_realestate']['region_name'] self.regionType = self.data['local_realestate']['region_type'] self.homeType = self.data['extended_data']['usecode'] self.zpid = self.data[ 'zpid'] # home identifier assigned by zillow, needed for other api calls self.zestimate_data = api.GetZEstimate( apikey, self.zpid).get_dict() # retrieves zestimate details self.comps_data = api.GetDeepComps( apikey, self.zpid, count=COMPNUMBER)['comps'] # returns comps in the form of a dict self.pp = pprint.PrettyPrinter(indent=4) self.comps = [] self.upper_val = None self.lower_val = None self.price = None self.comp_mean_weighted_sim = None self.comp_mean_weighted_dist = None self.comp_mean_weighted_sim_low = None self.comp_mean_weighted_dist_low = None self.comp_mean_weighted_sim_high = None self.comp_mean_weighted_dist_high = None self.comp_change_mean_weighted_sim = None self.comp_change_mean_weighted_dist = None self.change_30_days = None
def latlong_to_address(img_list): # run get_coordinates function for lat, long addresses = [] bing_key = '' zillow_key = '' zillow_api = zillow.ValuationApi() for img in img_list: #get address from Lat/lon coords = get_coordinates(img) #instantiate bing geocoder bing_locator = geocoders.Bing(bing_key) address = bing_locator.reverse(coords).raw street_address = address['name'] house = address['address']['addressLine'] postal_code = address['address']['postalCode'] #zillow api call try: house_data = zillow_api.GetSearchResults(zillow_key, house, postal_code) price = house_data.zestimate.amount except: price = '$__' addresses.append(f'{street_address}: ${price}') time.sleep(.5) return addresses
def zillow_data(zipcode): key = get_key() url = URL_generator(zipcode) driver = driver_generator() zpids = get_zpids(url, driver) api = zillow.ValuationApi() df = house_data(key, api, zpids) return df
def retrieve_zillow_data(zillow_addresses, api_key): api = zillow.ValuationApi() zillow_data = dict() for address, zipcode in zillow_addresses.itertuples(index=False): try: data = api.GetDeepSearchResults(api_key, address, zipcode) zillow_data[address] = format_zillow_data(data.get_dict()) except zillow.error.ZillowError: logging.error( "Could not retrieve data for address: {}".format(address)) return zillow_data
def textaddress(): #adding form that accepts address form = AddressForm() # text to address and value form if form.validate_on_submit(): address = form.address.data # bing address grabber bing_locator = geocoders.Bing(bing_key) address = bing_locator.geocode(address).raw # Zillow call (could be replaced with Zillow function) zillow_api = zillow.ValuationApi() house = address['address']['addressLine'] postal_code = address['address']['postalCode'] house_data = zillow_api.GetSearchResults(zillow_key, house, postal_code) price = house_data.zestimate.amount # set address back to street address and zip code address = address['name'] ### START GOOGLE STREET VIEW IMAGE HANDLING ### # Set image_url to Google Street View of address image_url = f'https://maps.googleapis.com/maps/api/streetview?size=600x600&location={address}&key={google_key}' # Image write out to uploads folder image = requests.get(image_url) basepath = os.path.abspath('app/') filelist = re.findall(r'\w+', address) filename = ''.join(filelist) final_path = f'{basepath}/uploads/{filename}.jpg' open(f'{final_path}', 'wb').write(image.content) # render template with passed variables when form validates return render_template('text_form.html', title='Output', price=price, address=address, file_path=f'{filename}.jpg', photo=open(f'{final_path}', 'rb')) #keep same page with form if form does not validate return render_template('textaddress.html', title='Submit Address', form=form)
def get_zillow_data(self): api = zillow.ValuationApi() zillow_data = api.GetSearchResults(self.zillow_key, self.address, self.zip) z_data = { 'valuation_high': zillow_data.zestimate.valuation_range_high, 'zestimate': zillow_data.zestimate.amount, 'valuation_low': zillow_data.zestimate.valuation_range_low, 'zestimate_30_day_change': zillow_data.zestimate.amount_change_30days, 'details': zillow_data.links.home_details, 'overview_link': zillow_data.local_realestate.overview_link } print(z_data)
def set_zillow(self): zillow_api = zillow.ValuationApi() house = f'{self.street_number} {self.street_name}' # estimate int, baths str, bedrooms str try: house_data = zillow_api.GetDeepSearchResults( zillow_key, house, self.postal_code) self.zillow_estimate = house_data.zestimate.amount self.zillow_baths = house_data.extended_data.bathrooms self.zillow_bedrooms = house_data.extended_data.bedrooms #Error if zillow doesnt have price for property except: print('Zillow does not have price for this address')
def textaddress(): form = AddressForm() if form.validate_on_submit(): # flash('Login requested for user {}'.format(form.address.data)) address = form.address.data bing_key = '' bing_locator = geocoders.Bing(bing_key) address = bing_locator.geocode(address).raw zillow_key = '' zillow_api = zillow.ValuationApi() house = address['address']['addressLine'] postal_code = address['address']['postalCode'] house_data = zillow_api.GetSearchResults(zillow_key, house, postal_code) price = house_data.zestimate.amount address = address['name'] google_key = '' ### START GOOGLE STREET VIEW IMAGE HANDLING ### # Set image_url to Google Street View of address # I don't know how this will need to be saved / returned for use in Flask image_url = f'https://maps.googleapis.com/maps/api/streetview?size=600x600&location={address}&key={google_key}' # Put image handling code for Flask here image = requests.get(image_url) basepath = os.path.abspath('app/') filelist = re.findall(r'\w+', address) filename = ''.join(filelist) final_path = f'{basepath}/uploads/{filename}.jpg' open(f'{final_path}', 'wb').write(image.content) return render_template('text_form.html', title='Output', price=price, file_path=f'{filename}.jpg', photo=open(f'{final_path}', 'rb')) # return redirect('/textaddress') return render_template('textaddress.html', title='Submit Address', form=form)
def __init__(self): with open("keys/zws_key", "r") as zws_file: self.zws_id = zws_file.read().replace("\n", "") if not self.zws_id: print_err("Cannot find Zillow API key") with open("keys/gapi_key", "r") as gapi_file: google_id = gapi_file.read().replace("\n", "") if not google_id: print_err("Cannot find Google API key") self.zapi = zillow.ValuationApi() self.gmaps = googlemaps.Client(key=google_id) self.browser = None
def zillow_pull(address): #instantiate zillow api zillow_api = zillow.ValuationApi() # get house and postal code info from dictionary house = address['address']['addressLine'] postal_code = address['address']['postalCode'] # Grab Zillow price and set to price variable try: house_data = zillow_api.GetSearchResults(zillow_key, house, postal_code) price = house_data.zestimate.amount #Error if zillow doesnt have price for property except: price = 'Zillow does not have price for this address' return price
def zillow_api(address): home_address = Address(address) if home_address.is_zip_good(): zip_code = home_address.zip_code else: zip_code = '98058' address = '1309 Harrington Ave SE, Renton' key = dec('M1-OLo18g1trev4fo_pu1if', 15) api = zillow.ValuationApi() data = api.GetDeepSearchResults(key, address, zip_code) if not isinstance(data, str): full_data = api.GetDeepComps(key, data.zpid) if not isinstance(full_data, str): full_data['principal'].extended_data = data.extended_data else: full_data = {'principal': data, 'comps': [data]} return full_data else: return "Wrong address"
def zillow_pull(address): zillow_api = zillow.ValuationApi() zillow_key = '' # get house and postal code info from dictionary house = address['address']['addressLine'] postal_code = address['address']['postalCode'] # Grab Zillow price and set to price variable try: house_data = zillow_api.GetSearchResults(zillow_key, house, postal_code) price = house_data.zestimate.amount except: price = 'Zillow does not have price for this address' # Error handling if Zillow has no price output if price == None: price = 'This address does not have a price estimate in Zillow' return price
def api_invoke(): config = configparser.ConfigParser() config.read('./api_key.conf') key = config.get('Zillow_API_Key_ZWSID', 'api_key') api = zillow.ValuationApi() address = "16229 North 22nd drive, Phoenix, AZ" postal_code = "85023" data = api.GetSearchResults(key, address, postal_code) pp = pprint.PrettyPrinter(indent=4) pp.pprint((data.get_dict())) detail_data = api.GetZEstimate(key, data.zpid) pp.pprint(detail_data.get_dict()) comp_data = api.GetComps(key, data.zpid) pp.pprint(detail_data.get_dict()) deep_results = api.GetDeepSearchResults(key, address, postal_code) pp.pprint(deep_results.get_dict())
""" import zillow import pprint if __name__=="__main__": key = "" with open("./zillow_key.conf", 'r') as f: key = f.readline().replace("\n", "") print(key) address = "3400 Pacific Ave., Marina Del Rey, CA" postal_code = "90292" api = zillow.ValuationApi() data = api.GetSearchResults(key, address, postal_code) pp = pprint.PrettyPrinter(indent=4) pp.pprint(data.get_dict()) detail_data = api.GetZEstimate(key, data.zpid) comp_data = api.GetComps(key, data.zpid) pp.pprint(comp_data['comps'][1].get_dict()) deep_results = api.GetDeepSearchResults(key, "1920 1st Street South Apt 407, Minneapolis, MN", "55454") pp.pprint(deep_results.get_dict()) http://www.zillow.com/webservice/GetSearchResults.htm?zws-id=X1-ZWz179yot8r9jf_282ek&address=2114+Bigelow+Ave&citystatezip=Seattle%2C+WA
def address_search(address, postal_code): connection_string = database_key engine = create_engine(f'postgresql://{connection_string}') api = zillow.ValuationApi() key = zillow_key try: request_data = api.GetSearchResults(key, address, postal_code) result = request_data.get_dict() address = result['full_address'] zestimate = result['zestimate'] #Combined returned results to a single dictionary and then to a dataframe comb_dict = dict(zestimate) comb_dict.update(address) combined_df = pd.DataFrame.from_dict(comb_dict, orient='index').T #Add Risk Adjustment calculations columns to the data frame combined_df['risk_adj_value'] = ( combined_df['amount'] * .85 ) #Risk adjusting home by 15%, reducing home val by 15% combined_df['max_cash_limit'] = combined_df[ 'risk_adj_value'] * .30 #Not to buy more than 30% of someones home equity, to avoid controlling interest combined_df['time_stamp'] = pd.Timestamp.now() #Log the data frame to the database using SQL combined_df.to_sql(name='zillow', con=engine, if_exists='append', index=False) print("connecting to db") #API call and results returned try: #Using API-returned Zip Code, compare that value with our risk data table ('sales_price' table). Will return True/False response from the 'equity_risk' column def result_getter(postal_code): connection = engine.connect() query = "select sp.equity_risk from sales_price sp where sp.zip_code = " + postal_code + ";" result = connection.execute(query) for i in result: results = i return results results = result_getter(postal_code) print("query finished") print(results[0]) print("Success") # Decision tree - if True, allowable investment 30% of risk adj home value. If False, 10% of risk adj home value if results[0] == True: offer = (zestimate['amount'] * .85) * .30 print(f'$ {offer}') else: offer = (zestimate['amount'] * .85) * .10 print(combined_df['risk_adj_value'] * .10) return ((zestimate['amount']), offer) except: return ((zestimate['amount']), ((zestimate['amount'] * .85) * .20)) except: return ("Bad", "Address") # def update_dash_data(): # return()
key = 'X1-ZWz1gk74zflatn_5jgqp' # In[2]: #The latitude and longitudinal points enclosing Manhattan, 96th street and below. p1 = [40.796,-73.975] p2 = [40.783,-73.944] p3 = [40.707,-74.029] p4 = [40.701,-73.990] points = [p1,p2,p3,p4] api = zillow.ValuationApi() #initialize zillow API. houses = pd.DataFrame([]) #start with this, can clean later on... nbeds = [] addresses = [] housekind = [] high_estimates = [] low_estimates = [] costs = [] sqfts = [] last_updated = [] cpss = [] dcost = []
def house_info(source_df, start, stop): # Gets information from Zillow, returns pandas DataFrame of range of houses key = apikey houses_df = DataFrame() # Call Zillow API for each house errors = 0 successes = 0 for row in range(start, stop): address = source_df.iloc[row][5] postal_code = source_df.iloc[row][4] api = zillow.ValuationApi() # Handle exceptions for lack of information from Zillow while True: try: data = api.GetDeepSearchResults(key, address, postal_code) house = { 'bathrooms': data.extended_data.bathrooms, 'bedrooms': data.extended_data.bedrooms, 'sqft': data.extended_data.finished_sqft, 'last_sold_price': data.extended_data.last_sold_price, 'last_sold_date': data.extended_data.last_sold_date, 'lot_size_sqft': data.extended_data.lot_size_sqft, 'year_built': data.extended_data.year_built, 'comps_link': data.links.comparables, 'home_details': data.links.home_details, 'graphs_data': data.links.graphs_and_data, 'map': data.links.map_this_home, 'zestimate': data.zestiamte.amount, 'valuation_range_high': data.zestiamte.valuation_range_high, 'valuation_range_low': data.zestiamte.valuation_range_low } s_house = pd.Series( house, index=[ 'bathrooms', 'bedrooms', 'sqft', 'last_sold_price', 'last_sold_date', 'lot_size_sqft', 'year_built', 'comps_link', 'home_details', 'graphs_data', 'map', 'zestimate', 'valuation_range_high', 'valuation_range_low' ]) successes += 1 # print "one pass" break except ValueError: s_house = pd.Series( [ np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN ], index=[ 'bathrooms', 'bedrooms', 'sqft', 'last_sold_price', 'last_sold_date', 'lot_size_sqft', 'year_built', 'comps_link', 'home_details', 'graphs_data', 'map', 'zestimate', 'valuation_range_high', 'valuation_range_low' ]) errors += 1 break except: s_house = pd.Series( [ np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN ], index=[ 'bathrooms', 'bedrooms', 'sqft', 'last_sold_price', 'last_sold_date', 'lot_size_sqft', 'year_built', 'comps_link', 'home_details', 'graphs_data', 'map', 'zestimate', 'valuation_range_high', 'valuation_range_low' ]) errors += 1 # print "ZillowError likely" break # Append each new pd.Series house to dataframe, and pause for next loop houses_df = houses_df.append(s_house, ignore_index=True) time.sleep(1) # Log success/error counts with open("Errors.txt", "a") as text_file: text_file.write("Successes: {} ".format(successes)) text_file.write("Errors: {}\n".format(errors)) return houses_df
def __init__(self, **kwargs): """Initialize, loading data.""" import eia import googlemaps import zillow from shapely.geometry import Polygon self._p = kwargs.get('logger') load_canopy_polys = kwargs.get('load_canopy_polys', True) self._dir_name = os.path.dirname(os.path.realpath(__file__)) # Load meta.json. self.prt('Loading meta file...') meta_path = os.path.join(self._dir_name, '..', 'meta.json') if os.path.exists(meta_path): with open(meta_path, 'r') as f: meta = json.load(f) self._imgs_mean = meta['mean'] self._imgs_std = meta['std'] self._train_count = meta['train_count'] # Load parcel data. self._parcels_fname = self.download_file(self._PARCELS_URL) with open(self._parcels_fname, 'r') as f: self._parcels = json.load(f) self._parcel_polygons = [ x.get('geometry', {}).get('coordinates', []) for x in self._parcels.get('features', []) ] self._parcel_polygons = list( filter(None, ([[y for y in x if len(y) >= 3] for x in self._parcel_polygons]))) self._parcel_polygons = [[Polygon(y) for y in x if len(y) >= 3] for x in self._parcel_polygons] with open(os.path.join(self._dir_name, '..', 'google.key'), 'r') as f: self._google_key = f.readline().strip() self._google_client = googlemaps.Client(key=self._google_key) with open(os.path.join(self._dir_name, '..', 'eia.key'), 'r') as f: self._eia_key = f.readline().strip() self._eia_client = eia.API(self._eia_key) with open(os.path.join(self._dir_name, '..', 'zillow.key'), 'r') as f: self._zillow_key = f.readline().strip() self._zillow_client = zillow.ValuationApi() self._cropsize = self._INPUT_IMG_SIZE - 2 * self._CROPPIX # Load canopy data. if not load_canopy_polys: return self._canopy_fname = os.path.join(self._dir_name, '..', 'geo', 'ENVIRONMENTAL_TreeCanopy2014.json') with open(self._canopy_fname, 'r') as f: self._canopies = json.load(f) raw_canpols = [ x.get('geometry', {}).get('coordinates', []) for x in self._canopies.get('features', []) if x.get('geometry', {}) is not None ] raw_canpols = list( filter(None, ([[y for y in x if len(y) >= 3] for x in raw_canpols]))) raw_canpols = [[ Polygon([(a, b + self._LAT_OFFSET) for a, b in y]) for y in x if len(y) >= 3 ] for x in raw_canpols] self._canopy_polygons = [] for canpoly in tqdm(raw_canpols, desc='Extracting canopy polygons'): cps = [x.buffer(0) for x in canpoly] cps = self._canopy_polygons.extend([ a for b in [ list(x.geoms) if 'multi' in str(type(x)).lower() else [x] for x in cps ] for a in b ]) self._model = None