cleaning and refactoring

Author: slawek87

geolocation/api.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+import requests
+from geolocation.validators import ResponseValidator
+
+
+class ApiClient(object):
+    """
+    Client class:
+        - sends request to API
+        - returns data from API
+        - handles exceptions
+    All clients should inheritance by this class.
+    """
+    api_key = None  # api key for google maps.
+    validator = ResponseValidator
+
+    def __repr__(self):
+        return '<ApiClient: %s>' % self.api_key
+
+    def send_data(self, url, params=None):
+        """Method class url api and returns json data."""
+        response = requests.get(url, params=params)
+        self.validator(response)
+
+        return response.json()

geolocation/client.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+from decimal import Decimal
+from geolocation.client import ApiClient
+
+
+class DistanceMatrixApiClient(ApiClient):
+    """
+    Client Class for Distance Matrix Google Maps Api.
+    Field query_parameters has keys:
+        - origins (multi origins are separated by '|')
+        - destinations (multi destinations are separated by '|')
+        - mode
+        - avoid
+    Documentation: https://developers.google.com/maps/documentation/distance-matrix/
+    """
+    API_URL = 'https://maps.googleapis.com/maps/api/distancematrix/json?'
+
+    ONE_MILE = Decimal(0.62137)  # km units
+    ONE_FEET = Decimal(3.2808)
+    ONE_KILOMETER = Decimal(1000.00)  # m units
+
+    UNIT_KM = 'km'
+    UNIT_M = 'm'
+
+    MODE_DRIVING = 'driving'
+    MODE_WALKING = 'walking'
+    MODE_BICYCLING = 'bicycling'
+    MODE_TRANSIT = 'transit'
+
+    MODES = (
+        (MODE_DRIVING, 'driving'),
+        (MODE_WALKING, 'walking'),
+        (MODE_BICYCLING, 'bicycling'),
+        (MODE_TRANSIT, 'transit')
+    )
+
+    AVOID_TOLLS = 'tools'
+    AVOID_HIGHWAYS = 'highways'
+    AVOID_FERRIES = 'ferries'
+
+    AVOIDS = (
+        (AVOID_TOLLS, 'tools'),
+        (AVOID_HIGHWAYS, 'highways'),
+        (AVOID_FERRIES, 'ferries')
+    )
+
+    query_parameters = {}
+
+    def __repr__(self):
+        return '<DistanceMatrixApiClient: %s>' % self.api_key
+
+    def set_query_parameters(self, origins, destinations, mode=MODE_DRIVING, avoid=None):
+        """Method sets values for query_parameters."""
+        def prepare_multi_params(value):
+            return '|'.join(value) if isinstance(value, list) else value
+
+        self.query_parameters['origins'] = prepare_multi_params(origins)
+        self.query_parameters['destinations'] = prepare_multi_params(destinations)
+        self.query_parameters['mode'] = mode
+
+        if avoid:
+            self.query_parameters['avoid'] = avoid
+
+    def get_data(self, origins, destinations, mode=MODE_DRIVING, avoid=None):
+        """Method returns json data fetched by calls from API_URL."""
+        self.set_query_parameters(
+            origins=origins,
+            destinations=destinations,
+            mode=mode,
+            avoid=avoid
+        )
+        return self.send_data(self.API_URL, self.query_parameters)
+
+
+
+

geolocation/const.py

@@ -1,54 +1,53 @@
 # encoding: utf-8
 
-from geolocation.distance_matrix.api import DistanceMatrixApi
+from geolocation.distance_matrix.client import DistanceMatrixApiClient
 from geolocation.distance_matrix.models import DistanceMatrixModel
 from geolocation.distance_matrix.parser import DistanceMatrixParser
 from geolocation.managers import Manager
 
 
 class DistanceMatrix(object):
+    client = DistanceMatrixApiClient()
     parser = DistanceMatrixParser()
     manager = Manager()
 
     def __init__(self, api_key):
-        self.api = DistanceMatrixApi(api_key)
+        self.client.api_key = api_key
 
-    def to_python(self, json_data):
+    def build(self, data):
         """Method should converts json_data to python object."""
         self.manager.clear()  # always clear manager data.
 
-        self.parser.json_data = json_data
+        self.parser.data = data
 
-        origins = self.parser.get_origin()
-        destinations = self.parser.get_destination()
+        origins = self.parser.prase_origin()
+        destinations = self.parser.parse_destination()
 
-        rows = self.parser.get_rows()
+        rows = self.parser.parse_rows()
 
         origin_counter = 0
 
         for origin in origins:
             destination_counter = 0
 
             for element in rows[origin_counter].get('elements'):
-                self.parser.json_data = element
+                self.parser.data = element
 
                 model = DistanceMatrixModel()
                 model.origin = origin
                 model.destination = destinations[destination_counter]
-                model.distance = self.parser.get_distance()
-                model.duration = self.parser.get_duration()
+                model.distance = self.parser.parse_distance()
+                model.duration = self.parser.parse_duration()
 
                 self.manager.data.add(model)
 
                 destination_counter += 1
 
             origin_counter += 1
 
-    def distance(self, origins, destinations, mode, avoid=None):
+    def distance(self, origins, destinations, mode=None, avoid=None):
         """Method returns distance between origins and destination."""
-        json_data = self.api.query(origins, destinations, mode, avoid)
-
-        if json_data:
-            self.to_python(json_data)
-
-        return self.manager
+        data = self.client.get_data(origins, destinations, mode, avoid)
+        if data:
+            self.build(data)
+        return self.manager