Decorator Module¶
The Approach¶
Decorator-based approach is a good choice;
- if you do not want to use inheritance on your classes
- if you want to implement
exceptive
on a simpler case, like a simple method
Decorators are much more flexible than inheritance, in which you can define custom object method to run and custom object method to run on exception.
catch¶
-
catch
(exception, method[, *args[, **kwargs]])
You can import the catch
decorator from exceptive.decorators
module.
catch
is a decorator which you can apply on an independent method as below:
def invalid_input(exception):
print("The input is invalid.")
@catch(TypeError, invalid_input)
def greet(name):
print("Hello "+name+"!")
greet("world")
# Hello world!
greet(5)
# The input is invalid.
First you provide which exception to catch and then a callback method, which might be a proper method or a lambda.
Notice you have exception
on callback method? That’s how you can further analysis the thrown exception and provide
further custom behavior.
You can also proive positional or keyword arguments for callback method on decorator. Here is a code sample:
def invalid_input(exception, default_value):
print("Hello "+default_value+"!")
@catch(TypeError, invalid_input, default_value="world")
def greet(name):
print("Hello "+name+"!")
greet("Eray")
# Hello Eray!
greet(5)
# Hello world!
Warning
This decorator is not suitable for object methods. For object methods, see catch_object
decorator below.
Note
You can also use multiple catch
decorator to handle multiple exception types.
catch_object¶
-
catch
(exception[, method=None[, *args[, **kwargs]]])
catch_object
decorator is specifically designed for object methods. It looks up for callback method in the
object-level.
You can import catch_object
decorator from exceptive.decorators
.
Providing Default Callback Method¶
When you provide catch_object
decorator with YourException
, except__YourException
is called in case the
exception is thrown.:
class Hello:
@catch_object(TypeError)
def greet(self, name):
print("Hello "+name+"!")
def except__TypeError(self, exception):
print("Invalid value!")
Providing Custom Callback Method¶
Default lookup for callback method may generate stylistic warnings by your intellisense or linters. So, you can also
provide the method name to look up for as a str
to handle exception.:
class Hello:
@catch_object(TypeError, "handle_type_error")
def greet(self, name):
print("Hello "+name+"!")
def handle_type_error(self, exception):
print("Invalid value!")
method
argument also accepts ``callable``s, so that you can pass an independent method.:
def handle_type_error(exception):
print("Invalid value!")
class Hello:
@catch_object(TypeError, handle_type_error)
def greet(self, name):
print("Hello "+name+"!")
Note
catch_object
decorator’s parameters are quite similar to catch
decorator’s. So you can also provide your
own args
and kwargs
to it.
Note
You can also define multiple catch_object
on a single object method.