modified to Python3 compatible

Author: yliu1010

config/config_request.py

@@ -75,7 +75,7 @@ def process_requests(self):
                     filter_req.input_file_path = get_response.file_path
                 filter_response = filter_req.filter()
                 if filter_response.status_code != SUCCESS_CODE:
-                    print filter_response.message
+                    print(filter_response.message)
         return True
 
     def __load_config(self):

feed_cli.py

@@ -78,7 +78,7 @@
                                         args.format)
     filter_response = feed_filter_obj.filter()
     if filter_response.status_code != SUCCESS_CODE:
-        print filter_response.message
+        print(filter_response.message)
 
 else:
     # download the feed file if --filteronly option is not set
@@ -95,10 +95,10 @@
                                             args.format)
         filter_response = feed_filter_obj.filter()
         if filter_response.status_code != SUCCESS_CODE:
-            print filter_response.message
+            print(filter_response.message)
 end = time.time()
 logger.info('Execution time (s): %s', str(round(end - start, 3)))
-print 'Execution time (s): %s' % str(round(end - start, 3))
+print('Execution time (s): %s' % str(round(end - start, 3)))
 
 
 

tests/test_config_request.py

@@ -10,37 +10,37 @@ def test_parse_requests(self):
         cr = ConfigFileRequest('../tests/test-data/test_config')
         cr.parse_requests('Bearer v^1...')
         self.assertIsNotNone(cr.requests)
-        self.assertEquals(len(cr.requests), 3)
+        self.assertEqual(len(cr.requests), 3)
 
         # first request has both feed and filter requests
         feed_req = cr.requests[0].feed_obj
         filter_req = cr.requests[0].filter_request_obj
         self.assertIsNotNone(feed_req)
         self.assertIsNotNone(filter_req)
-        self.assertEquals(feed_req.category_id, u'260')
-        self.assertEquals(filter_req.price_lower_limit, 10)
+        self.assertEqual(feed_req.category_id, u'260')
+        self.assertEqual(filter_req.price_lower_limit, 10)
 
         # second request has a feed request only
         self.assertIsNone(cr.requests[1].filter_request_obj)
         feed_req = cr.requests[1].feed_obj
         self.assertIsNotNone(feed_req)
         self.assertIsNotNone(feed_req.token)
-        self.assertEquals(feed_req.category_id, u'220')
-        self.assertEquals(feed_req.marketplace_id, u'EBAY_US')
-        self.assertEquals(feed_req.feed_date, '20190127')
-        self.assertEquals(feed_req.feed_scope, FeedScope.DAILY.value)
-        self.assertEquals(feed_req.download_location, DEFAULT_DOWNLOAD_LOCATION)
+        self.assertEqual(feed_req.category_id, u'220')
+        self.assertEqual(feed_req.marketplace_id, u'EBAY_US')
+        self.assertEqual(feed_req.feed_date, '20190127')
+        self.assertEqual(feed_req.feed_scope, FeedScope.DAILY.value)
+        self.assertEqual(feed_req.download_location, DEFAULT_DOWNLOAD_LOCATION)
 
         # third request has a filter request only
         self.assertIsNone(cr.requests[2].feed_obj)
         filter_req = cr.requests[2].filter_request_obj
         self.assertIsNotNone(filter_req)
