Go style explicit error handling in Python. Features:
pip install goerr
Err
err
: creates a new error, print it and store it in the trace if the option is activated. Exit the program
if the trace is not activated. Parameters:
ex
: an exception (optional)msg
: the message string (optional)warning
: prints a warning message
info
: prints an info message
debug
: prints a debug message
panic
: force program exit after an error even if the errors trace is activated
to_dict
: returns a dictionnary with the error details
Log
Same as Err
but log errors
log_path
: path of the file where to log. Default is "errors.log"
log_format
: csv or text. Default is "csv"
.
Note: the tracebacks are not recorded if the format is csv.
Trace
Same as Err
but trace errors
trace
: prints the errors trace and reset it
via
: same as err
with an empty error: to record the call stack. See example
Check the examples directory for code
Trace errors across the call stack:
import time
from goerr import Trace
err = Trace()
def func1():
print("Func 1 running")
time.sleep(0.5)
try:
'x' > 1
except Exception as e:
err.new("Errmsg frun func1", e)
print("Func 1 finished")
def func2():
func1()
time.sleep(0.5)
err.via("Errmsg frun func2")
print("Func 2 running")
def func3():
func2()
time.sleep(0.5)
err.via()
print("Func 3 running")
func3()
err.trace()
Output:
A helper function is available to test errors:
testing.assert_err
: parameters:
error type
: a string with the error typefunction to run
: the function to test*args
: function arguments**kwargs
: function keyword argumentsExample:
# the program
from goerr import Err
class Foo(Err):
def func1(self, param1, param2):
try:
param1 > param2
except Exception as e:
self.err(e)
# the test
import unittest
from goerr.testing import assert_err
from myprogram import Foo
class MyTest(unittest.TestCase):
def test_myprogram(self):
foo = Foo()
assert_err("TypeError", foo.func1, 1, "bar")
I like the explicit errors management in Go (unlike many people) and I wanted to have the same kind of experience in Python: a fined grained control over errors all across the call stack.
The same lib in Go: terr