Add Flight Choice Prediction API

Author: Alvaro Navarro

README.rst

@@ -207,7 +207,11 @@ List of supported endpoints
 
     # Flight Low-fare Search
     amadeus.shopping.flight_offers.get(origin='MAD', destination='NYC', departureDate='2019-08-01')
-    
+
+    # Flight Choice Prediction 
+    result = amadeus.shopping.flight_offers.get(origin='MAD', destination='NYC', departureDate='2019-08-01').result
+    amadeus.shopping.flight_offers.prediction.post(result)
+
     # Flight Checkin Links
     amadeus.reference_data.urls.checkin_links.get(airlineCode='BA')
 
@@ -245,6 +249,7 @@ List of supported endpoints
     amadeus.shopping.hotel_offers_by_hotel.get(hotelId = 'IALONCHO')
     # Confirm the availability of a specific offer
     amadeus.shopping.hotel_offer('D5BEE9D0D08B6678C2F5FAD910DC110BCDA187D21D4FCE68ED423426D0A246BB').get()
+    
     # Point of Interest
     # What are the popular places in Barcelona (based a geo location and a radius)
     amadeus.reference_data.locations.points_of_interest.get(latitude=41.397158, longitude=2.160873)

amadeus/client/request.py

@@ -1,5 +1,8 @@
 # Support Python 2 and 3 API calls without importing
 # a 3rd party library
+
+import json
+
 try:
     from urllib.request import Request as HTTPRequest
     from urllib.parse import urlencode
@@ -54,16 +57,6 @@ class Request(object):
     '''
 
     def __init__(self, options):
-        self.http_request = None
-        self.__initialize_options(options)
-        self.__initialize_headers()
-        self.__build_http_request()
-
-    # PRIVATE
-
-    # Initializes the Request object with all the passed in params. These
-    # do not change once set
-    def __initialize_options(self, options):
         self.host = options['host']
         self.port = options['port']
         self.ssl = options['ssl']
@@ -77,13 +70,16 @@ def __initialize_options(self, options):
         self.app_id = options['app_id']
         self.app_version = options['app_version']
 
-    # Initializes the basic headers
-    def __initialize_headers(self):
         self.headers = {
             'User-Agent': self.__build_user_agent(),
             'Accept': 'application/json, application/vnd.amadeus+json'
         }
 
+        self.url = self.__build_url()
+        self.http_request = self.__build_http_request()
+
+    # PRIVATE
+
     # Determines the User Agent
     def __build_user_agent(self):
         user_agent = 'amadeus-python/{0}'.format(self.client_version)
@@ -92,30 +88,31 @@ def __build_user_agent(self):
             user_agent += ' {0}/{1}'.format(self.app_id, self.app_version)
         return user_agent
 
-    # Builds up a HTTP Request objectm if not akready set
+    # Builds a HTTP Request object based on the path, params, and verb
     def __build_http_request(self):
-        request = self.__request_for_verb()
-        self.__add_post_data_header()
-        self.__add_bearer_token_header()
-        self.__apply_headers(request)
-        self.http_request = request
+        # Requests token in case has not been set
+        if (self.bearer_token is None):
+            self.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+            return HTTPRequest(self.url,
+                               data=urlencode(self.params).encode(),
+                               headers=self.headers)
 
-    # Builds a HTTP Request object based on the path, params, and verb
-    def __request_for_verb(self):
-        params = self._encoded_params().encode()
-        path = self.__full_url()
+        # Adds the authentication header since the bearer token has been set
+        self.headers['Authorization'] = self.bearer_token
 
         if (self.verb == 'GET'):
-            return HTTPRequest(path)
+            return HTTPRequest(self.url, headers=self.headers)
         else:
-            return HTTPRequest(path, params)
+            return HTTPRequest(self.url,
+                               data=json.dumps(self.params).encode(),
+                               headers=self.headers)
 
     # Encodes the params before sending them
     def _encoded_params(self):
         return self._urlencode(self.params)
 
     # Builds up the full URL based on the scheme, host, path, and params
-    def __full_url(self):
+    def __build_url(self):
         full_url = '{0}://{1}'.format(self.scheme, self.host)
         if not self.__port_matches_scheme():
             full_url = '{0}:{1}'.format(full_url, self.port)
@@ -128,20 +125,6 @@ def __port_matches_scheme(self):
         return ((self.ssl and self.port == 443) or
                 (not self.ssl and self.port == 80))
 
-    # Adds an extra header if the verb is POST
-    def __add_post_data_header(self):
-        if (self.verb == 'POST'):
-            self.headers['Content-Type'] = 'application/x-www-form-urlencoded'
-
-    # Adds the authentication header if the bearer token has been set
-    def __add_bearer_token_header(self):
-        if (self.bearer_token is not None):
-            self.headers['Authorization'] = self.bearer_token
-
-    # Applies all the headers to the HTTP Request object
-    def __apply_headers(self, http_request):
-        http_request.headers = self.headers
-
     # Helper method to prepare the parameter encoding
     def _urlencode(self, d):
         return urlencode(self._flatten_keys(d, '', {}))

amadeus/mixins/http.py

@@ -40,9 +40,9 @@ def get(self, path, **params):
         :rtype: amadeus.Response
         :raises amadeus.ResponseError: when the request fails
         '''
