cc-py-commons 0.5.13__tar.gz → 0.5.15__tar.gz

{cc_py_commons-0.5.13 → cc_py_commons-0.5.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cc_py_commons
-Version: 0.5.13
+Version: 0.5.15
 Summary: Common code for microservices
 Home-page: https://github.com/Cargo-Chief/py-commons
 Author: CargoChief

{cc_py_commons-0.5.13 → cc_py_commons-0.5.15}/cc_py_commons/geolocate.py

@@ -25,7 +25,7 @@ def get_location_with_country(city, state, zipcode, country, logger, reset_cache
       from_cache = True
     else:
       logger.debug(json.dumps({
-        'message': 'Found locatin in cache that was not a match',
+        'message': 'Found location in cache that was not a match',
         'city': city,
         'state': state,
         'zipcode': zipcode,
@@ -50,6 +50,23 @@ def get_location_with_country(city, state, zipcode, country, logger, reset_cache
     from_cache = False
     data = __get_google_location(city=None, state=None, zipcode=postcode, country=None, logger=logger)
 
+  if data and not data.get('postcode'):
+    matching_location = __get_matching_location_from_cache(city, state, data.get('lat'), data.get('lng'), logger)
+    if matching_location:
+      data['postcode'] = matching_location.get('postcode')
+    else:
+      gmaps = googlemaps.Client(key=app_config.GOOGLE_API_KEY)
+      response = None
+      if zipcode:
+          response = gmaps.geocode(zipcode)
+      elif data.get('lat') and data.get('lng'):
+          response = gmaps.reverse_geocode((data.get('lat'), data.get('lng')))
+      post_code_data = __parse_response(response, city)
+      data['postcode'] = post_code_data['postcode'] if post_code_data else None
+
+    if data.get('postcode'):
+      __cache_location(city, state, zipcode, data, logger)
+
   if data:
     if not from_cache:
       __cache_location(city, state, zipcode, data, logger)
@@ -127,7 +144,10 @@ def __get_google_distance(origin_latitude, origin_longitude, destination_latitud
 
 def __get_google_location(city, state, zipcode, country, logger):
   try:
+    if (not city or not state) and not zipcode:
+      return None
     loc_str = ''
+    data = None
 
     if city:
       loc_str = city
@@ -150,123 +170,6 @@ def __get_google_location(city, state, zipcode, country, logger):
 
       loc_str = loc_str + country
 
-    def __parse_response(response):
-      if not response or len(response) == 0:
-        return None
-      ''' 
-        Sample response of Google Maps API for address: Cincinati, OH, 45204
-        {
-            "address_components": [
-                {
-                    "long_name": "45204",
-                    "short_name": "45204",
-                    "types": [
-                        "postal_code"
-                    ]
-                },
-                {
-                    "long_name": "Cincinnati",
-                    "short_name": "Cincinnati",
-                    "types": [
-                        "locality",
-                        "political"
-                    ]
-                },
-                {
-                    "long_name": "Hamilton County",
-                    "short_name": "Hamilton County",
-                    "types": [
-                        "administrative_area_level_2",
-                        "political"
-                    ]
-                },
-                {
-                    "long_name": "Ohio",
-                    "short_name": "OH",
-                    "types": [
-                        "administrative_area_level_1",
-                        "political"
-                    ]
-                },
-                {
-                    "long_name": "United States",
-                    "short_name": "US",
-                    "types": [
-                        "country",
-                        "political"
-                    ]
-                }
-            ],
-            "formatted_address": "Cincinnati, OH 45204, USA",
-            "geometry": {
-                "bounds": {
-                    "northeast": {
-                        "lat": 39.1251898,
-                        "lng": -84.539683
-                    },
-                    "southwest": {
-                        "lat": 39.073286,
-                        "lng": -84.62870989999999
-                    }
-                },
-                "location": {
-                    "lat": 39.0930395,
-                    "lng": -84.56676650000001
-                },
-                "location_type": "APPROXIMATE",
-                "viewport": {
-                    "northeast": {
-                        "lat": 39.1251898,
-                        "lng": -84.539683
-                    },
-                    "southwest": {
-                        "lat": 39.073286,
-                        "lng": -84.62870989999999
-                    }
-                }
-            },
-            "place_id": "ChIJjYEP0hK2QYgRTJoYykoQeqw",
-            "postcode_localities": [
-                "Cincinnati",
-                "Queen City Square"
-            ],
-            "types": [
-                "postal_code"
-            ]
-        }
-      '''
-      components = response[0]['address_components']
-      types = response[0]['types']
-      location = response[0]['geometry']['location']
-      postcode_localities = response[0].get('postcode_localities', None)
-
-      data = { 'city': None, 'state': None, 'postcode': None }
-      data['lat'] = location['lat']
-      data['lng'] = location['lng']
-
-      # when checking the response for a zipcode verify the city name is in the list of localities
-      if 'postal_code' in types and postcode_localities and city:
-        matches = [l for l in components if (
-                    'postal_localities' in l.get('types') and
-                    (l.short_name.lower() == city.lower() or l.long_name.lower() == city.lower())
-        )]
-        city_present_in_postcode_localities = (city in postcode_localities)
-
-        if not matches and not city_present_in_postcode_localities:
-          return None
-
-      for component in components:
-        if 'locality' in component['types']:
-          data['city'] = component['short_name']
-        elif 'administrative_area_level_1' in component['types']:
-          data['state'] = component['short_name']
-        elif 'postcode' in component['types'] or 'postal_code' in component['types']:
-          data['postcode'] = component['short_name']
-        elif 'country' in component['types']:
-          data['country'] = component['short_name']
-
-      return data
-
     gmaps = googlemaps.Client(key=app_config.GOOGLE_API_KEY)
     response = gmaps.geocode(loc_str)
     
@@ -282,20 +185,7 @@ def __get_google_location(city, state, zipcode, country, logger):
           logger.warning(f"Cannot select a single address from multiple for {loc_str}.")
           return None
         response = [selected_address]
-
-      data = __parse_response(response)
-      
-      # For some locals like neighborhood google does not return postal_code
-      ## if zipcode is present run it only and verify against city
-      if data and not data['postcode']:
-        if zipcode:
-          response = gmaps.geocode(zipcode)
-        else:
-          response = gmaps.reverse_geocode((data['lat'], data['lng']))
-        post_code_data = __parse_response(response)
-        data['postcode'] = post_code_data['postcode'] if post_code_data else None
-        if data['postcode']:
-          __cache_location(city, state, zipcode, data, logger)
+        data = __parse_response(response, city)
       return data
   except googlemaps.exceptions.Timeout as e:
     msg = "geolocate.__get_google_location - Location lookup timed out {0}, {1}, {2}: {3}".format(city, state, zipcode, e)
@@ -314,6 +204,123 @@ def __get_google_location(city, state, zipcode, country, logger):
 
   return None
 
+def __parse_response(response, city):
+    if not response or len(response) == 0:
+        return None
+    ''' 
+      Sample response of Google Maps API for address: Cincinati, OH, 45204
+      {
+          "address_components": [
+              {
+                  "long_name": "45204",
+                  "short_name": "45204",
+                  "types": [
+                      "postal_code"
+                  ]
+              },
+              {
+                  "long_name": "Cincinnati",
+                  "short_name": "Cincinnati",
+                  "types": [
+                      "locality",
+                      "political"
+                  ]
+              },
+              {
+                  "long_name": "Hamilton County",
+                  "short_name": "Hamilton County",
+                  "types": [
+                      "administrative_area_level_2",
+                      "political"
+                  ]
+              },
+              {
+                  "long_name": "Ohio",
+                  "short_name": "OH",
+                  "types": [
+                      "administrative_area_level_1",
+                      "political"
+                  ]
+              },
+              {
+                  "long_name": "United States",
+                  "short_name": "US",
+                  "types": [
+                      "country",
+                      "political"
+                  ]
+              }
+          ],
+          "formatted_address": "Cincinnati, OH 45204, USA",
+          "geometry": {
+              "bounds": {
+                  "northeast": {
+                      "lat": 39.1251898,
+                      "lng": -84.539683
+                  },
+                  "southwest": {
+                      "lat": 39.073286,
+                      "lng": -84.62870989999999
+                  }
+              },
+              "location": {
+                  "lat": 39.0930395,
+                  "lng": -84.56676650000001
+              },
+              "location_type": "APPROXIMATE",
+              "viewport": {
+                  "northeast": {
+                      "lat": 39.1251898,
+                      "lng": -84.539683
+                  },
+                  "southwest": {
+                      "lat": 39.073286,
+                      "lng": -84.62870989999999
+                  }
+              }
+          },
+          "place_id": "ChIJjYEP0hK2QYgRTJoYykoQeqw",
+          "postcode_localities": [
+              "Cincinnati",
+              "Queen City Square"
+          ],
+          "types": [
+              "postal_code"
+          ]
+      }
+    '''
+    components = response[0]['address_components']
+    types = response[0]['types']
+    location = response[0]['geometry']['location']
+    postcode_localities = response[0].get('postcode_localities', None)
+
+    data = {'city': None, 'state': None, 'postcode': None}
+    data['lat'] = location['lat']
+    data['lng'] = location['lng']
+
+    # when checking the response for a zipcode verify the city name is in the list of localities
+    if 'postal_code' in types and postcode_localities and city:
+        matches = [l for l in components if (
+            'postal_localities' in l.get('types') and
+            (l.short_name.lower() == city.lower() or l.long_name.lower() == city.lower())
+        )]
+        city_present_in_postcode_localities = (city in postcode_localities)
+
+        if not matches and not city_present_in_postcode_localities:
+            return None
+
+    for component in components:
+        if 'locality' in component['types']:
+            data['city'] = component['short_name']
+        elif 'administrative_area_level_1' in component['types']:
+            data['state'] = component['short_name']
+        elif 'postcode' in component['types'] or 'postal_code' in component['types']:
+            data['postcode'] = component['short_name']
+        elif 'country' in component['types']:
+            data['country'] = component['short_name']
+
+    return data
+
 def __cache_location(city, state, zipcode, location_data, logger):
     location_string = __get_location_string(city, state, zipcode)
     location_db_conn.set(location_string, str(location_data))
@@ -404,3 +411,20 @@ def __select_address(city, state, address_list):
       and parsed_city_and_state['state'].strip().lower() == state.strip().lower():
       return parsed_city_and_state['address']
   return None
+
+def __get_matching_location_from_cache(city, state, lat, lng, logger):
+    matching_location = None
+    try:
+        if city and state and lat and lng:
+            key = __get_location_string(city, state, None)
+            pattern = f'{key}*'
+            matching_keys = location_db_conn.keys(pattern)
+            if matching_keys:
+                for matching_key in matching_keys:
+                    location = literal_eval(location_db_conn.get(matching_key).decode('utf-8'))
+                    if location.get('lat') == lat and location.get('lng') == lng and location.get('postcode'):
+                        matching_location = location
+                        break
+    except Exception as e:
+        logger.warn("geolocate.__get_matching_location_from_cache: Failed: ", e)
+    return matching_location

{cc_py_commons-0.5.13 → cc_py_commons-0.5.15}/cc_py_commons.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cc-py-commons
-Version: 0.5.13
+Version: 0.5.15
 Summary: Common code for microservices
 Home-page: https://github.com/Cargo-Chief/py-commons
 Author: CargoChief

{cc_py_commons-0.5.13 → cc_py_commons-0.5.15}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 setup(
     name='cc_py_commons',
     description='Common code for microservices',
-    version='0.5.13',
+    version='0.5.15',
     url='https://github.com/Cargo-Chief/py-commons',
     author='CargoChief',
     author_email='engineering@cargochief.com',