Apply pep8 style rules

I used `pycodestyle` in the files I modified.

Author: Rafa de la Torre

carto/auth.py

@@ -70,13 +70,18 @@ class _ClientIdentifier:
     CARTO_VERSION = pkg_resources.require('carto')[0].version
 
     def get_user_agent(self, name='carto-python-sdk'):
-        return "{name}/{version}".format(name=name, version=self.CARTO_VERSION)
+        return "{name}/{version}".format(
+            name=name,
+            version=self.CARTO_VERSION)
 
     def get_client_identifier(self, prefix='cps'):
-        return "{prefix}-{version}".format(prefix=prefix, version=self.CARTO_VERSION)
+        return "{prefix}-{version}".format(
+            prefix=prefix,
+            version=self.CARTO_VERSION)
 
 
-class APIKeyAuthClient(_UsernameGetter, _BaseUrlChecker, _ClientIdentifier, BaseAuthClient):
+class APIKeyAuthClient(_UsernameGetter, _BaseUrlChecker, _ClientIdentifier,
+                       BaseAuthClient):
     """
     This class provides you with authenticated access to CARTO's APIs using
     your API key.

carto/sql.py

@@ -25,7 +25,7 @@
 # The chunk size should be a multiple of the filesystem/buffers block
 # size. Big values can cause resource starvation and OTOH small values
 # incur in some protocol overhead. Typical linux block size is 4 KB.
-DEFAULT_CHUNK_SIZE = 8 * 1024 # 8 KB provides good results in practice
+DEFAULT_CHUNK_SIZE = 8 * 1024  # 8 KB provides good results in practice
 
 # The compression level of gzip/zlib ranges from 1 (fastest, least
 # compression) to 9 (slowest, most compression).  In our performance
@@ -276,15 +276,17 @@ def _read_in_chunks(self, file_object, chunk_size=DEFAULT_CHUNK_SIZE):
 
     def _compress_chunks(self, chunk_generator, compression_level):
         zlib_mode = 16 + zlib.MAX_WBITS
-        compressor = zlib.compressobj(compression_level, zlib.DEFLATED, zlib_mode)
+        compressor = zlib.compressobj(compression_level,
+                                      zlib.DEFLATED,
+                                      zlib_mode)
         for chunk in chunk_generator:
             compressed_chunk = compressor.compress(chunk)
             if len(compressed_chunk) > 0:
                 yield compressed_chunk
         yield compressor.flush()
 
-
-    def copyfrom(self, query, iterable_data, compress=True, compression_level=DEFAULT_COMPRESSION_LEVEL):
+    def copyfrom(self, query, iterable_data, compress=True,
+                 compression_level=DEFAULT_COMPRESSION_LEVEL):
         """
         Gets data from an iterable object into a table
 
@@ -306,11 +308,12 @@ def copyfrom(self, query, iterable_data, compress=True, compression_level=DEFAUL
             'Content-Type': 'application/octet-stream',
             'Transfer-Encoding': 'chunked'
         }
-        params={'api_key': self.api_key, 'q': query}
+        params = {'api_key': self.api_key, 'q': query}
 
         if compress:
             headers['Content-Encoding'] = 'gzip'
-            _iterable_data = self._compress_chunks(iterable_data, compression_level)
+            _iterable_data = self._compress_chunks(iterable_data,
+                                                   compression_level)
         else:
             _iterable_data = iterable_data
 
