example_sns_calls.py

import json
import requests
import os
import ast
import logging
import sys
import boto3
import datetime
import time
import uuid
from retrying import retry
from boto3.dynamodb.conditions import Key, Attr
from operator import itemgetter
from dynamodb_json import json_util as dyndb_json
logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.INFO)
try:
    dynamodb = boto3.client('dynamodb',region_name=os.environ['REGION'])
except:
    # local testing
    dynamodb = boto3.client('dynamodb',region_name='us-east-1')
try:
    dynamodb_resource = boto3.resource('dynamodb',region_name=os.environ['REGION'])
except:
    # local testing
    dynamodb_resource = boto3.resource('dynamodb',region_name='us-east-1')
try:
    sns      = boto3.client('sns',region_name=os.environ['REGION'])
except:
    # local testing
    sns      = boto3.client('sns',region_name='us-east-1')
try:
    s3       = boto3.resource('s3',region_name=os.environ['REGION'])
except:
    # local testing
    s3       = boto3.resource('s3',region_name='us-east-1')
try:
    s3_client = boto3.client('s3',region_name=os.environ['REGION'])
except:
    # local testing
    s3_client = boto3.client('s3',region_name='us-east-1')
def send_to_sns(subject, message):
    """ 
    generic publish of an event for use in an event driven architecture
    """
    #logger.info("subject of sns message: %s" %str(subject));
    #logger.info("body/message of sns message: %s" %str(message));
    result = sns.publish(
        TopicArn=os.environ['GENERIC_WEB_EVENT_SNS'],
        Subject=str(subject),
        Message=str(message)
    )
    logger.info("result of sns publish: %s" %str(result));
    return result
def extract_selections(week):
    """
    pull pick6 entries 
    """
    #time check start
    t0 = time.time()
    #time check end
    response = dynamodb.scan(TableName='Pick6',
                             IndexName='week-index',
                             ExpressionAttributeValues={':w': {'N': str(week),},},
                             FilterExpression='week = :w')
    all_entries = response['Items']
    while 'LastEvaluatedKey' in response:
        response = dynamodb.scan(TableName='Pick6',
                                 ExclusiveStartKey=response['LastEvaluatedKey'],
                                 IndexName='week-index',
                                 ExpressionAttributeValues={':w': {'N': str(week),},},
                                 FilterExpression='week = :w'                                 
                                 )
        all_entries.extend(response['Items'])
    pydict = dyndb_json.loads(all_entries)
    #time check start
    t1 = time.time()
    logger.info("time of extract_selections module: %s" %str((t1 - t0)))
    #time check end
    return pydict
def extract_weekly_totals():
    """
    pull Pick6WeeklyResults for past weeks
    """
    #time check start
    t0 = time.time()
    #time check end
    response = dynamodb.scan(TableName='Pick6WeeklyResults')
    all_entries = response['Items']
    while 'LastEvaluatedKey' in response:
        response = dynamodb.scan(TableName='Pick6WeeklyResults',
                                 ExclusiveStartKey=response['LastEvaluatedKey'])
        all_entries.extend(response['Items'])
    pydict = dyndb_json.loads(all_entries)
    #time check start
    t1 = time.time()
    logger.info("time of extract_weekly_totals module: %s" %str((t1 - t0)))
    #time check end
    return pydict
def get_player_details(player_id):
    """
    get player details
    """
    #time check start
    t0 = time.time()
    #time check end
    table = dynamodb_resource.Table('NflRoster')
    response = table.query(KeyConditionExpression=Key('playerId').eq(player_id))
    details = response['Items']
    pydict_full = dyndb_json.loads(details)
    #logger.info("get_player_details: %s" %str(pydict_full))
    output = {"position":pydict_full[0]['position'],\
              "team"    :pydict_full[0]['team']}
    #time check start
    t1 = time.time()
    logger.info("time of get_player_details module: %s" %str((t1 - t0)))
    #time check end
    return output
def get_player(player_id,year_week):
    """
    get player data
    """
    #time check start
    t0 = time.time()
    #time check end
    table = dynamodb_resource.Table('NflPlayer')
    response = table.query(KeyConditionExpression=Key('playerId').eq(player_id) & Key('yearWeek').eq(int(year_week)))
    player = response['Items']
    pydict_full = dyndb_json.loads(player)
    #logger.info("player: %s" %str(pydict_full))
    output = None
    for e in pydict_full:
        playerId = e['playerId']
        #details = get_player_details(playerId)
        #display_name = e['playerName'] + " - " + details["team"] 
        for x in ['week','profile_id','playerId','team','playerName','insUpdEpoch','yearWeek','seasonType']:
            try:
                del e[x]
            except:
                pass
        values = e
        #logger.info("values: %s" %str(values))
        weekly_points = scoring(values)
        output = {"playerId": playerId,\
                  "stats"   : values,\
                  "points"  : weekly_points}
    #time check start
    t1 = time.time()
    logger.info("time of get_player module: %s" %str((t1 - t0)))
    #time check end
    return output
def ins(table,item):
    """
    insert into dynamodb
    """
    #logger.info("inserting into table: %s" %str(table))
    table = dynamodb_resource.Table(table)
    response = table.put_item(Item=item,)
    #logger.info("Insert DynamoDB results: %s" %str(response))
    return response
def extract_games(week):
    """
    pull schedule games
    """
    #time check start
    t0 = time.time()
    #time check end
    response = dynamodb.scan(TableName='NflSchedule',
                             IndexName='week-index',
                             ExpressionAttributeValues={':w': {'N': str(week),},},
                             FilterExpression='week = :w')
    all_games = response['Items']
    while 'LastEvaluatedKey' in response:
        response = dynamodb.scan(TableName='NflSchedule',
                                 IndexName='week-index',
                                 ExpressionAttributeValues={':w': {'N': str(week),},},
                                 FilterExpression='week = :w',
                                 ExclusiveStartKey=response['LastEvaluatedKey'])
        all_games.extend(response['Items'])
    pydict = dyndb_json.loads(all_games)
    #time check start
    t1 = time.time()
    logger.info("time of extract_games module: %s" %str((t1 - t0)))
    #time check end
    return pydict
def get_pick6_entries(event, context):
    '''
    retrieve all pick6 entries
    '''
    try:
        if event['source'].encode() == 'serverless-plugin-warmup':
            logger.info("lambda warm-up call")
            response = {
                "statusCode": 200,
                "body": "serverless-plugin-warmup"
            }
            return response
            raise SystemExit(0)
    except:
        pass
    function_uuid = str(uuid.uuid4())
    current_epoch = int(time.time())
    logger.info("incoming event: %s" %str(event))
    results = {"currentWeek": "foo",\
               "previousWeeks": "bar"}
    message = "get_pick6_entries completed successfully"
    statusCode = 200
    response = {
        "HTTPStatusCode": statusCode,
        "message": message,
        "thisFunction": "get_pick6_entries",
        "eventEpoch": int(time.time()),
        "data": results,
        "functionUuid": function_uuid,
        "headers": {
          "Access-Control-Allow-Origin": "*", 
        }
    }
    logger.info("response: %s" %str(response))
    return response