Autopep8 linter used

Author: fatimarahman

src/nypl_py_utils/classes/avro_client.py

@@ -9,17 +9,18 @@
 from nypl_py_utils.functions.log_helper import create_log
 from requests.exceptions import JSONDecodeError, RequestException
 
+
 class AvroClient:
     """
     Base class for Avro schema interaction. Takes as input the
     Platform API endpoint from which to fetch the schema in JSON format.
     """
-    
+
     def __init__(self, platform_schema_url):
         self.logger = create_log('avro_encoder')
         self.schema = avro.schema.parse(
             self.get_json_schema(platform_schema_url))
-    
+
     def get_json_schema(self, platform_schema_url):
         """
         Fetches a JSON response from the input Platform API endpoint and
@@ -48,7 +49,7 @@ def get_json_schema(self, platform_schema_url):
             raise AvroClientError(
                 'Retrieved schema is malformed: {errorType} {errorMessage}'
                 .format(errorType=type(e), errorMessage=e)) from None
-    
+
 
 class AvroEncoder(AvroClient):
     """
@@ -64,7 +65,7 @@ def encode_record(self, record):
         """
         self.logger.debug(
             'Encoding record using {schema} schema'.format(
-               schema=self.schema.name))
+                schema=self.schema.name))
         datum_writer = DatumWriter(self.schema)
         with BytesIO() as output_stream:
             encoder = BinaryEncoder(output_stream)
@@ -110,30 +111,33 @@ class AvroDecoder(AvroClient):
 
     def decode_record(self, record, encoding="binary"):
         """
-        Decodes a single record represented either as a byte or 
+        Decodes a single record represented either as a byte or
         base64 string, using the given Avro schema.
 
         Returns a dictionary where each key is a field in the schema.
         """
-        self.logger.info('Decoding {rec} of type {type} using {schema} schema'.format(
-            rec=record, type=encoding, schema=self.schema.name))
-        
+        self.logger.info('Decoding {rec} of type {type} using {schema} schema'
+                         .format(rec=record, type=encoding,
+                                 schema=self.schema.name))
+
         if encoding == "base64":
             return self._decode_base64(record)
         elif encoding == "binary":
             return self._decode_binary(record)
         else:
-            self.logger.error('Failed to decode record due to encoding type: {}'.format(encoding))
+            self.logger.error(
+                'Failed to decode record due to encoding type: {}'
+                .format(encoding))
             raise AvroClientError(
                 'Invalid encoding type: {}'.format(encoding))
-        
+
     def _decode_base64(self, record):
         decoded_data = base64.b64decode(record).decode("utf-8")
         try:
             return json.loads(decoded_data)
         except Exception as e:
             if isinstance(decoded_data, bytes):
-                self._decode_binary(decoded_data) 
+                self._decode_binary(decoded_data)
             else:
                 self.logger.error('Failed to decode record: {}'.format(e))
                 raise AvroClientError(
@@ -153,4 +157,4 @@ def _decode_binary(self, record):
 
 class AvroClientError(Exception):
     def __init__(self, message=None):
-        self.message = message
+        self.message = message

tests/test_avro_client.py

@@ -1,7 +1,8 @@
 import json
 import pytest
 
-from nypl_py_utils.classes.avro_client import AvroDecoder, AvroEncoder, AvroClientError
+from nypl_py_utils.classes.avro_client import (
+    AvroDecoder, AvroEncoder, AvroClientError)
 from requests.exceptions import ConnectTimeout
 
 _TEST_SCHEMA = {'data': {'schema': json.dumps({
@@ -19,6 +20,7 @@
     ]
 })}}
 
+
 class TestAvroClient:
 
     @pytest.fixture
@@ -33,9 +35,12 @@ def test_avro_decoder_instance(self, requests_mock):
             'https://test_schema_url', text=json.dumps(_TEST_SCHEMA))
         return AvroDecoder('https://test_schema_url')
 
-    def test_get_json_schema(self, test_avro_encoder_instance, test_avro_decoder_instance):
-        assert test_avro_encoder_instance.schema == _TEST_SCHEMA['data']['schema']
-        assert test_avro_decoder_instance.schema == _TEST_SCHEMA['data']['schema']
+    def test_get_json_schema(self, test_avro_encoder_instance,
+                             test_avro_decoder_instance):
+        assert test_avro_encoder_instance.schema == _TEST_SCHEMA['data'][
+            'schema']
+        assert test_avro_decoder_instance.schema == _TEST_SCHEMA['data'][
+            'schema']
 
     def test_request_error(self, requests_mock):
         requests_mock.get('https://test_schema_url', exc=ConnectTimeout)
@@ -54,18 +59,21 @@ def test_missing_key_error(self, requests_mock):
         with pytest.raises(AvroClientError):
             AvroEncoder('https://test_schema_url')
 
-    def test_encode_record(self, test_avro_encoder_instance, test_avro_decoder_instance):
+    def test_encode_record(self, test_avro_encoder_instance,
+                           test_avro_decoder_instance):
         TEST_RECORD = {'patron_id': 123, 'library_branch': 'aa'}
         encoded_record = test_avro_encoder_instance.encode_record(TEST_RECORD)
         assert type(encoded_record) is bytes
-        assert test_avro_decoder_instance.decode_record(encoded_record) == TEST_RECORD
+        assert test_avro_decoder_instance.decode_record(
+            encoded_record) == TEST_RECORD
 
     def test_encode_record_error(self, test_avro_encoder_instance):
         TEST_RECORD = {'patron_id': 123, 'bad_field': 'bad'}
         with pytest.raises(AvroClientError):
             test_avro_encoder_instance.encode_record(TEST_RECORD)
 
-    def test_encode_batch(self, test_avro_encoder_instance, test_avro_decoder_instance):
+    def test_encode_batch(self, test_avro_encoder_instance,
+                          test_avro_decoder_instance):
         TEST_BATCH = [
             {'patron_id': 123, 'library_branch': 'aa'},
             {'patron_id': 456, 'library_branch': None},
@@ -89,10 +97,11 @@ def test_decode_record_binary(self, test_avro_decoder_instance):
         TEST_ENCODED_RECORD = b'\xf6\x01\x02\x04aa'
         assert test_avro_decoder_instance.decode_record(
             TEST_ENCODED_RECORD) == TEST_DECODED_RECORD
-    
+
     def test_decode_record_b64(self, test_avro_decoder_instance):
         TEST_DECODED_RECORD = {"patron_id'": 123, "library_branch": "aa"}
-        TEST_ENCODED_RECORD = "eyJwYXRyb25faWQnIjogMTIzLCAibGlicmFyeV9icmFuY2giOiAiYWEifQ=="
+        TEST_ENCODED_RECORD = (
+            "eyJwYXRyb25faWQnIjogMTIzLCAibGlicmFyeV9icmFuY2giOiAiYWEifQ==")
         assert test_avro_decoder_instance.decode_record(
             TEST_ENCODED_RECORD, "base64") == TEST_DECODED_RECORD