Restframework-simplejwt rewrite authentication mechanism

from rest_framework_simplejwt.authentication import JWTAuthentication
class MyJWTAuthentication(JWTAuthentication):
    '''  modify JWT Certification , Return to custom User Table object  '''

    def authenticate(self, request):
        header = self.get_header(request)
        if header is None:
            return None
        #  obtain  access_token
        raw_token = self.get_raw_token(header)
        user = None
        token = None
        if raw_token is None:
            return None
        #  Define the current  access_token White list 
        wraw_token = str(raw_token, 'utf-8') + config.JWT_WHITE_LIST_TAG
        #  When there is a   When in the white list 
        if cache.has_key(wraw_token):
            #  In the cache   obtain   stay   middleware   Set up   User object 
            user = cache.get(wraw_token)["user_obj"]
            token = raw_token
        else:
            try:
                #  Yes, I received access_token  authentication 
                token = self.get_validated_token(raw_token)
                #  According to the certified  access_token  Get user object 
                user = self.get_user(token)
            except Exception as e:
                #  Ordinary  access_token Exceptions are not handled   How to throw a response is to throw a response 
                #  primary access_token abnormal , When refreshing the interface for , obtain  request.data  Of  refresh_token
                if request.data.get("refresh_token"):
                    refresh_token = request.data.get("refresh_token")
                    #  Get current  refresh_token  Of   Valid time 
                    refresh_time_remaining = output_time_remaining(refresh_token)
                    # refresh_token  Within the validity period 
                    if refresh_time_remaining > 0:
                        #  And not on the blacklist 
                        if not cache.has_key(refresh_token):
                            decoded_data = jwt_decode(str(refresh_token), config.JWT_SECRET_KEY, verify=False,
                                                      algorithms="HS256")
                            #  obtain   User object 
                            user = Person_info.objects.get(**{
    'person_id': decoded_data["user_id"]})
        return user, token

    def get_user(self, validated_token):
        try:
            #  Whether it has been entered into the blacklist 
            if cache.has_key(str(validated_token) + config.JWT_BLACK_LIST_TAG):
                raise AuthenticationFailed(_('Token contained no recognizable user identification'))
            user_id = validated_token['user_id']
        except KeyError:
            raise InvalidToken(_('Token contained no recognizable user identification'))
        try:
            user = Person_info.objects.get(**{
    'person_id': user_id})
        except Person_info.DoesNotExist:
            raise AuthenticationFailed(_('User not found'), code='user_not_found')
        return user