def run(): auth_id = os.environ[ 'SMARTY_AUTH_ID'] # We recommend storing your keys in environment variables auth_token = os.environ['SMARTY_AUTH_TOKEN'] credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_zipcode_api_client() lookup = Lookup() lookup.city = "Mountain View" lookup.state = "California" try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result zipcodes = result.zipcodes cities = result.cities for city in cities: print("\nCity: " + city.city) print("State: " + city.state) print("Mailable City: {}".format(city.mailable_city)) for zipcode in zipcodes: print("\nZIP Code: " + zipcode.zipcode) print("Latitude: {}".format(zipcode.latitude)) print("Longitude: {}".format(zipcode.longitude))
def test_address(address): auth_id = "9484953c-80e6-c55d-c6fc-317df18233eb" auth_token = "GdjMKksY6pLKQFoLMiWx" credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_street_api_client() lookup = Lookup() lookup.street = address['street'] lookup.city = address['city'] lookup.state = address['state'] lookup.zipcode = address['zipcode'] lookup.match = "Invalid" # "invalid" is the most permissive match try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result if not result: print("No candidates. This means the address is not valid.") return False first_candidate = result[0] print("Address is valid. (There is at least one candidate)\n") print("ZIP Code: " + first_candidate.components.zipcode) print("County: " + first_candidate.metadata.county_name) print("Latitude: {}".format(first_candidate.metadata.latitude)) print("Longitude: {}".format(first_candidate.metadata.longitude)) return True
def smarty_validate(address): load_dotenv() auth_id = os.environ['SMARTY_AUTH_ID'] auth_token = os.environ['SMARTY_AUTH_TOKEN'] write_path = '/Users/wesamazaizeh/Desktop/Projects/halal_o_meter/src/data/data_collection/invalid_address.txt' credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_street_api_client() lookup = StreetLookup() lookup.street = address lookup.match = "strict" try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result if not result: print("\nInvalid address.") print(address) # with open(write_path, 'a+') as myfile: # myfile.write("{}\n".format(address)) return return result
def do_lookup(cls, address_dto): creds = cls.get_credentials() client = ClientBuilder(creds).with_licenses( ["us-standard-cloud"]).build_us_street_api_client() lookup = StreetLookup() lookup = StreetLookup() # lookup.input_id = "24601" # Optional ID from your system lookup.street = "1047 East Washington Street" # lookup.street2 = "closet under the stairs" # lookup.secondary = "APT 2" # lookup.urbanization = "" # Only applies to Puerto Rico addresses lookup.city = "Pembroke" lookup.state = "MA" # lookup.zipcode = "" lookup.candidates = 3 client.send_lookup(lookup) try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) cls.candidates = None return cls.candidates = lookup.result cls._set_dictionary()
def run(): auth_id = os.environ[ 'SMARTY_AUTH_ID'] # We recommend storing your keys in environment variables auth_token = os.environ['SMARTY_AUTH_TOKEN'] credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_street_api_client() # client = ClientBuilder(credentials).with_proxy('localhost:8080', 'user', 'password').build_us_street_api_client() # Uncomment the line above to try it with a proxy instead lookup = Lookup() lookup.street = "1600 Amphitheatre Pkwy" lookup.city = "Mountain View" lookup.state = "CA" try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result if not result: print("No candidates. This means the address is not valid.") return first_candidate = result[0] print("Address is valid. (There is at least one candidate)\n") print("ZIP Code: " + first_candidate.components.zipcode) print("County: " + first_candidate.metadata.county_name) print("Latitude: {}".format(first_candidate.metadata.latitude)) print("Longitude: {}".format(first_candidate.metadata.longitude))
def __isValidDeliveryStreet(self, deliveryStreet, deliveryZip): '''Performs a validity check of a given street address and zip code pair. Leverages the SmartyStreets address verification service. Args: self: Instance reference deliveryStreet: String containing the street address deliveryZip: String containing the zip code Returns: Boolean indicating whether the street address is valid Raises: None ''' if deliveryStreet and deliveryZip: credentials = StaticCredentials(AUTH_ID, AUTH_TOKEN) client = ClientBuilder(credentials).build_us_street_api_client() lookup = Lookup() lookup.street = deliveryStreet lookup.zipcode = deliveryZip try: client.send_lookup(lookup) except exceptions.SmartyException: return False if lookup.result: return True else: return False else: return False
def run(): # auth_id = "Your SmartyStreets Auth ID here" # auth_token = "Your SmartyStreets Auth Token here" # We recommend storing your secret keys in environment variables instead---it's safer! auth_id = os.environ['SMARTY_AUTH_ID'] auth_token = os.environ['SMARTY_AUTH_TOKEN'] credentials = StaticCredentials(auth_id, auth_token) # The appropriate license values to be used for you subscriptions # can be found on the Subscriptions page of the account dashboard. # https://www.smartystreets.com/docs/cloud/licensing client = ClientBuilder(credentials).with_licenses( ["us-core-cloud"]).build_us_street_api_client() # client = ClientBuilder(credentials).with_custom_header({'User-Agent': 'smartystreets ([email protected])', 'Content-Type': 'application/json'}).build_us_street_api_client() # client = ClientBuilder(credentials).with_proxy('localhost:8080', 'user', 'password').build_us_street_api_client() # Uncomment the line above to try it with a proxy instead # Documentation for input fields can be found at: # https://smartystreets.com/docs/us-street-api#input-fields lookup = StreetLookup() lookup.input_id = "24601" # Optional ID from your system lookup.addressee = "John Doe" lookup.street = "1600 Amphitheatre Pkwy" lookup.street2 = "closet under the stairs" lookup.secondary = "APT 2" lookup.urbanization = "" # Only applies to Puerto Rico addresses lookup.city = "Mountain View" lookup.state = "CA" lookup.zipcode = "94043" lookup.candidates = 3 lookup.match = "invalid" # "invalid" is the most permissive match, # this will always return at least one result even if the address is invalid. # Refer to the documentation for additional Match Strategy options. try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result if not result: print("No candidates. This means the address is not valid.") return first_candidate = result[0] print("There is at least one candidate.") print("If the match parameter is set to STRICT, the address is valid.") print( "Otherwise, check the Analysis output fields to see if the address is valid.\n" ) print("ZIP Code: " + first_candidate.components.zipcode) print("County: " + first_candidate.metadata.county_name) print("Latitude: {}".format(first_candidate.metadata.latitude)) print("Longitude: {}".format(first_candidate.metadata.longitude))
class AddressCorrecter: """ Validates and returns a corrected address. """ def __init__(self): self.auth_id = '839867c5-ea75-9d4f-10da-85b8fd453ba9' self.auth_token = 'uU5o6MjSolIc00dxVYeA' self.credentials = StaticCredentials(self.auth_id, self.auth_token) self.client = ClientBuilder( self.credentials).build_us_street_api_client() self.lookup = Lookup() def _lookup_one(self, address, city): self.lookup.street = address self.lookup.city = city self.lookup.state = "CA" try: self.client.send_lookup(self.lookup) except exceptions.SmartyException as err: print(err) return result = self.lookup.result if not result: # print("Address not valid.") return False first_candidate = result[0] return first_candidate.delivery_line_1 # if __name__ == "__main__": # ac = AddressCorrecter() # ac._lookup_one("528 Shorebird Cir #8204", "Redwood City")
def getZipCode(cityName, stateName): auth_id = "64c1b167-5f64-f1ab-0898-5a13c92e2359" auth_token = "WfTDEo4wyzYEaOeoe3FV" # We recommend storing your secret keys in environment variables instead---it's safer! # auth_id = os.environ['SMARTY_AUTH_ID'] # auth_token = os.environ['SMARTY_AUTH_TOKEN'] credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_zipcode_api_client() # Documentation for input fields can be found at: # https://smartystreet.com/docs/us-zipcode-api#input-fields lookup = ZIPCodeLookup() lookup.input_id = "dfc33cb6-829e-4fea-aa1b-b6d6580f0817" # Optional ID from your system lookup.city = cityName lookup.state = stateName try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result zipcodes = result.zipcodes cities = result.cities # for zipcode in zipcodes: # print("\nZIP Code: " + zipcode.zipcode) return zipcodes
def verifyaddress(): body = json.loads(request.data.decode()) credentials = StaticCredentials(AUTH_ID, AUTH_TOKEN) client = ClientBuilder(credentials).build_us_street_api_client() lookup = StreetLookup() # lookup.addressee = body.get('address') lookup.street = body['street'] # lookup.secondary = body.get('secondary') lookup.city = body['city'] lookup.state = body['state'] lookup.zipcode = body['zipcode'] lookup.candidates = 1 try: client.send_lookup(lookup) except Exception.SmartyException as err: print(err) return Response([], status=500) results = lookup.result if not results: return Response(json.dumps(False, default=str), status=200, content_type="text/json") first_candidate = results[0] # city_name, state_abbreviation, zipcode if not first_candidate or (first_candidate.delivery_line_1 != body['street'] or first_candidate.components.city_name != body['city'] or first_candidate.components.state_abbreviation != body['state'] or first_candidate.components.zipcode != body['zipcode']): print("No candidates. This means the address is not valid.") return Response(json.dumps(False, default=str), status=200, content_type="text/json") return Response(json.dumps(True, default=str), status=200, content_type="text/json")
def run(addressee,street,city,state,zipcode): auth_id = "9a7b8041-9ac4-7e15-75b0-780771fc3d92" auth_token = "xMvDBs26P88X0Esk8q5D" # We recommend storing your secret keys in environment variables instead---it's safer! # auth_id = os.environ['SMARTY_AUTH_ID'] # auth_token = os.environ['SMARTY_AUTH_TOKEN'] credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_street_api_client() # client = ClientBuilder(credentials).with_custom_header({'User-Agent': 'smartystreets ([email protected])', 'Content-Type': 'application/json'}).build_us_street_api_client() # client = ClientBuilder(credentials).with_proxy('localhost:8080', 'user', 'password').build_us_street_api_client() # Uncomment the line above to try it with a proxy instead # Documentation for input fields can be found at: # https://smartystreets.com/docs/us-street-api#input-fields lookup = StreetLookup() # lookup.input_id = "" # Optional ID from your system lookup.addressee = addressee lookup.street = street lookup.street2 = "" # lookup.secondary = secondary # lookup.urbanization = "" # Only applies to Puerto Rico addresses lookup.city = city lookup.state = state lookup.zipcode = zipcode # # lookup.candidates = 3 lookup.match = "Invalid" # "invalid" is the most permissive match, # this will always return at least one result even if the address is invalid. # Refer to the documentation for additional Match Strategy options. try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result # print(result[0]) if not result: print("No candidates. This means the address is not valid.") return False else: print("correct address") return True
def run(): auth_id = "Your SmartyStreets Auth ID here" auth_token = "Your SmartyStreets Auth Token here" # We recommend storing your secret keys in environment variables instead---it's safer! # auth_id = os.environ['SMARTY_AUTH_ID'] # auth_token = os.environ['SMARTY_AUTH_TOKEN'] credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_street_api_client() # client = ClientBuilder(credentials).with_proxy('localhost:8080', 'user', 'password').build_us_street_api_client() # Uncomment the line above to try it with a proxy instead # Documentation for input fields can be found at: # https://smartystreets.com/docs/us-street-api#input-fields lookup = Lookup() lookup.input_id = "24601" # Optional ID from your system lookup.addressee = "John Doe" lookup.street = "1600 Amphitheatre Pkwy" lookup.street2 = "closet under the stairs" lookup.secondary = "APT 2" lookup.urbanization = "" # Only applies to Puerto Rico addresses lookup.city = "Mountain View" lookup.state = "CA" lookup.zipcode = "94043" lookup.candidates = 3 lookup.match = "Invalid" # "invalid" is the most permissive match try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result if not result: print("No candidates. This means the address is not valid.") return first_candidate = result[0] print("Address is valid. (There is at least one candidate)\n") print("ZIP Code: " + first_candidate.components.zipcode) print("County: " + first_candidate.metadata.county_name) print("Latitude: {}".format(first_candidate.metadata.latitude)) print("Longitude: {}".format(first_candidate.metadata.longitude))
def smarty_api(flat_address_list: List[str]) -> Optional[SmartyStreetResult]: """ Run addresses through SmartyStreets API, returning a `SmartyStreetsResult` object with all the information we get from the API. If any errors occur, we'll return None. Args: flat_address_list: a flat list of addresses that will be read as follows: _ : an unused arguement for ID street: The street address, e.g., 250 OCONNOR ST state: The state (probably RI) zipcode: The zipcode to look up smartystreets_auth_id: Your SmartyStreets auth_id smartystreets_auth_token: Your SmartyStreets auth_token Returns: The result if we find one, else None """ # Authenticate to SmartyStreets API [ _, street, state, zipcode, smartystreets_auth_id, smartystreets_auth_token ] = flat_address_list credentials = StaticCredentials(smartystreets_auth_id, smartystreets_auth_token) client = ClientBuilder(credentials).build_us_street_api_client() # Lookup the Address with inputs by indexing from input `row` lookup = StreetLookup() lookup.street = street lookup.state = state lookup.zipcode = zipcode lookup.candidates = 1 lookup.match = "invalid" # "invalid" always returns at least one match try: client.send_lookup(lookup) except exceptions.SmartyException: return None res = lookup.result if not res: # if we have exceptions, just return the inputs to retry later return None result = res[0] return SmartyStreetResult.from_metadata(result)
def query_smartystreets(lookup): logging.info("Looking up address in SmartyStreets") auth_id = settings.SMARTYSTREETS_AUTH_ID auth_token = settings.SMARTYSTREETS_AUTH_TOKEN credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_street_api_client() try: client.send_lookup(lookup) except exceptions.SmartyException as err: logging.error(err) return None result = lookup.result if not result: logging.info("No address returned from SmartyStreets") return None return result
def run(): auth_id = '1d3ba9eb-6df4-74ec-fa31-d23fe2d89162' auth_token = '5RqNDBSfOAq3jdN7OgMc' # We recommend storing your secret keys in environment variables instead---it's safer! # auth_id = os.environ['SMARTY_AUTH_ID'] # auth_token = os.environ['SMARTY_AUTH_TOKEN'] credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_street_api_client() # client = ClientBuilder(credentials).with_proxy('localhost:8080', 'user', 'password').build_us_street_api_client() # Uncomment the line above to try it with a proxy instead address = '350 S Main, Salt Lake City, UT, 84101' lookup = Lookup(address) #lookup.street = "1600 Amphitheatre Pkwy" #lookup.city = "Mountain View" #lookup.state = "CA" #lookup.street = 'Union Station, 1717 Pacific Ave, #2100, Tacoma, WA 98402' try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result if not result: print("No candidates. This means the address is not valid.") return first_candidate = result[0] print("Address is valid. (There is at least one candidate)\n") print("ZIP Code: " + first_candidate.components.zipcode) print("County: " + first_candidate.metadata.county_name) print("Latitude: {}".format(first_candidate.metadata.latitude)) print("Longitude: {}".format(first_candidate.metadata.longitude))
def run(): # auth_id = "Your SmartyStreets Auth ID here" # auth_token = "Your SmartyStreets Auth Token here" # We recommend storing your secret keys in environment variables instead---it's safer! auth_id = os.environ['SMARTY_AUTH_ID'] auth_token = os.environ['SMARTY_AUTH_TOKEN'] credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_zipcode_api_client() # Documentation for input fields can be found at: # https://smartystreet.com/docs/us-zipcode-api#input-fields lookup = ZIPCodeLookup() lookup.input_id = "dfc33cb6-829e-4fea-aa1b-b6d6580f0817" # Optional ID from your system lookup.city = "Mountain View" lookup.state = "California" lookup.zipcode = "94043" try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result zipcodes = result.zipcodes cities = result.cities for city in cities: print("\nCity: " + city.city) print("State: " + city.state) print("Mailable City: {}".format(city.mailable_city)) for zipcode in zipcodes: print("\nZIP Code: " + zipcode.zipcode) print("Latitude: {}".format(zipcode.latitude)) print("Longitude: {}".format(zipcode.longitude))
def check_address(self, location): client = ClientBuilder(self.__credentials).build_us_street_api_client() lookup = street_lookup() lookup.street = location['street'] lookup.city = location['city'] lookup.state = location['state'] lookup.zipcode = location['zipcode'] try: client.send_lookup(lookup) except exceptions.SmartyExceptions as err: print(err) return result = lookup.result if not result: return ("No candidates. The address is not valid.") candidate = result[0] return candidate
def address_validation(): found = True # We recommend storing your secret keys in environment variables instead---it's safer! auth_id = os.environ['SMARTY_AUTH_ID'] auth_token = os.environ['SMARTY_AUTH_TOKEN'] session['shipping_fn'] = request.form['first_name'] session['shipping_ln'] = request.form['last_name'] input_address = { 'street': request.form['street1'] + ' ' + request.form['street2'], 'city': request.form['city'], 'state': request.form['state'], 'zip': request.form['zip_code'] } credentials = StaticCredentials(auth_id, auth_token) client = ClientBuilder(credentials).build_us_street_api_client() # client = ClientBuilder(credentials).with_custom_header({'User-Agent': 'smartystreets ([email protected])', 'Content-Type': 'application/json'}).build_us_street_api_client() # client = ClientBuilder(credentials).with_proxy('localhost:8080', 'user', 'password').build_us_street_api_client() # Uncomment the line above to try it with a proxy instead # Documentation for input fields can be found at: # https://smartystreets.com/docs/us-street-api#input-fields lookup = Lookup() #lookup.input_id = "24601" # Optional ID from your system lookup.addressee = request.form['first_name'] + ' ' + request.form[ 'last_name'] lookup.street = request.form['street1'] lookup.street2 = request.form['street2'] #lookup.secondary = "APT 2" lookup.urbanization = "" # Only applies to Puerto Rico addresses lookup.city = request.form['city'] lookup.state = request.form['state'] lookup.zipcode = request.form['zip_code'] lookup.candidates = 3 lookup.match = "Invalid" # "invalid" is the most permissive match try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result if not result: found = False print("No candidates. This means the address is not valid.") flash('Address is not valid. Please re-enter shipping information.') return render_template('partials/address.html', found=found) #for output example fields here https://smartystreets.com/docs/cloud/us-street-api#http-response-status first_candidate = result[0] print("Address is valid. (There is at least one candidate)\n") suggested_address_line1 = first_candidate.delivery_line_1 suggested_address_line2 = first_candidate.components.city_name + ", " + first_candidate.components.state_abbreviation + " " + first_candidate.components.zipcode print(first_candidate.delivery_line_1) print(suggested_address_line1) print(first_candidate.components.city_name + ", " + first_candidate.components.state_abbreviation + " " + first_candidate.components.zipcode) return render_template('partials/address.html', found=found, suggested_address_line1=suggested_address_line1, suggested_address_line2=suggested_address_line2, input_address=input_address)
def run(): auth_id = context.get_context("auth_id") auth_token = context.get_context("auth_token") # We recommend storing your secret keys in environment variables instead---it's safer! # auth_id = os.environ['SMARTY_AUTH_ID'] # auth_token = os.environ['SMARTY_AUTH_TOKEN'] credentials = StaticCredentials(auth_id, auth_token) # The appropriate license values to be used for you subscriptions # can be found on the Subscriptions page of the account dashboard. # https://www.smartystreets.com/docs/cloud/licensing client = ClientBuilder(credentials).with_licenses(["us-standard-cloud"]).build_us_street_api_client() # client = ClientBuilder(credentials).with_custom_header({'User-Agent': 'smartystreets ([email protected])', 'Content-Type': 'application/json'}).build_us_street_api_client() # client = ClientBuilder(credentials).with_proxy('localhost:8080', 'user', 'password').build_us_street_api_client() # Uncomment the line above to try it with a proxy instead # Documentation for input fields can be found at: # https://smartystreets.com/docs/us-street-api#input-fields lookup = StreetLookup() lookup.input_id = "24601" # Optional ID from your system lookup.addressee = "John Doe" lookup.street = "1600 Amphitheatre Pkwy" lookup.street2 = "closet under the stairs" lookup.secondary = "APT 2" lookup.urbanization = "" # Only applies to Puerto Rico addresses lookup.city = "Mountain View" lookup.state = "CA" lookup.zipcode = "94043" lookup.candidates = 3 lookup.match = "invalid" # "invalid" is the most permissive match, # this will always return at least one result even if the address is invalid. # Refer to the documentation for additional Match Strategy options. try: client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result = lookup.result if not result: print("No candidates. This means the address is not valid.") return first_candidate = result[0] print("Address is valid. (There is at least one candidate)\n") #print("Address = ", json.dumps(first_candidate.components)) print("ZIP Code: " + first_candidate.components.zipcode) print("County: " + first_candidate.metadata.county_name) print("Latitude: {}".format(first_candidate.metadata.latitude)) print("Longitude: {}".format(first_candidate.metadata.longitude)) # print("Precision: {}".format(first_candidate.metadata.precision)) # print("Residential: {}".format(first_candidate.metadata.rdi)) # print("Vacant: {}".format(first_candidate.analysis.dpv_vacant)) # Complete list of output fields is available here: https://smartystreets.com/docs/cloud/us-street-api#http-response-output sm = SmartyStreetsAdaptor(result) res = sm.to_json() print("All fields = \n", json.dumps(res, indent=2, default=str))
class ValidatorService(Validator): def __init__(self, context): self._context = context self._auth_id = context['smarty_streets_id'] self._auth_token = context['smarty_streets_token'] # This set up the credentials for the SDK self._credentials = StaticCredentials(self._auth_id, self._auth_token) # We will use the SDK for looking up zipcodes. self._zip_client = ClientBuilder(self._credentials).build_us_zipcode_api_client() # I am going to use the "raw" rest API for address lookup to provide a comparison of # the two API approaches. Also, I should be getting the URL for the context. self._address_lookup_url = "https://us-street.api.smartystreets.com/street-address" def validate_address(self, address): url = self._address_lookup_url params = {} params['auth-id'] = self._auth_id params['auth-token'] = self._auth_token params['street'] = address['street'] state = address.get('state', None) if state is not None: params['state'] = state city = address.get('city', None) if city is not None: params['city'] = city zipcode = address.get('zipcode', None) if zipcode is not None: params['zipcode'] = zipcode result = requests.get(url, params=params) # We need to handle the various status codes. We will learn this when we study REST. if result.status_code == 200: # If we got more than one address, then there was something wrong and the address into is imprecise j_data = result.json() if len(j_data) > 1: rsp = None else: rsp = j_data[0]['components'] rsp['deliver_point_barcode']=j_data[0]['delivery_point_barcode'] else: rsp = None return rsp def _zip_lookup_to_json(self, lookup): result = {} cities = [] zipcodes = [] for c in lookup.result.cities: new_c = { "city": c.city, "mailable": c.mailable_city, "state": c.state, "state_abbreviation": c.state_abbreviation } cities.append(new_c) for z in lookup.result.zipcodes: new_z = { "country_fips": z.county_fips, "name": z.county_name, "default_city": z.default_city, "latitude": z.latitude, "longitude": z.longitude, "precision": z.precision, "state": z.state, "state_abbreviation": z.state_abbreviation, "zipcode": z.zipcode, "zipcode_type": z.zipcode_type } zipcodes.append(new_z) result = { "city": cities, "zipcodes": zipcodes } return result def get_zip_code(self, town_info): lookup = Lookup() lookup.input_id = "dfc33cb6-829e-4fea-aa1b-b6d6580f0817" lookup.city = town_info["city"] lookup.state = town_info["state"] try: self._zip_client.send_lookup(lookup) except exceptions.SmartyException as err: print(err) return result_json = self._zip_lookup_to_json(lookup) result = result_json return result