def lambda_handler()

in sam-code/img_api/app.py [0:0]
55 lines of code
3 McCabe index (conditional complexity)

def lambda_handler(event, context):
    print(event)

    # Define desired image dimentions from query string if provided
    xdim_requested = int(event.get("queryStringParameters",{}).get("w",  xdim))
    ydim_requested = int(event.get("queryStringParameters",{}).get("h",  ydim))
    cmin_requested = int(event.get("queryStringParameters",{}).get("min",cmin))
    cmax_requested = int(event.get("queryStringParameters",{}).get("max",cmax))

    # For demo purposes only - define whether plain text response in base64 encoded
    demo64Flag   = int(event.get("queryStringParameters",{}).get("demo64Flag",0))

    # Define desired output formate from accept header, default to JPEG 
    accept = event.get("headers",{}).get("accept","image/jpeg")



    # Get the RESTful VERB
    verb = event.get("requestContext",{}).get("http",{}).get("method","GET").split()[0]
    # On OPTIONS we don't return data so save time
    if verb == "OPTIONS":
        image = Image.new('RGB',(1,1))
        result = encode_img(image,accept)
    # On POST, take an image, overlay noise
    elif verb == "POST":
        # Base64 decode data it it came in encoded
        img_string = event.get("body","")
        if event.get("isBase64Encoded",False)==True:
            img_data = b64decode(img_string)
        else:
            img_data = img_string.encode('utf-8')
        # Get a PIL image object from data and overlay noise
        image = decode_img(
            img_data, 
            event.get("headers",{}).get("content-type","text/plain"),
            xdim_requested,ydim_requested
            )
        image = overlay_noise_on_image(image,cmin_requested,cmax_requested)
        result = encode_img(image,accept)
    # On GET, just return the noise
    elif verb == "GET":
        image = generate_noise_img(xdim_requested,ydim_requested,cmin_requested,cmax_requested)
        result = encode_img(image,accept)
    # On all other calls return error
    else:
        result = { "success": False, "mimetype": "text/plain", "data": "Unsupported HTTP method" }

    if result["success"]:
        return {
            # Status code 200 HTTP OK
            'statusCode': 200,
            # Return the mime type of the image
            'headers': {
                'Content-Type': result["mimetype"],
                'Access-Control-Allow-Origin': '*'
            },
            # Return the image
            'body': b64encode(result["data"]),
            # Tell API-GW that it's Base64 encoded. 
            'isBase64Encoded': True
        }       
    else: # fail
        # Return failure message as unencoded string to API-GW
        if demo64Flag == 0:
            return_string = "Text path: " + result["data"]
            return_encode = False
        # Return failure message as unencoded string to API-GW
        else:
            return_string = b64encode(("Binary path: " + result["data"]).encode('utf-8'))
            return_encode = True

        return {                
            # Status code 400 HTTP BAD REQUEST
            'statusCode': 400,
            # Return the mime type of the response
            'headers': {
                'Content-Type': 'text/plain'
            },
            # Return message, might be Base64 encoded
            'body': return_string,
            # Tell API-GW whether it's Base64 encoded. 
            'isBase64Encoded': return_encode
        }