session-per-request to session-over-time

nasdaqdatalink/connection.py

@@ -13,103 +13,109 @@
     AuthenticationError, ForbiddenError, InvalidRequestError,
     NotFoundError, ServiceUnavailableError)
 
+# global session
+session = None
 
-class Connection:
-    @classmethod
-    def request(cls, http_verb, url, **options):
-        if 'headers' in options:
-            headers = options['headers']
+
+def request(http_verb, url, **options):
+    if 'headers' in options:
+        headers = options['headers']
+    else:
+        headers = {}
+
+    accept_value = 'application/json'
+    if ApiConfig.api_version:
+        accept_value += ", application/vnd.data.nasdaq+json;version=%s" % ApiConfig.api_version
+
+    headers = Util.merge_to_dicts({
+        'accept': accept_value,
+        'request-source': 'python',
+        'request-source-version': VERSION
+        }, headers)
+    if ApiConfig.api_key:
+        headers = Util.merge_to_dicts({'x-api-token': ApiConfig.api_key}, headers)
+
+    options['headers'] = headers
+
+    abs_url = '%s/%s' % (ApiConfig.api_base, url)
+
+    return execute_request(http_verb, abs_url, **options)
+
+
+def execute_request(http_verb, url, **options):
+    session = get_session()
+
+    try:
+        response = session.request(
+            method=http_verb,
+            url=url,
+            verify=ApiConfig.verify_ssl,
+            **options
+            )
+        if response.status_code < 200 or response.status_code >= 300:
+            handle_api_error(response)
         else:
-            headers = {}
-
-        accept_value = 'application/json'
-        if ApiConfig.api_version:
-            accept_value += ", application/vnd.data.nasdaq+json;version=%s" % ApiConfig.api_version
-
-        headers = Util.merge_to_dicts({'accept': accept_value,
-                                       'request-source': 'python',
-                                       'request-source-version': VERSION}, headers)
-        if ApiConfig.api_key:
-            headers = Util.merge_to_dicts({'x-api-token': ApiConfig.api_key}, headers)
-
-        options['headers'] = headers
-
-        abs_url = '%s/%s' % (ApiConfig.api_base, url)
-
-        return cls.execute_request(http_verb, abs_url, **options)
-
-    @classmethod
-    def execute_request(cls, http_verb, url, **options):
-        session = cls.get_session()
-
-        try:
-            response = session.request(method=http_verb,
-                                       url=url,
-                                       verify=ApiConfig.verify_ssl,
-                                       **options)
-            if response.status_code < 200 or response.status_code >= 300:
-                cls.handle_api_error(response)
-            else:
-                return response
-        except requests.exceptions.RequestException as e:
-            if e.response:
-                cls.handle_api_error(e.response)
-            raise e
-
-    @classmethod
-    def get_session(cls):
+            return response
+    except requests.exceptions.RequestException as e:
+        if e.response:
+            handle_api_error(e.response)
+        raise e
+
+
+def get_retries():
+    if not ApiConfig.use_retries:
+        return Retry(total=0)
+
+    Retry.BACKOFF_MAX = ApiConfig.max_wait_between_retries
+    retries = Retry(total=ApiConfig.number_of_retries,
+                    connect=ApiConfig.number_of_retries,
+                    read=ApiConfig.number_of_retries,
+                    status_forcelist=ApiConfig.retry_status_codes,
+                    backoff_factor=ApiConfig.retry_backoff_factor,
+                    raise_on_status=False)
+
+    return retries
+
+
+def get_session():
+    global session
+    if session is None:
         session = requests.Session()
-        adapter = HTTPAdapter(max_retries=cls.get_retries())
+        adapter = HTTPAdapter(max_retries=get_retries())
         session.mount(ApiConfig.api_protocol, adapter)
