It is a simple tool that can be used to intercept methods of classes to apply advices on them.

pip install SimpleInterceptor

Please note, pip search SimpleInterceptor doesn't return anything. Alternatively, the package can be cloned or downloaded, extracted and following can be run

• Install using python setup.py install
• Run Tests using python setup.py test

If we were to implement a bank transaction logic, it could be as simple as this.

class BankTransaction(object):
    def transfer(self, amt):
        print "Transferring Rs. %d" % amt

And transaction would be done this simply as well.

obj = BankTransaction()
obj.transfer(1000)

Now, there could be various other concerns related to this requirement - logging, checking if balance is available, notifying user about the transaction status etc. We could had written all of this logic there. But in order to modularise it better or separate the cross-cutting concerns, we follow principles of AOP and apply the other concerns(advices) by intercepting the core method. This simple library is intended to do this.

Say the above concerns are implemented this trivially.

def start_transaction_log(*args, **kwargs):
    print "Starting transaction"

def check_balance_available(*args, **kwargs):
    print "Balance check logic says Transaction allowed"

def send_notification(*args, **kwargs):
    print "Transaction successful"

Now, in order to apply these logics to the transfer method, we would need to create an aspect and decorate the BankTransaction class with the intercept decorator, featured by the tool, as shown under. Instead of using transfer we could had used any regex pattern to match the method name. This allows to intercept multiple methods using the same pattern.

aspects = dict()
aspects[r'transfer'] = dict(
    before=start_transaction_log,
    around_before=check_balance_available,
    after_success=send_notification)

from interceptor import intercept

BankTransaction = intercept(aspects)(BankTransaction)

obj = BankTransaction()
obj.transfer(1000)

The tool accepts following self-explanatory advices. before logic is run before around_before and around_after is run before after_success. after_exc can be used to write exception logic. around_after doesn't run in case of exception.

• before
• around_before
• after_exc
• around_after
• after_success
• after_finally