The document discusses using aspect oriented programming (AOP) in Python to design APIs. It describes how AOP can help separate concerns like security, logging, and serialization into distinct aspects to avoid scattering code across multiple functions. Decorators are proposed as a way to implement aspects for a bioenergy application API. Specific decorator aspects are presented for security, statistics, serialization, and dispatching API calls to core functions. The implementation applies the aspects as decorators to API functions to cleanly separate the concerns.

1. AOP in Python API design
Douwe van der Meij
Goldmund, Wyldebeast & Wunderliebe

2. Outline
● Problem description
● Aspect Oriented Programming
● Implementation

3. Case
● BioBench:
○ Application for biogas installations
● Enter measurements
● Normalize data
● Calculate plant performance

4. Problem description
● Large code-base
● A lot of calculations
● Django web-interface
● Make calculations available via an API

5. Problem description
● Is there a library/framework?
● Are the alternatives?
● What is the actual impact of the feature?
● What aspects to take into account?

6. Problem description
● Aspects:
○ Security
○ Statistics / Logging
○ Serialization
○ More?

7. Problem description
def add(lhs, rhs):
return lhs + rhs

8. Problem description
def add(lhs, rhs):
return lhs + rhs
def api_add(request):
return add(request.args['lhs'],
request.args['rhs'])

9. Problem description
def add(lhs, rhs):
return lhs + rhs
def api_add(request):
if request.args['token'] == valid:
return add(request.args['lhs'],
request.args['rhs'])
raise Exception('Security error')

10. Problem description
def add(lhs, rhs):
return lhs + rhs
def api_add(request):
if request.args['token'] == valid:
database.query().alter usage counter
return add(request.args['lhs'],
request.args['rhs'])
raise Exception('Security error')

11. Problem description
def add(lhs, rhs):
return lhs + rhs
def api_add(request):
if request.args['token'] == valid:
database.query().alter usage counter
result = add(request.args['lhs'],
request.args['rhs'])
return '<xml>{0}</xml>'.format(result)
raise Exception('Security error')

12. Problem description
def add(lhs, rhs):
return lhs + rhs
def api_add(request):
if request.args['token'] == valid:
database.query().alter usage counter
result = add(request.args['lhs'],
request.args['rhs'])
return '<xml>{0}</xml>'.format(result)
raise Exception('Security error')

13. Problem description
def add(lhs, rhs):
return lhs + rhs
def api_add(request):
if request.args['token'] == valid:
database.query().alter usage counter
result = add(request.args['lhs'],
request.args['rhs'])
return '<xml>{0}</xml>'.format(result)
raise Exception('Security error')

14. Problem description
Code base

15. Problem description
● Security
Code base

16. Problem description
● Statistics / Logging
Code base

17. Problem description
● Serialization
Code base

18. Problem description
● Dispatcher
Code base

19. Problem description
● Scattered / tangled code
Code base

20. Aspect Oriented Programming
● What is AOP?
● Separation of concerns (aspects)
● Avoid scattering / tangling

21. Aspect Oriented Programming
● Scattered / tangled code
Code base

22. Aspect Oriented Programming
● Avoid scattering
Code base

23. Aspect Oriented Programming
● Avoid tangling
Code base

24. Aspect Oriented Programming
● How to implement these marvelous
concepts?
○ In pure python please!

25. Aspect Oriented Programming
● Decorators!

26. Aspect Oriented Programming
● Aspect:
○ Pointcuts
○ Join points
○ Advices
■ Before advices
■ After advices
■ Around advices

27. Aspect Oriented Programming
● Before advice
○ Must execute the function (no side-effects)
def aspect(function):
def advice(*args, **kwargs):
do something here
return function(*args, **kwargs)
return advice

28. Aspect Oriented Programming
● After advice
○ Must execute the function (no side-effects)
def aspect(function):
def advice(*args, **kwargs):
result = function(*args, **kwargs)
do something here
return result
return advice

29. Aspect Oriented Programming
● Around advice
○ Allowed to bypass the function
def aspect(function):
def advice(*args, **kwargs):
do something here
result = function(*args, **kwargs)
do something here
return result
return advice

30. Implementation
● How to apply it to our case?

31. Implementation
● The decorators

32. Implementation
● Security aspect
○ Around advice
def secure(function):
def advice(*args, **kwargs):
if valid token in request object:
return function(*args, **kwargs)
raise Exception('No valid token provided')
return advice

33. Implementation
● Statistics aspect
○ Before advice
def statistics(function):
def advice(*args, **kwargs):
increase API usage count for the user logged in
return function(*args, **kwargs)
return advice

34. Implementation
● Serialization aspect
○ Around advice
def serialize(function):
def advice(format, *args, **kwargs):
if not format in ['html', 'xml', 'json']:
raise exception
result = function(*args, **kwargs)
make a http response of 'result' in the right format
return advice

35. Implementation
● Dispatcher aspect
○ Around advice
def dispatch(function):
def advice(*args, **kwargs):
proxy the API call to a call to the core system
return advice

36. Implementation
mapping = {
'api_function':
(core_function, ['lhs', 'rhs']),
'create_token':
(create_token, ['username', 'password']),
}

37. Implementation
def dispatch(function):
def advice(*args, **kwargs):
if API call proxy mapping:
in
core_function, params = mapping[API call]
kwargs.update(extract(params, request))
return function(proxy=core_function,
params=params, *args, **kwargs)
raise exception
return advice

38. Implementation
● The API itself

39. Implementation
@secure
@serialize
@statistics
@dispatch
def api_call(*args, **kwargs):
proxy_function = kwargs['proxy']
params = kwargs['params']
return proxy_function(extract params from kwargs)

40. Conclusion
● AOP offers some brilliant concepts in
software engineering
● Separate your concerns / aspects
○ Avoid classical scattering and tangling

41. Questions?
● Thank you!
vandermeij@gw20e.com
@douwevandermeij