-
-        return session
-
-    @classmethod
-    def get_retries(cls):
-        if not ApiConfig.use_retries:
-            return Retry(total=0)
-
-        Retry.BACKOFF_MAX = ApiConfig.max_wait_between_retries
-        retries = Retry(total=ApiConfig.number_of_retries,
-                        connect=ApiConfig.number_of_retries,
-                        read=ApiConfig.number_of_retries,
-                        status_forcelist=ApiConfig.retry_status_codes,
-                        backoff_factor=ApiConfig.retry_backoff_factor,
-                        raise_on_status=False)
-
-        return retries
-
-    @classmethod
-    def parse(cls, response):
-        try:
-            return response.json()
-        except ValueError:
-            raise DataLinkError(http_status=response.status_code, http_body=response.text)
-
-    @classmethod
-    def handle_api_error(cls, resp):
-        error_body = cls.parse(resp)
-
-        # if our app does not form a proper data_link_error response
-        # throw generic error
-        if 'error' not in error_body:
-            raise DataLinkError(http_status=resp.status_code, http_body=resp.text)
-
-        code = error_body['error']['code']
-        message = error_body['error']['message']
-        prog = re.compile('^QE([a-zA-Z])x')
-        if prog.match(code):
-            code_letter = prog.match(code).group(1)
-
-        d_klass = {
-            'L': LimitExceededError,
-            'M': InternalServerError,
-            'A': AuthenticationError,
-            'P': ForbiddenError,
-            'S': InvalidRequestError,
-            'C': NotFoundError,
-            'X': ServiceUnavailableError
-        }
-        klass = d_klass.get(code_letter, DataLinkError)
-
-        raise klass(message, resp.status_code, resp.text, resp.headers, code)
+    return session
+
+
+def parse(response):
+    try:
+        return response.json()
+    except ValueError:
+        raise DataLinkError(http_status=response.status_code, http_body=response.text)
+
+
+def handle_api_error(resp):
+    error_body = parse(resp)
+
+    # if our app does not form a proper data_link_error response
+    # throw generic error
+    if 'error' not in error_body:
+        raise DataLinkError(http_status=resp.status_code, http_body=resp.text)
+
+    code = error_body['error']['code']
+    message = error_body['error']['message']
+    prog = re.compile('^QE([a-zA-Z])x')
+    if prog.match(code):
+        code_letter = prog.match(code).group(1)
+
+    d_klass = {
+        'L': LimitExceededError,
+        'M': InternalServerError,
+        'A': AuthenticationError,
+        'P': ForbiddenError,
+        'S': InvalidRequestError,
+        'C': NotFoundError,
+        'X': ServiceUnavailableError
+    }
+    klass = d_klass.get(code_letter, DataLinkError)
+
+    raise klass(message, resp.status_code, resp.text, resp.headers, code)

nasdaqdatalink/model/database.py

@@ -4,7 +4,7 @@
 
 import nasdaqdatalink.model.dataset
 from nasdaqdatalink.api_config import ApiConfig
-from nasdaqdatalink.connection import Connection
+import nasdaqdatalink.connection as connection
 from nasdaqdatalink.errors.data_link_error import DataLinkError
 from nasdaqdatalink.message import Message
 from nasdaqdatalink.operations.get import GetOperation
@@ -43,7 +43,7 @@ def bulk_download_to_file(self, file_or_folder_path, **options):
         path_url = self._bulk_download_path()
 
         options['stream'] = True
-        r = Connection.request('get', path_url, **options)
+        r = connection.request('get', path_url, **options)
         file_path = file_or_folder_path
         if os.path.isdir(file_or_folder_path):
             file_path = file_or_folder_path + '/' + os.path.basename(urlparse(r.url).path)

nasdaqdatalink/model/datatable.py

@@ -3,7 +3,7 @@
 
 from six.moves.urllib.request import urlopen
 
-from nasdaqdatalink.connection import Connection
+import nasdaqdatalink.connection as connection
 from nasdaqdatalink.errors.data_link_error import DataLinkError
 from nasdaqdatalink.message import Message
 from nasdaqdatalink.operations.get import GetOperation
@@ -51,7 +51,7 @@ def _request_file_info(self, file_or_folder_path, **options):
 
         updated_options = Util.convert_options(request_type=request_type, **options)
 
-        r = Connection.request(request_type, url, **updated_options)
+        r = connection.request(request_type, url, **updated_options)
 
         response_data = r.json()
 

nasdaqdatalink/operations/get.py

@@ -1,7 +1,7 @@
 from inflection import singularize
 
 from .operation import Operation
-from nasdaqdatalink.connection import Connection
+import nasdaqdatalink.connection as connection
 from nasdaqdatalink.util import Util
 
 
@@ -21,7 +21,7 @@ def __get_raw_data__(self):
 
         path = Util.constructed_path(cls.get_path(), options['params'])
 
-        r = Connection.request('get', path, **options)
+        r = connection.request('get', path, **options)
         response_data = r.json()
         Util.convert_to_dates(response_data)
         self._raw_data = response_data[singularize(cls.lookup_key())]

nasdaqdatalink/operations/list.py

@@ -1,5 +1,5 @@
 from .operation import Operation
-from nasdaqdatalink.connection import Connection
+import nasdaqdatalink.connection as connection
 from nasdaqdatalink.util import Util
 from nasdaqdatalink.model.paginated_list import PaginatedList
 from nasdaqdatalink.utils.request_type_util import RequestType
@@ -12,7 +12,7 @@ def all(cls, **options):
         if 'params' not in options:
             options['params'] = {}
         path = Util.constructed_path(cls.list_path(), options['params'])
-        r = Connection.request('get', path, **options)
+        r = connection.request('get', path, **options)
         response_data = r.json()
         Util.convert_to_dates(response_data)
         resource = cls.create_list_from_response(response_data)
@@ -27,7 +27,7 @@ def page(cls, datatable, **options):
 
         updated_options = Util.convert_options(request_type=request_type, **options)
 
-        r = Connection.request(request_type, path, **updated_options)
+        r = connection.request(request_type, path, **updated_options)
 
         response_data = r.json()
         Util.convert_to_dates(response_data)

test/test_connection.py