-        return self.request('GET', path, **params)
+        return self.request('GET', path, params)
 
-    def post(self, path, **params):
+    def post(self, path, params={}):
         '''
         A helper function for making generic POST requests calls. It is used by
         every namespaced API POST method.
@@ -63,9 +63,9 @@ def post(self, path, **params):
         :rtype: amadeus.Response
         :raises amadeus.ResponseError: when the request fails
         '''
-        return self.request('POST', path, **params)
+        return self.request('POST', path, params)
 
-    def request(self, verb, path, **params):
+    def request(self, verb, path, params):
         '''
         A helper function for making generic POST requests calls. It is used by
         every namespaced API method. It can be used to make any generic API

amadeus/mixins/pagination.py

@@ -30,7 +30,7 @@ def __page(self, name, response):
         return self.request(
             response.request.verb,
             response.request.path,
-            **params
+            params
         )
 
     def __page_number_for(self, name, response):

amadeus/shopping/_flight_offers.py

@@ -1,14 +1,19 @@
 from amadeus.client.decorator import Decorator
+from amadeus.shopping.flight_offers._prediction import FlightChoicePrediction
 
 
 class FlightOffers(Decorator, object):
+    def __init__(self, client):
+        Decorator.__init__(self, client)
+        self.prediction = FlightChoicePrediction(client)
+
     def get(self, **params):
         '''
         Find the cheapest bookable flights.
 
         .. code-block:: python
 
