Error workflow was refactored

Author: voronind

vk/api.py

@@ -5,7 +5,7 @@
 
 from vk.logs import LOGGING_CONFIG
 from vk.utils import stringify_values, json_iter_parse, LoggingSession
-from vk.exceptions import VkAuthError, VkAPIMethodError, CAPTCHA_IS_NEEDED, AUTHORIZATION_FAILED
+from vk.exceptions import VkAuthError, VkAPIError, CAPTCHA_IS_NEEDED, AUTHORIZATION_FAILED
 from vk.mixins import AuthMixin, InteractiveMixin
 
 
@@ -60,55 +60,67 @@ def get_access_token(self):
         logger.debug('API.get_access_token()')
         return self._access_token
 
-    def make_request(self, method_request, **method_kwargs):
+    def make_request(self, method_request, captcha_response=None):
 
         logger.debug('Prepare API Method request')
 
         response = self.send_api_request(method_request)
+        # todo Replace with something less exceptional
         response.raise_for_status()
 
         # there are may be 2 dicts in one JSON
-        # for example: {'error': ...}{'response': ...}
-        errors = []
-        error_codes = []
-        for data in json_iter_parse(response.text):
-            if 'error' in data:
-                error_data = data['error']
-                if error_data['error_code'] == CAPTCHA_IS_NEEDED:
-                    return self.on_captcha_is_needed(error_data, method_request)
-
-                error_codes.append(error_data['error_code'])
-                errors.append(error_data)
-
-            if 'response' in data:
-                for error in errors:
-                    logger.warning(str(error))
-
-                return data['response']
-            
-        if AUTHORIZATION_FAILED in error_codes:  # invalid access token
-            logger.info('Authorization failed. Access token will be dropped')
-            self.access_token = None
-            return self.make_request(method_request)
-        else:
-            raise VkAPIMethodError(errors[0])
-
-    def send_api_request(self, request):
+        # for example: "{'error': ...}{'response': ...}"
+        for response_or_error in json_iter_parse(response.text):
+            if 'response' in response_or_error:
+                # todo Can we have error and response simultaneously
+                # for error in errors:
+                #     logger.warning(str(error))
+
+                return response_or_error['response']
+
+            elif 'error' in response_or_error:
+                error_data = response_or_error['error']
+                error = VkAPIError(error_data)
+
+                if error.is_captcha_needed():
+                    captcha_key = self.get_captcha_key(error.captcha_img)
+                    if not captcha_key:
+                        raise error
+
+                    captcha_response = {
+                        'sid': error.captcha_sid,
+                        'key': captcha_key,
+                    }
+                    return self.make_request(method_request, captcha_response=captcha_response)
+
+                elif error.is_access_token_incorrect():
+                    logger.info('Authorization failed. Access token will be dropped')
+                    self.access_token = None
+                    return self.make_request(method_request)
+
+                else:
+                    raise error
+
+    def send_api_request(self, request, captcha_response=None):
         url = self.API_URL + request._method_name
         method_args = request._api._method_default_args.copy()
         method_args.update(stringify_values(request._method_args))
-        if self.access_token:
-            method_args['access_token'] = self.access_token
+        access_token = self.access_token
+        if access_token:
+            method_args['access_token'] = access_token
+        if captcha_response:
+            method_args['captcha_sid'] = captcha_response['sid']
+            method_args['captcha_key'] = captcha_response['key']
         timeout = request._api._timeout
         response = self.requests_session.post(url, method_args, timeout=timeout)
         return response
 
-    def on_captcha_is_needed(self, error_data, method_request):
+    def get_captcha_key(self, captcha_image_url):
         """
         Default behavior on CAPTCHA is to raise exception
         Reload this in child
         """
-        raise VkAPIMethodError(error_data)
+        return None
 
     def auth_code_is_needed(self, content, session):
         """

vk/exceptions.py

@@ -16,16 +16,39 @@ class VkAuthError(VkException):
     pass
 
 
-class VkAPIMethodError(VkException):
+class VkAPIError(VkException):
     __slots__ = ['error', 'code', 'message', 'request_params', 'redirect_uri']
 
-    def __init__(self, error):
-        super(VkAPIMethodError, self).__init__()
-        self.error = error
-        self.code = error.get('error_code')
-        self.message = error.get('error_msg')
-        self.request_params = error.get('request_params')
-        self.redirect_uri = error.get('redirect_uri')
+    CAPTCHA_NEEDED = 14
+    ACCESS_DENIED = 15
+
+    def __init__(self, error_data):
+        super(VkAPIError, self).__init__()
+        self.error_data = error_data
+        self.code = error_data.get('error_code')
+        self.message = error_data.get('error_msg')
+        self.request_params = self.get_pretty_request_params(error_data)
+        self.redirect_uri = error_data.get('redirect_uri')
+
+    @staticmethod
+    def get_pretty_request_params(error_data):
+        request_params = error_data.get('request_params', ())
+        request_params = {param['key']: param['value'] for param in request_params}
+        return request_params
+
+    def is_access_token_incorrect(self):
+        return self.code == self.ACCESS_DENIED and 'access_token' in self.message
+
+    def is_captcha_needed(self):
+        return self.code == self.CAPTCHA_NEEDED
+
+    @property
+    def captcha_sid(self):
+        return self.error_data.get('captcha_sid')
+
+    @property
+    def captcha_img(self):
+        return self.error_data.get('captcha_img')
 
     def __str__(self):
         error_message = '{self.code}. {self.message}. request_params = {self.request_params}'.format(self=self)

vk/mixins.py

@@ -167,11 +167,12 @@ def auth_captcha_is_needed(self, response, login_form_data):
         if not captcha_form_action:
             raise VkAuthError('Cannot find form url')
 
+        # todo Are we sure that `response_url_dict` doesn't contain CAPTCHA image url?
         captcha_url = '%s?s=%s&sid=%s' % (self.CAPTCHA_URI, response_url_dict['s'], response_url_dict['sid'])
         # logger.debug('Captcha url %s', captcha_url)
 
         login_form_data['captcha_sid'] = response_url_dict['sid']
-        login_form_data['captcha_key'] = self.on_captcha_is_needed(captcha_url)
+        login_form_data['captcha_key'] = self.get_captcha_key(captcha_url)
 
         response = self.auth_session.post(captcha_form_action, login_form_data)
 
@@ -204,12 +205,12 @@ def get_access_token(self):
             access_token = raw_input('VK API access token: ')
         return access_token
 
-    def on_captcha_is_needed(self, url):
+    def get_captcha_key(self, captcha_image_url):
         """
         Read CAPTCHA key from shell
         """
-        print('Open captcha url:', url)
-        captcha_key = raw_input('Enter captcha key: ')
+        print('Open CAPTCHA image url: ', captcha_image_url)
+        captcha_key = raw_input('Enter CAPTCHA key: ')
         return captcha_key
 
     def get_auth_check_code(self):