@@ -1,4 +1,4 @@
-from nasdaqdatalink.connection import Connection
+import nasdaqdatalink.connection as connection
 from nasdaqdatalink.api_config import ApiConfig
 from nasdaqdatalink.errors.data_link_error import (
     DataLinkError, LimitExceededError, InternalServerError,
@@ -42,7 +42,7 @@ def test_nasdaqdatalink_exceptions_no_retries(self, request_method):
 
         for expected_error in data_link_errors:
             self.assertRaises(
-                expected_error[2], lambda: Connection.request(request_method, 'databases'))
+                expected_error[2], lambda: connection.request(request_method, 'databases'))
 
     @parameterized.expand(['GET', 'POST'])
     def test_parse_error(self, request_method):
@@ -51,7 +51,7 @@ def test_parse_error(self, request_method):
                                "https://data.nasdaq.com/api/v3/databases",
                                body="not json", status=500)
         self.assertRaises(
-            DataLinkError, lambda: Connection.request(request_method, 'databases'))
+            DataLinkError, lambda: connection.request(request_method, 'databases'))
 
     @parameterized.expand(['GET', 'POST'])
     def test_non_data_link_error(self, request_method):
@@ -62,16 +62,16 @@ def test_non_data_link_error(self, request_method):
                                 {'foobar':
                                  {'code': 'blah', 'message': 'something went wrong'}}), status=500)
         self.assertRaises(
-            DataLinkError, lambda: Connection.request(request_method, 'databases'))
+            DataLinkError, lambda: connection.request(request_method, 'databases'))
 
     @parameterized.expand(['GET', 'POST'])
-    @patch('nasdaqdatalink.connection.Connection.execute_request')
+    @patch('nasdaqdatalink.connection.execute_request')
     def test_build_request(self, request_method, mock):
         ApiConfig.api_key = 'api_token'
         ApiConfig.api_version = '2015-04-09'
         params = {'per_page': 10, 'page': 2}
         headers = {'x-custom-header': 'header value'}
-        Connection.request(request_method, 'databases', headers=headers, params=params)
+        connection.request(request_method, 'databases', headers=headers, params=params)
         expected = call(request_method, 'https://data.nasdaq.com/api/v3/databases',
                         headers={'x-custom-header': 'header value',
                                  'x-api-token': 'api_token',
@@ -81,3 +81,15 @@ def test_build_request(self, request_method, mock):
                                  'request-source-version': VERSION},
                         params={'per_page': 10, 'page': 2})
         self.assertEqual(mock.call_args, expected)
+
+    def test_session_reuse(self):
+        session1 = connection.get_session()
+        session2 = connection.get_session()
+        areSessionsSame = session1 is session2
+
+        adapter1 = connection.get_session().get_adapter(ApiConfig.api_protocol)
+        adapter2 = connection.get_session().get_adapter(ApiConfig.api_protocol)
+        areAdaptersSame = adapter1 is adapter2
+
+        self.assertEqual(areAdaptersSame, True)
+        self.assertEqual(areSessionsSame, True)

test/test_data.py

@@ -77,7 +77,7 @@ def tearDownClass(cls):
         httpretty.disable()
         httpretty.reset()
 
-    @patch('nasdaqdatalink.connection.Connection.request')
+    @patch('nasdaqdatalink.connection.request')
     def test_data_calls_connection(self, mock):
         Data.all(params={'database_code': 'NSE', 'dataset_code': 'OIL'})
         expected = call('get', 'datasets/NSE/OIL/data', params={})

test/test_database.py

@@ -7,7 +7,7 @@
 from six.moves.urllib.parse import parse_qs, urlparse
 
 from nasdaqdatalink.api_config import ApiConfig
-from nasdaqdatalink.connection import Connection
+import nasdaqdatalink.connection as connection
 from nasdaqdatalink.errors.data_link_error import (InternalServerError, DataLinkError)
 from nasdaqdatalink.model.database import Database
 from test.factories.database import DatabaseFactory
@@ -34,7 +34,7 @@ def tearDownClass(cls):
         httpretty.disable()
         httpretty.reset()
 
-    @patch('nasdaqdatalink.connection.Connection.request')
+    @patch('nasdaqdatalink.connection.request')
     def test_database_calls_connection(self, mock):
         database = Database('NSE')
         database.data_fields()
@@ -80,7 +80,7 @@ def tearDownClass(cls):
         httpretty.disable()
         httpretty.reset()
 
-    @patch('nasdaqdatalink.connection.Connection.request')
+    @patch('nasdaqdatalink.connection.request')
     def test_databases_calls_connection(self, mock):
         Database.all()
         expected = call('get', 'databases', params={})
@@ -148,7 +148,7 @@ def test_get_bulk_download_url_without_download_type(self):
 
     def test_bulk_download_to_fileaccepts_download_type(self):
         m = mock_open()
-        with patch.object(Connection, 'request') as mock_method:
+        with patch.object(connection, 'request') as mock_method:
             mock_method.return_value.url = 'https://www.blah.com/download/db.zip'
             with patch('nasdaqdatalink.model.database.open', m, create=True):
                 self.database.bulk_download_to_file(