-            amadeus.shopping.flight_destinations.get(
+            amadeus.shopping.flight_offers.get(
                 origin='MAD',
                 destination='NYC',
                 departureDate='2019-08-01'

amadeus/shopping/flight_offers/__init__.py

@@ -0,0 +1,3 @@
+from ._prediction import FlightChoicePrediction
+
+__all__ = ['FlightChoicePrediction']

amadeus/shopping/flight_offers/_prediction.py

@@ -0,0 +1,21 @@
+from amadeus.client.decorator import Decorator
+
+
+class FlightChoicePrediction(Decorator, object):
+    def post(self, body):
+        '''
+        Forecast traveler choices in the context of search & shopping.
+
+        .. code-block:: python
+
+            amadeus.shopping.flight_offers.prediction.post(
+                amadeus.shopping.flight_offers.get(origin='MAD',
+                destination='NYC',
+                departureDate='2019-08-01'
+            ).body
+        )
+
+        :rtype: amadeus.Response
+        :raises amadeus.ResponseError: if the request could not be completed
+        '''
+        return self.client.post('/v1/shopping/flight-offers/prediction', body)

specs/client/request_spec.py

@@ -64,7 +64,7 @@
             expect(self.request.http_request.get_header('Accept')).to(
                 equal('application/json, application/vnd.amadeus+json')
             )
-            expect(self.request.http_request.get_header('User-Agent')).to(
+            expect(self.request.http_request.get_header('User-agent')).to(
                 equal('amadeus-python/1.2.3 python/2.3.4 amadeus-cli/3.4.5')
             )
 
@@ -86,9 +86,8 @@
             expect(self.request.http_request).to(be_a(HTTPRequest))
             expect(self.request.http_request.get_full_url()).to(equal(
                 'https://example.com/foo/bar'))
-            expect(self.request.http_request.data).to(equal(b'foo=bar'))
-            expect(self.request.http_request.get_header('Content-Type')).to(
-                equal('application/x-www-form-urlencoded'))
+            expect(self.request.http_request.data).to(
+                equal(b'{\"foo\": \"bar\"}'))
 
         with it('should handle a custom scheme and port'):
             self.request = Request({

specs/mixins/http_spec.py

@@ -26,23 +26,23 @@
             response = self.client.get('/foo', foo='bar')
             expect(response).to(equal(self.response))
             expect(self.client.request).to(
-                have_been_called_with('GET', '/foo', foo='bar')
+                have_been_called_with('GET', '/foo', {'foo': 'bar'})
             )
 
     with context('Client.post'):
         with it('should pass all details to the request method'):
             self.client.request = self.request_method
-            response = self.client.post('/foo', foo='bar')
+            response = self.client.post('/foo', {'foo': 'bar'})
             expect(response).to(equal(self.response))
             expect(self.client.request).to(
-                have_been_called_with('POST', '/foo', foo='bar')
+                have_been_called_with('POST', '/foo', {'foo': 'bar'})
             )
 
     with context('Client.request'):
         with it('should pass on to the _unauthenticated_request method'):
             self.response.result = {'access_token': '123'}
             self.client._unauthenticated_request = self.request_method
-            response = self.client.request('POST', '/foo', foo='bar')
+            response = self.client.request('POST', '/foo', {'foo': 'bar'})
             expect(response).to(equal(self.response))
             expect(self.client._unauthenticated_request).to(
                 have_been_called_with(
@@ -53,11 +53,11 @@
         with it('should use the same access token when cashed'):
             self.response.result = {'access_token': '123', 'expires_in': 2000}
             self.client._unauthenticated_request = self.request_method
-            self.client.request('POST', '/foo', foo='bar')
+            self.client.request('POST', '/foo', {'foo': 'bar'})
 
             self.response.result = {'access_token': '234', 'expires_in': 2000}
             self.client._unauthenticated_request = self.request_method
-            self.client.request('POST', '/foo', foo='bar')
+            self.client.request('POST', '/foo', {'foo': 'bar'})
 
             expect(self.client._unauthenticated_request).not_to(
                 have_been_called_with(

specs/mixins/pagination_spec.py

@@ -31,7 +31,8 @@
 
             next_response = self.pagination.previous(self.response)
             expect(self.client.request).to(
-                have_been_called_with('GET', '/a', a='b', page={'offset': '1'})
+                have_been_called_with('GET', '/a',
+                                      {'a': 'b', 'page': {'offset': '1'}})
             )
             expect(next_response).to(equal(self.next_response))
 
@@ -48,7 +49,8 @@
 
             next_response = self.pagination.next(self.response)
             expect(self.client.request).to(
-                have_been_called_with('GET', '/a', a='b', page={'offset': '1'})
+                have_been_called_with('GET', '/a',
+                                      {'a': 'b', 'page': {'offset': '1'}})
             )
             expect(next_response).to(equal(self.next_response))
 
@@ -65,7 +67,8 @@
 
             next_response = self.pagination.first(self.response)
             expect(self.client.request).to(
-                have_been_called_with('GET', '/a', a='b', page={'offset': '1'})
+                have_been_called_with('GET', '/a',
+                                      {'a': 'b', 'page': {'offset': '1'}})
             )
             expect(next_response).to(equal(self.next_response))
 
@@ -83,7 +86,8 @@
 
             next_response = self.pagination.last(self.response)
             expect(self.client.request).to(
-                have_been_called_with('GET', '/a', a='b', page={'offset': '1'})
+                have_been_called_with('GET', '/a',
+                                      {'a': 'b', 'page': {'offset': '1'}})
             )
             expect(next_response).to(equal(self.next_response))