Source code for sparcl.exceptions

import traceback


def genSparclException(response, verbose=False):
    """Given status from Server response.json(), which is a dict, generate
    a native SPARCL exception suitable for Science programs."""

    content = response.content
    if verbose:
        print(f'Exception: response content={content}')
    status = response.json()

    # As of Python 3.10.0.alpha6, python "match" statement could be used
    # instead of if-elif-else.
    # https://docs.python.org/3.10/whatsnew/3.10.html#pep-634-structural-pattern-matching
    if status.get('errorCode') == 'BADPATH':
        return BadPath(status.get('errorMessage'))
    elif status.get('errorCode') == 'BADQUERY':
        return BadQuery(status.get('errorMessage'))
    elif status.get('errorCode') == 'UNKFIELD':
        return UnknownField(status.get('errorMessage'))
    elif status.get('errorCode') == 'BADCONST':
        return BadSearchConstraint(status.get('errorMessage'))
    else:
        return UnknownServerError(
            f"{status.get('errorMessage')} "
            f"[{status.get('errorCode')}]")


class BaseSparclException(Exception):
    """Base Class for all SPARCL exceptions. """
    error_code = 'UNKNOWN'
    error_message = '<NA>'
    traceback = None

    def get_subclass_name(self):
        return self.__class__.__name__

    def __init__(self, error_message, error_code=None):
        Exception.__init__(self)
        self.error_message = error_message
        if error_code:
            self.error_code = error_code
        self.traceback = traceback.format_exc()

    def __str__(self):
        return f'[{self.error_code}] {self.error_message}'

    def to_dict(self):
        """Convert a SPARCL exception to a python dictionary"""
        dd = dict(errorMessage=self.error_message,
                  errorCode=self.error_code)
        if self.traceback is not None:
            dd['traceback'] = self.traceback
        return dd


class BadPath(BaseSparclException):
    """A field path starts with a non-core field."""
    error_code = 'BADPATH'


class BadQuery(BaseSparclException):
    """Bad find constraints."""
    error_code = 'BADPATH'


class BadInclude(BaseSparclException):
    """Include list contains invalid data field(s)."""
    error_code = 'BADINCL'


class UnknownServerError(BaseSparclException):
    """Client got a status response from the SPARC Server that we do not
    know how to decode."""
    error_code = 'UNKNOWN'


class UnkDr(BaseSparclException):
    """The Data Release is not known or not supported."""
    error_code = 'UNKDR'


class ReadTimeout(BaseSparclException):
    """The server did not send any data in the allotted amount of time."""
    error_code = 'RTIMEOUT'


class UnknownSparcl(BaseSparclException):
    """Unknown SPARCL error.  If this is ever raised (seen in a log)
    create and use a new BaseSparcException exception that is more specific."""
    error_code = 'UNKSPARC'


class UnknownField(BaseSparclException):
    """Unknown field name for a record"""
    error_code = 'UNKFIELD'


class NoCommonIdField(BaseSparclException):
    """The field name for Science id field is not common to all Data Sets"""
    error_code = 'IDNOTCOM'


class ServerConnectionError(BaseSparclException):
    error_code = 'SRVCONER'


class BadSearchConstraint(BaseSparclException):
    error_code = 'BADSCONS'


class NoRecords(BaseSparclException):
    """Results did not contain any records"""
    error_code = 'NORECORD'


class TooManyRecords(BaseSparclException):
    """Too many records asked for in RETRIEVE"""
    error_code = 'TOOMANYR'


class NoIDs(BaseSparclException):
    """The length of the list of original IDs passed to the reorder
       method was zero"""
    error_code = 'NOIDS'


# error_code values should be no bigger than 8 characters 12345678