-        self.assertEquals(filter_req.input_file_path, '/Users/[USER]/Desktop/sdk/test_bootstrap.gz')
-        self.assertEquals(filter_req.leaf_category_ids, ['112529', '64619', '111694'])
-        self.assertEquals(filter_req.item_location_countries, ['DE', 'GB', 'ES'])
-        self.assertEquals(filter_req.any_query,
+        self.assertEqual(filter_req.input_file_path, '/Users/[USER]/Desktop/sdk/test_bootstrap.gz')
+        self.assertEqual(filter_req.leaf_category_ids, ['112529', '64619', '111694'])
+        self.assertEqual(filter_req.item_location_countries, ['DE', 'GB', 'ES'])
+        self.assertEqual(filter_req.any_query,
                           '(AvailabilityThresholdType=\'MORE_THAN\' AND AvailabilityThreshold=10)')
-        self.assertEquals(filter_req.compression_type, FileFormat.GZIP.value)
+        self.assertEqual(filter_req.compression_type, FileFormat.GZIP.value)
 
 
 if __name__ == '__main__':

tests/test_feed_filter.py

@@ -26,57 +26,57 @@ def test_default_values(self):
         self.assertIsNone(filter_request.item_location_countries)
         self.assertIsNone(filter_request.any_query)
         self.assertIsNone(filter_request.filtered_file_path)
-        self.assertEquals(filter_request.compression_type, FileFormat.GZIP.value)
-        self.assertEquals(filter_request.separator, '\t')
-        self.assertEquals(filter_request.encoding, FileEncoding.UTF8.value)
-        self.assertEquals(filter_request.rows_chunk_size, DATA_FRAME_CHUNK_SIZE)
-        self.assertEquals(filter_request.number_of_records, 0)
-        self.assertEquals(filter_request.number_of_filtered_records, 0)
-        self.assertEquals(len(filter_request.queries), 0)
+        self.assertEqual(filter_request.compression_type, FileFormat.GZIP.value)
+        self.assertEqual(filter_request.separator, '\t')
+        self.assertEqual(filter_request.encoding, FileEncoding.UTF8.value)
+        self.assertEqual(filter_request.rows_chunk_size, DATA_FRAME_CHUNK_SIZE)
+        self.assertEqual(filter_request.number_of_records, 0)
+        self.assertEqual(filter_request.number_of_filtered_records, 0)
+        self.assertEqual(len(filter_request.queries), 0)
 
     def test_any_query_format(self):
         filter_request = FeedFilterRequest(self.test_file_path, any_query=self.test_any_query)
-        self.assertEquals(filter_request.any_query, '(' + self.test_any_query + ')')
+        self.assertEqual(filter_request.any_query, '(' + self.test_any_query + ')')
 
     def test_none_file_path(self):
         filter_request = FeedFilterRequest(None)
         filter_response = filter_request.filter()
-        self.assertEquals(filter_response.status_code, FAILURE_CODE)
+        self.assertEqual(filter_response.status_code, FAILURE_CODE)
         self.assertIsNotNone(filter_response.message)
         self.assertIsNone(filter_response.file_path)
-        self.assertEquals(len(filter_response.applied_filters), 0)
+        self.assertEqual(len(filter_response.applied_filters), 0)
 
     def test_dir_file_path(self):
         filter_request = FeedFilterRequest('../tests/test-data')
         filter_response = filter_request.filter()
-        self.assertEquals(filter_response.status_code, FAILURE_CODE)
+        self.assertEqual(filter_response.status_code, FAILURE_CODE)
         self.assertIsNotNone(filter_response.message)
         self.assertIsNone(filter_response.file_path)
-        self.assertEquals(len(filter_response.applied_filters), 0)
+        self.assertEqual(len(filter_response.applied_filters), 0)
 
     def test_no_query(self):
         filter_request = FeedFilterRequest(self.test_file_path)
         filter_response = filter_request.filter()
-        self.assertEquals(filter_response.status_code, FAILURE_CODE)
+        self.assertEqual(filter_response.status_code, FAILURE_CODE)
         self.assertIsNotNone(filter_response.message)
         self.assertIsNone(filter_response.file_path)
-        self.assertEquals(len(filter_response.applied_filters), 0)
+        self.assertEqual(len(filter_response.applied_filters), 0)
 
     def test_apply_filters(self):
         filter_request = FeedFilterRequest(self.test_file_path, price_upper_limit=10, any_query=self.test_any_query)
         filter_response = filter_request.filter(keep_db=False)
-        self.assertEquals(filter_response.status_code, SUCCESS_CODE)
+        self.assertEqual(filter_response.status_code, SUCCESS_CODE)
         self.assertIsNotNone(filter_response.message)
 
-        self.assertEquals(len(filter_request.queries), 2)
-        self.assertEquals(len(filter_response.applied_filters), 2)
+        self.assertEqual(len(filter_request.queries), 2)
+        self.assertEqual(len(filter_response.applied_filters), 2)
 
         self.assertTrue(filter_request.number_of_records > 0)
         self.assertTrue(filter_request.number_of_filtered_records > 0)
 
         self.assertIsNotNone(filter_request.filtered_file_path)
         self.assertTrue(isfile(filter_request.filtered_file_path))
-        self.assertEquals(filter_request.filtered_file_path, filter_response.file_path)
+        self.assertEqual(filter_request.filtered_file_path, filter_response.file_path)
         # clean up
         remove(filter_request.filtered_file_path)
 

tests/test_feed_request.py

@@ -27,33 +27,33 @@ def tearDownClass(cls):
     def test_none_token(self):
         feed_req_obj = Feed(FeedType.ITEM.value, FeedScope.BOOTSTRAP.value, '220', 'EBAY_US', None)
         get_response = feed_req_obj.get()
-        self.assertEquals(get_response.status_code, FAILURE_CODE)
+        self.assertEqual(get_response.status_code, FAILURE_CODE)
         self.assertIsNotNone(get_response.message)
         self.assertIsNone(get_response.file_path, 'file_path is not None in the response')
 
     def test_default_values(self):
         feed_req_obj = Feed(None, None, '220', 'EBAY_US', 'v^1 ...')
-        self.assertEquals(feed_req_obj.feed_type, FeedType.ITEM.value)
-        self.assertEquals(feed_req_obj.feed_scope, FeedScope.DAILY.value)
+        self.assertEqual(feed_req_obj.feed_type, FeedType.ITEM.value)
+        self.assertEqual(feed_req_obj.feed_scope, FeedScope.DAILY.value)
         self.assertTrue(feed_req_obj.token.startswith('Bearer'), 'Bearer is missing from token')
-        self.assertEquals(feed_req_obj.feed_date, get_formatted_date(feed_req_obj.feed_type))
-        self.assertEquals(feed_req_obj.environment, Environment.PRODUCTION.value)
-        self.assertEquals(feed_req_obj.download_location, DEFAULT_DOWNLOAD_LOCATION)
-        self.assertEquals(feed_req_obj.file_format, FileFormat.GZIP.value)
+        self.assertEqual(feed_req_obj.feed_date, get_formatted_date(feed_req_obj.feed_type))
+        self.assertEqual(feed_req_obj.environment, Environment.PRODUCTION.value)
+        self.assertEqual(feed_req_obj.download_location, DEFAULT_DOWNLOAD_LOCATION)
+        self.assertEqual(feed_req_obj.file_format, FileFormat.GZIP.value)
 
     def test_download_feed_invalid_path(self):
         feed_req_obj = Feed(FeedType.ITEM.value, FeedScope.BOOTSTRAP.value, '220', 'EBAY_US', 'Bearer v^1 ...',
                             download_location='../tests/test-data/test_json')
         get_response = feed_req_obj.get()
-        self.assertEquals(get_response.status_code, FAILURE_CODE)
+        self.assertEqual(get_response.status_code, FAILURE_CODE)
         self.assertIsNotNone(get_response.message)
         self.assertIsNotNone(get_response.file_path, 'file_path is None in the response')
 
     def test_download_feed_invalid_date(self):
         feed_req_obj = Feed(FeedType.ITEM.value, FeedScope.BOOTSTRAP.value, '220', 'EBAY_US', 'Bearer v^1 ...',
                             download_location='../tests/test-data/', feed_date='2019-02-01')
         get_response = feed_req_obj.get()
-        self.assertEquals(get_response.status_code, FAILURE_CODE)
+        self.assertEqual(get_response.status_code, FAILURE_CODE)
         self.assertIsNotNone(get_response.message)
         self.assertIsNotNone(get_response.file_path, 'file_path is None in the response')
 
@@ -66,7 +66,7 @@ def test_download_feed_daily(self):
         # store the file path for clean up
         self.file_paths.append(get_response.file_path)
         # assert the result
-        self.assertEquals(get_response.status_code, SUCCESS_CODE)
+        self.assertEqual(get_response.status_code, SUCCESS_CODE)
         self.assertIsNotNone(get_response.message)
         self.assertIsNotNone(get_response.file_path, 'file_path is None')
         self.assertTrue(isfile(get_response.file_path), 'file_path is not pointing to a file. file_path: %s'
@@ -78,7 +78,7 @@ def test_download_feed_daily(self):
                         'feed file name does not have %s in it. file_path: %s' %
                         (FeedPrefix.DAILY.value, get_response.file_path))
         file_dir, file_name = split(abspath(get_response.file_path))
-        self.assertEquals(abspath(feed_req_obj.download_location), file_dir)
+        self.assertEqual(abspath(feed_req_obj.download_location), file_dir)
 
     def test_download_feed_daily_bad_request(self):
         # ask for a future feed file that does not exist
@@ -90,7 +90,7 @@ def test_download_feed_daily_bad_request(self):
         # store the file path for clean up
         self.file_paths.append(get_response.file_path)
         # assert the result
-        self.assertEquals(get_response.status_code, FAILURE_CODE)
+        self.assertEqual(get_response.status_code, FAILURE_CODE)
         self.assertIsNotNone(get_response.message)
         self.assertIsNotNone(get_response.file_path, 'file has not been created')
         self.assertTrue(isfile(get_response.file_path), 'file_path is not pointing to a file. file_path: %s'
@@ -102,7 +102,7 @@ def test_download_feed_daily_bad_request(self):
                         'feed file name does not have %s in it. file_path: %s'
                         % (FeedPrefix.DAILY.value, get_response.file_path))
         file_dir, file_name = split(abspath(get_response.file_path))
-        self.assertEquals(abspath(feed_req_obj.download_location), file_dir)
+        self.assertEqual(abspath(feed_req_obj.download_location), file_dir)
 
     def test_download_feed_daily_multiple_calls(self):
         feed_req_obj = Feed(FeedType.ITEM.value, FeedScope.BOOTSTRAP.value, self.test_category_2,
@@ -111,7 +111,7 @@ def test_download_feed_daily_multiple_calls(self):
         # store the file path for clean up
         self.file_paths.append(get_response.file_path)
         # assert the result
-        self.assertEquals(get_response.status_code, SUCCESS_CODE)
+        self.assertEqual(get_response.status_code, SUCCESS_CODE)
         self.assertIsNotNone(get_response.message)
         self.assertIsNotNone(get_response.file_path, 'file has not been created')
         self.assertTrue(isfile(get_response.file_path), 'file_path is not pointing to a file. file_path: %s'
@@ -123,7 +123,7 @@ def test_download_feed_daily_multiple_calls(self):
                         'feed file name does not have %s in it. file_path: %s'
                         % (FeedPrefix.BOOTSTRAP.value, get_response.file_path))
         file_dir, file_name = split(abspath(get_response.file_path))
-        self.assertEquals(abspath(feed_req_obj.download_location), file_dir)
+        self.assertEqual(abspath(feed_req_obj.download_location), file_dir)
 
 
 if __name__ == '__main__':

tests/test_file_utils.py

@@ -73,15 +73,15 @@ def test_create_and_replace_binary_file_not_exists(self):
 
     def test_find_next_range_none_range_header(self):
         next_range = file_utils.find_next_range(None, 100)
-        self.assertEquals(next_range, 'bytes=0-100')
+        self.assertEqual(next_range, 'bytes=0-100')
 
     def test_find_next_range_none_chunk(self):
         next_range = file_utils.find_next_range('0-1000/718182376', None)
-        self.assertEquals(next_range, 'bytes=1001-%s' % (SANDBOX_CHUNK_SIZE + 1001))
+        self.assertEqual(next_range, 'bytes=1001-%s' % (SANDBOX_CHUNK_SIZE + 1001))
 
     def test_find_next_range(self):
         next_range = file_utils.find_next_range('1001-2001/718182376', 1000)
-        self.assertEquals(next_range, 'bytes=2002-3002')
+        self.assertEqual(next_range, 'bytes=2002-3002')
 
     def test_get_file_extension_none(self):
         ext = file_utils.get_extension(None)
@@ -94,20 +94,20 @@ def test_get_file_extension(self):
     def test_get_file_name_dir(self):
         test_dir = os.path.expanduser('../feed-sdk/tests')
         returned_dir_name = file_utils.get_file_name(test_dir)
-        self.assertEquals(returned_dir_name, 'tests')
+        self.assertEqual(returned_dir_name, 'tests')
 
     def test_get_file_name(self):
         test_dir = os.path.expanduser('../feed-sdk/tests/test_json')
         returned_file_name = file_utils.get_file_name(test_dir)
-        self.assertEquals(returned_file_name, 'test_json')
+        self.assertEqual(returned_file_name, 'test_json')
 
     def test_get_file_name_none(self):
         with self.assertRaises(InputDataError):
             file_utils.get_file_name(None)
 
     def test_get_file_name_name(self):
         test_file_name = 'abc.txt'
-        self.assertEquals(file_utils.get_file_name(test_file_name), test_file_name)
+        self.assertEqual(file_utils.get_file_name(test_file_name), test_file_name)
 
     def test_read_json(self):
         json_obj = file_utils.read_json('../tests/test-data/test_json')

tests/test_filter_utils.py

@@ -76,7 +76,7 @@ def test_convert_to_bool_false_false(self):
 
     def convert_to_float_max_int_invalid(self):
         converted_float = filter_utils.convert_to_float_max_int('invalid')
-        self.assertEqual(sys.maxint, converted_float)
+        self.assertEqual(sys.maxsize, converted_float)
 
     def convert_to_float_max_int(self):
         converted_float = filter_utils.convert_to_float_max_int('1.2')

utils/file_utils.py

@@ -70,9 +70,9 @@ def find_next_range(content_range_header, chunk_size=const.SANDBOX_CHUNK_SIZE):
         try:
             # ex. content-range : 0-1000/7181823761
             range_components = content_range_header.split('/')
-            total_size = long(range_components[1])
+            total_size = int(range_components[1])
             bounds = range_components[0].split('-')
-            upper_bound = long(bounds[1]) + 1
+            upper_bound = int(bounds[1]) + 1
             if upper_bound > total_size:
                 return ''
             return const.RANGE_PREFIX + str(upper_bound) + '-' + str(upper_bound + chunk)

utils/filter_utils.py

@@ -32,7 +32,7 @@ def convert_to_float_max_int(data):
     try:
         return pd.np.float(data)
     except (ValueError, TypeError, AttributeError):
-        return pd.np.float(sys.maxint)
+        return pd.np.float(sys.maxsize)
 
 
 def convert_to_float_zero(data):