Best practices for handling application specific exceptions?

Question

Is it considered to be a good practice to convert all types of exceptions (exceptions from internal logic of application + exceptions from application's external dependencies - for example: File System) to application specific exceptions?

For example,

I am developing a Job Scheduling Software in Python (using layered architecture). One of the layer in this architecture is Persistence layer. This layer is responsible for storing/retrieving state of the Job to/from the persistence store (File System).

I have defined two application specific exception classes "PersistenceReadError" and "PersistenceWriteError" for exceptions raised from persistence layer APIs (read_jobs, write_jobs etc).

I am not sure if this is considered to be a good practice i.e. is it right to even catch exceptions like FileNotFoundError, FilePermissionsError etc. and wrap them in PersistenceRead/PersistenceWrite exceptions? Also how far should I go with creating exception classes vs using limited exception classes (to group similar exceptions together) with error code/messages to distinguish subtypes of exceptions.

Answer 1

It depends on what your overall approach and intent are.
I tend to keep the standard exceptions separate from the application-specific exceptions.
The question is, what do you do with them afterwards.

1. Reraise as is: no need to wrap them in app-specific exceptions.
2. Use in reporting or logging: wrapping is recommended.
3. Add more info, such as error codes and messages: definitely wrap them.
4. Group: if multiple exceptions are considered part of the same action/task.
   ie: FileNotFoundError, FilePermissionsError could raise PersistenceIOError

Example:

try:
    try:
        doSomething()
    except SystemError:
        do1()
        raise MainEx
    except ValueError:
        do2()
        raise MainEx
    except IOError as e:
        # Add more info
        raise PersistenceIOError(code=123, msg='File Bad', other=e)
    except TypeError:
        # Raise as is
        raise
    except Exception as e:
        raise UnknownEx
except MainEx:
    doMain()

Update:

Here's an idea of how I handle same exception with multiple error codes:

try:
    if a:
        raise PersistenceError(code=1, msg='1 Bad')
    elif b:
        raise PersistenceError(code=2, msg='2 Bad')
    else:
        raise PersistenceError(code=3, msg='3 Bad')
except PersistenceError as e:
    if e.code == 1:
        do1()
    elif e.code == 2:
        do2()
    elif e.code == 3:
        do3()
    else:
        raise