@@ -327,7 +330,8 @@ def copyfrom(self, query, iterable_data, compress=True, compression_level=DEFAUL
 
         return response_json
 
-    def copyfrom_file_object(self, query, file_object, compress=True, compression_level=DEFAULT_COMPRESSION_LEVEL):
+    def copyfrom_file_object(self, query, file_object, compress=True,
+                             compression_level=DEFAULT_COMPRESSION_LEVEL):
         """
         Gets data from a readable file object into a table
 
@@ -345,9 +349,11 @@ def copyfrom_file_object(self, query, file_object, compress=True, compression_le
         :raise CartoException:
         """
         chunk_generator = self._read_in_chunks(file_object)
-        return self.copyfrom(query, chunk_generator, compress, compression_level)
+        return self.copyfrom(query, chunk_generator, compress,
+                             compression_level)
 
-    def copyfrom_file_path(self, query, path, compress=True, compression_level=DEFAULT_COMPRESSION_LEVEL):
+    def copyfrom_file_path(self, query, path, compress=True,
+                           compression_level=DEFAULT_COMPRESSION_LEVEL):
         """
         Gets data from a readable file into a table
 
@@ -364,14 +370,15 @@ def copyfrom_file_path(self, query, path, compress=True, compression_level=DEFAU
         :raise CartoException:
         """
         with open(path, 'rb') as f:
-            result = self.copyfrom_file_object(query, f, compress, compression_level)
+            result = self.copyfrom_file_object(query, f, compress,
+                                               compression_level)
         return result
 
     def copyto(self, query):
         """
         Gets data from a table into a Response object that can be iterated
 
-        :param query: The "COPY { table_name [(column_name[, ...])] | ( query ) }
+        :param query: The "COPY { table_name [(column_name[, ...])] | (query) }
                            TO STDOUT [WITH(option[,...])]" query to execute
         :type query: str
 
@@ -381,7 +388,7 @@ def copyto(self, query):
         :raise CartoException:
         """
         url = self.api_url + '/copyto'
-        params={'api_key': self.api_key, 'q': query}
+        params = {'api_key': self.api_key, 'q': query}
 
         try:
             response = self.client.send(url,
@@ -393,7 +400,8 @@ def copyto(self, query):
             if 400 <= response.status_code < 500:
                 # Client error, provide better reason
                 reason = response.json()['error'][0]
-                error_msg = u'%s Client Error: %s' % (response.status_code, reason)
+                error_msg = u'%s Client Error: %s' % (response.status_code,
+                                                      reason)
                 raise CartoException(error_msg)
             else:
                 raise CartoException(e)
@@ -406,7 +414,7 @@ def copyto_file_object(self, query, file_object):
         """
         Gets data from a table into a writable file object
 
-        :param query: The "COPY { table_name [(column_name[, ...])] | ( query ) }
+        :param query: The "COPY { table_name [(column_name[, ...])] | (query) }
                            TO STDOUT [WITH(option[,...])]" query to execute
         :type query: str
 
@@ -424,7 +432,7 @@ def copyto_file_path(self, query, path, append=False):
         """
         Gets data from a table into a writable file
 
-        :param query: The "COPY { table_name [(column_name[, ...])] | ( query ) }
+        :param query: The "COPY { table_name [(column_name[, ...])] | (query) }
                            TO STDOUT [WITH(option[,...])]" query to execute
         :type query: str
 

examples/copy_example.py

@@ -20,13 +20,13 @@
 parser = argparse.ArgumentParser(description='External database connector')
 
 parser.add_argument('--base_url', type=str, dest='CARTO_BASE_URL',
-                    default=os.environ['CARTO_API_URL'] if 'CARTO_API_URL' in os.environ else '',
+                    default=os.environ.get('CARTO_API_URL', ''),
                     help='Set the base URL. For example:' +
                     ' https://username.carto.com/ ' +
                     '(defaults to env variable CARTO_API_URL)')
 
 parser.add_argument('--api_key', dest='CARTO_API_KEY',
-                    default=os.environ['CARTO_API_KEY'] if 'CARTO_API_KEY' in os.environ else '',
+                    default=os.environ.get('CARTO_API_KEY', ''),
                     help='Api key of the account' +
                     ' (defaults to env variable CARTO_API_KEY)')
 
@@ -38,12 +38,11 @@
     auth_client = APIKeyAuthClient(
         args.CARTO_BASE_URL, args.CARTO_API_KEY)
 else:
-    logger.error('You need to provide valid credentials, run with -h parameter for details')
+    logger.error('You need to provide valid credentials, run with '
+                 '-h parameter for details')
     import sys
     sys.exit(1)
 
-
-
 # Create and cartodbfy a table
 sqlClient = SQLClient(auth_client)
 sqlClient.send("""
@@ -55,13 +54,12 @@
     """)
 sqlClient.send("SELECT CDB_CartodbfyTable(current_schema, 'copy_example')")
 
-
-
 copyClient = CopySQLClient(auth_client)
 
 # COPY FROM example
 logger.info("COPY'ing FROM file...")
-query = 'COPY copy_example (the_geom, name, age) FROM stdin WITH (FORMAT csv, HEADER true)'
+query = ('COPY copy_example (the_geom, name, age) '
+         'FROM stdin WITH (FORMAT csv, HEADER true)')
 result = copyClient.copyfrom_file_path(query, 'files/copy_from.csv')
 logger.info('result = %s' % result)
 
@@ -71,7 +69,5 @@
 copyClient.copyto_file_path(query, output_file)
 logger.info('Table copied to %s' % output_file)
 
-
-
 # Truncate the table to make this example repeatable
 sqlClient.send('TRUNCATE TABLE copy_example RESTART IDENTITY')

tests/test_auth.py

@@ -39,6 +39,7 @@ def test_on_prem_url():
     assert user2 == 'user2'
     assert user3 == 'user3'
 
+
 USER1_BASE_URL = 'https://user1.carto.com/'
 USER1_USERNAME = 'user1'
 
@@ -107,19 +108,23 @@ def test_client_identifier():
     client_id_pattern = re.compile('test/\d+\.\d+\.\d+')
     assert client_id_pattern.match(ci.get_user_agent('test'))
 
+
 def test_user_agent():
     expected_user_agent = _ClientIdentifier().get_user_agent()
     adapter = requests_mock.Adapter()
     session = requests.Session()
 
-    # Using file:// cause urllib's urljoin (used in pyrestcli) does not support a mock:// schema
+    # Using file:// cause urllib's urljoin (used in pyrestcli)
+    # does not support a mock:// schema
     session.mount('file', adapter)
     adapter.register_uri('POST', 'file://test.carto.com/headers',
                          request_headers={'User-Agent': expected_user_agent})
 
-    client = APIKeyAuthClient('file://test.carto.com', 'some_api_key', None, session)
+    client = APIKeyAuthClient('file://test.carto.com', 'some_api_key',
+                              None, session)
     client.send('headers', 'post')
 
+
 def test_client_id_in_requests():
     expected_client_id = _ClientIdentifier().get_client_identifier()
     client = APIKeyAuthClient('https://test.carto.com', 'some_api_key')

tests/test_sql_copy.py

@@ -28,13 +28,18 @@
 BATCH_TERMINAL_STATES = ['done', 'failed', 'cancelled', 'unknown']
 
 # Please note the newline characters to delimit rows
-TABLE_CONTENTS=[
+TABLE_CONTENTS = [
     b'the_geom,name,age\n',
     b'SRID=4326;POINT(-126 54),North West,89\n',
     b'SRID=4326;POINT(-96 34),South East,99\n',
     b'SRID=4326;POINT(-6 -25),Souther Easter,124\n'
 ]
 
+COPY_FROM_QUERY = (
+    'COPY carto_python_sdk_copy_test (the_geom, name, age) FROM stdin WITH ',
+    '(FORMAT csv, HEADER true)'
+)
+
 
 @pytest.fixture(scope="module")
 def test_table(api_key_auth_client_usr):
@@ -45,26 +50,26 @@ def test_table(api_key_auth_client_usr):
         job = batch_client.read(job['job_id'])
     assert job['status'] == 'done'
 
+
 @pytest.fixture
 def copy_client(api_key_auth_client_usr):
     return CopySQLClient(api_key_auth_client_usr)
 
 
 def test_copyfrom(copy_client, test_table):
-    query = 'COPY carto_python_sdk_copy_test (the_geom, name, age) FROM stdin WITH (FORMAT csv, HEADER true)'
     data = iter(TABLE_CONTENTS)
-    result = copy_client.copyfrom(query, data)
+    result = copy_client.copyfrom(COPY_FROM_QUERY, data)
 
     assert result['total_rows'] == 3
 
 
 def test_copyfrom_no_compression(copy_client):
-    query = 'COPY carto_python_sdk_copy_test (the_geom, name, age) FROM stdin WITH (FORMAT csv, HEADER true)'
     data = iter(TABLE_CONTENTS)
-    result = copy_client.copyfrom(query, data, compress=False)
+    result = copy_client.copyfrom(COPY_FROM_QUERY, data, compress=False)
 
     assert result['total_rows'] == 3
 
+
 def test_copyfrom_wrong_query(copy_client):
     query = 'COPY any_wrong_table (any_wrong_column) FROM stdin'
     data = iter(TABLE_CONTENTS)
@@ -75,6 +80,7 @@ def test_copyfrom_wrong_query(copy_client):
 
 IN_MEMORY_CSV_NROWS = 1000
 
+
 @pytest.fixture()
 def in_memory_csv(request):
     file_obj = InMemIO()
@@ -86,36 +92,44 @@ def fin():
 
     for i in range(IN_MEMORY_CSV_NROWS):
         row = u'SRID=4326;POINT({lon} {lat}),{name},{age}\n'.format(
-            lon = random.uniform(-170.0, 170.0),
-            lat = random.uniform(-80.0, 80.0),
-            name = random.choice(['fulano', 'mengano', 'zutano', 'perengano']),
-            age = random.randint(18,99)
+            lon=random.uniform(-170.0, 170.0),
+            lat=random.uniform(-80.0, 80.0),
+            name=random.choice(['fulano', 'mengano', 'zutano', 'perengano']),
+            age=random.randint(18, 99)
         )
         file_obj.write(bytearray(row, 'utf-8'))
     file_obj.seek(0)
     return file_obj
 
+
 def test_copyfrom_file_object(copy_client, in_memory_csv):
-    query = 'COPY carto_python_sdk_copy_test (the_geom, name, age) FROM stdin WITH (FORMAT csv, HEADER false)'
+    query = (
+        'COPY carto_python_sdk_copy_test (the_geom, name, age) '
+        'FROM stdin WITH (FORMAT csv, HEADER false)'
+    )
     result = copy_client.copyfrom_file_object(query, in_memory_csv)
 
     assert result['total_rows'] == IN_MEMORY_CSV_NROWS
 
+
 def test_copyfrom_file_path(copy_client):
-    query = 'COPY carto_python_sdk_copy_test (the_geom, name, age) FROM stdin WITH (FORMAT csv, HEADER true)'
-    result = copy_client.copyfrom_file_path(query, 'tests/copy_from.csv')
+    result = copy_client.copyfrom_file_path(COPY_FROM_QUERY,
+                                            'tests/copy_from.csv')
 
     assert result['total_rows'] == 3
 
 
-
-
 @pytest.fixture()
 def copyto_sample_query():
-    arbitrary_subquery = 'SELECT i cartodb_id, ST_AsEWKT(ST_SetSRID(ST_MakePoint(i, i),4326)) the_geom FROM generate_series(1,10) i'
+    arbitrary_subquery = (
+        'SELECT i cartodb_id, ',
+        'ST_AsEWKT(ST_SetSRID(ST_MakePoint(i, i),4326)) the_geom FROM ',
+        'generate_series(1,10) i'
+    )
     query = 'COPY ({subquery}) TO STDOUT'.format(subquery=arbitrary_subquery)
     return query
 
+
 @pytest.fixture()
 def copyto_expected_result():
     return bytearray(u'\n'.join([
@@ -141,15 +155,20 @@ def test_copyto(copy_client, copyto_sample_query, copyto_expected_result):
 
     assert result == copyto_expected_result
 
-def test_copyto_file_object(copy_client, copyto_sample_query, copyto_expected_result):
+
+def test_copyto_file_object(copy_client, copyto_sample_query,
+                            copyto_expected_result):
     in_memory_target_fileobj = InMemIO()
 
-    copy_client.copyto_file_object(copyto_sample_query, in_memory_target_fileobj)
+    copy_client.copyto_file_object(copyto_sample_query,
+                                   in_memory_target_fileobj)
     assert in_memory_target_fileobj.getvalue() == copyto_expected_result
 
     in_memory_target_fileobj.close()
 
-def test_copyto_file_path(copy_client, copyto_sample_query, copyto_expected_result, tmpdir):
+
+def test_copyto_file_path(copy_client, copyto_sample_query,
+                          copyto_expected_result, tmpdir):
     target_path = tmpdir.join('carto-python-sdk-copy-test.dump')
     copy_client.copyto_file_path(copyto_sample_query, target_path.strpath)
     assert target_path.read() == copyto_expected_result.decode('utf-8')