Source code for

import importlib
import inspect
import json
import os

import boto3


In lambda handler:

from import event_command

def handler(event, context):

    if event_command(event, context):

    from zappa.asynchronous import run as zappa_run
except ImportError:
    zappa_run = None

[docs]def event_command(event, context): """ Minimal `shim <>`_ to add to the top lambda handler function to enable distributed tasks The rest of this library is compatible with zappa.async library. If you have deployed your app with `Zappa <>`_, then you do NOT need to add this shim. """ if not set(event).intersection({'task_path', 'args', 'kwargs'}): return False # did not match an event command func = import_and_get_task(event['task_path'], event.get('func_class_init_kwargs')) # if the func was decorated with zappa.async.task then run the real function func = getattr(func, 'sync', func) # DID match an event command # -- so probably don't do the usual thing the Lambda handler does return (func(*event['args'], **event['kwargs']) or True)
def run(func, args=[], kwargs={}, service='lambda', capture_response=False, remote_aws_lambda_function_name=None, remote_aws_region=None, func_class=None, func_class_init_kwargs=None, **task_kwargs): lambda_function_name = (remote_aws_lambda_function_name or os.environ.get('AWS_LAMBDA_FUNCTION_NAME')) if not lambda_function_name or lambda_function_name == 'FORCE_LOCAL': # We are neither running in Lambda environment, nor given one to invoke # so let's run it synchronously -- so code can be compatible both in-and-out of Lambda func(*args, **kwargs) return True # zappa has more robust and allows more configs -- but is not compatible with func_class if zappa_run and not func_class: return zappa_run(func, args, kwargs, service, capture_response, remote_aws_lambda_function_name, remote_aws_region, **task_kwargs) task_path = get_func_task_path(func, func_class) payload = (json.dumps({'task_path': task_path, 'args': args, 'kwargs': kwargs, 'func_class_init_kwargs': func_class_init_kwargs}) .encode('utf-8')) if len(payload) > 128000: # pragma: no cover raise AsyncException("Payload too large for async Lambda call") lambda_client = boto3.Session().client('lambda') response = lambda_client.invoke( FunctionName=lambda_function_name, InvocationType='Event', # makes the call async Payload=payload ) return response.get('StatusCode', 0) == 202 ## # Utility Functions ## def import_and_get_task(task_path, instance_init_kwargs=None): """ Given a modular path to a function, import that module and return the function. """ module, function = task_path.rsplit('.', 1) app_module = importlib.import_module(module) class_func = function.split('|') app_function = getattr(app_module, class_func[0]) if len(class_func) == 1: return app_function def init_and_run(*args, **kwargs): print('INITRUN', args, kwargs) if len(class_func) == 3: # instance instance = app_function # actually the class else: instance = app_function(**(instance_init_kwargs or {})) method = getattr(instance, class_func[1]) return method(*args, **kwargs) return init_and_run def get_func_task_path(func, method_class=None): """ Format the modular task path for a function via inspection. """ module_path = inspect.getmodule(method_class or func).__name__ func_name = func.__name__ # To support class methods, we need to see if it IS a method on a class # and then also determine if it is an instance method or a classmethod # Then we record that info with |'s to be decoded in import_and_get_task # classmethod format: "Foo|method|" # instance method format: "Foo|method" task_path = '{}.{}{}{}'.format( module_path, f'{method_class.__name__}|' if method_class else '', func_name, '|' if method_class and 'of <class' in repr(func) else '' ) return task_path class AsyncException(Exception): pass