Ejemplo n.º 1
0
def rg():

    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
    config = ConfigParser()
    configfn = os.path.join(os.path.expanduser('~'), '.pgcred')
    config.read(configfn)
    nbapg = NBAComPg(username=config['nbadb']['username'],
                     password=config['nbadb']['password'],
                     database=config['nbadb']['database'])

    with open('/home/sansbacon/data.csv', 'r') as infile:
        data = [{k: v
                 for k, v in row.items()} for row in csv.DictReader(
                     infile, skipinitialspace=True, delimiter=',')]

    for d in season_dates('2015-16')[2:]:
        items = []
        players = rotoguru_to_pydfs(
            filter(lambda x: x['date'] == datetostr(d, 'db'), data))
        if players:
            optimizer = LineupOptimizer(settings.DraftKingsBasketballSettings)
            optimizer._players = players
            try:
                for idx, lineup in enumerate(optimizer.optimize(n=100)):
                    for p in lineup.players:
                        items.append({
                            'game_date':
                            d,
                            'lineup_rank':
                            idx + 1,
                            'nbacom_player_id':
                            p.id,
                            'team_code':
                            p.team,
                            'name':
                            '{} {}'.format(p.first_name, p.last_name),
                            'positions':
                            p.positions,
                            'dkpts':
                            p.fppg,
                            'salary':
                            p.salary
                        })

            except Exception as e:
                logging.exception(e)

            finally:
                nbapg.insert_dicts(items, 'optimal_lineups')

        logging.info('finished {}'.format(d))
Ejemplo n.º 2
0
def main():

    logging.basicConfig(stream=sys.stdout, level=logging.INFO)

    config = ConfigParser()
    configfn = os.path.join(os.path.expanduser('~'), '.pgcred')
    config.read(configfn)
    nbapg = NBAComPg(username=config['nbadb']['username'],
                    password=config['nbadb']['password'],
                    database=config['nbadb']['database'])
    flpg = FantasyLabsNBAPg(username=config['nbadb']['username'],
                    password=config['nbadb']['password'],
                    database=config['nbadb']['database'])

    cn = 'nba-agent-{}'.format(today())
    a = NBAComAgent(cache_name=cn, cookies=None, db=nbapg)
    a.scraper.delay = 1
    season = '2016-17'

    # get the rosters
    q = """SELECT is_starter FROM starters WHERE nbacom_player_id = {}
            ORDER BY game_date DESC LIMIT 1"""
    incomplete = []
    roster_url = 'http://data.nba.com/data/10s/prod/v1/2016/teams/{}/roster.json'
    for urlcode in nbapg.select_list(today_team_url_codes()):
        print(urlcode)
        try:
            roster = a.scraper.get_json(roster_url.format(urlcode))
            for p in roster["league"]["standard"]["players"]:
                pid = p.get('personId')
                starter = a.db.select_scalar(q.format(pid))
                print('{}, {}'.format(pid, starter))
        except:
            incomplete.append(roster_url.format(urlcode))
    for i in incomplete:
        try:
            roster = a.scraper.get_json(roster_url.format(urlcode))
            for p in roster["league"]["standard"]["players"]:
                starter = a.db.select_scalar(q.format(p))
                print('{}, {}'.format(p, starter))
        except:
            logging.error('could not get {}'.format(i))
Ejemplo n.º 3
0
def fl():

    logging.basicConfig(stream=sys.stdout, level=logging.INFO)

    config = ConfigParser()
    configfn = os.path.join(os.path.expanduser('~'), '.pgcred')
    config.read(configfn)

    nbapg = NBAComPg(username=config['nbadb']['username'],
                     password=config['nbadb']['password'],
                     database=config['nbadb']['database'])

    #dq = """SELECT DISTINCT game_date FROM cs_games WHERE game_date < now()::date ORDER BY game_date"""
    dq = """SELECT DISTINCT game_date FROM games WHERE game_date = '2015-11-02'"""
    q = """SELECT * FROM past_dfs WHERE game_date = '{}' ORDER BY dk_points DESC"""

    for d in nbapg.select_list(dq):
        gd = datetostr(d, 'nba')
        logging.info('starting {}'.format(gd))
        optimizer = LineupOptimizer(settings.DraftKingsBasketballSettings)
        pls = nbapg.select_dict(q.format(gd))
        logging.info(pls[0:3])
        optimizer._players = nba_to_pydfs(pls)
        items = []
        try:
            for idx, lineup in enumerate(optimizer.optimize(n=10)):
                for p in lineup.players:
                    items.append({
                        'game_date': gd,
                        'lineup_rank': idx + 1,
                        'nbacom_player_id': p.id,
                        'positions': p.positions,
                        'dkpts': p.fppg,
                        'salary': p.salary
                    })
                print(lineup)
                logging.info('finished lineup {}'.format(idx))

        except Exception as e:
            logging.exception(e)
            continue
Ejemplo n.º 4
0
def main():

    config = ConfigParser()
    configfn = os.path.join(os.path.expanduser('~'), '.pgcred')
    config.read(configfn)
    db = NBAComPg(username=config['nbadb']['username'],
                    password=config['nbadb']['password'],
                    database=config['nbadb']['database'])

    s = WaybackScraper(cache_name='realgm-wayback')
    rotoworld(s, '2014-15', db)
    rotoworld(s, '2016-17', db)
Ejemplo n.º 5
0
    def __init__(self, db=True, safe=True):
        '''

        Args:
            db (bool): compose NBAComPg object as self.nbadb
            safe (bool): create backups of tables prior to inserts

        '''

        NBAAgent.__init__(self)
        self.logger = logging.getLogger(__name__)
        self.scraper = NBAComScraper()
        self.parser = NBAComParser()
        self.safe = safe
        self.nbas = NBASeasons()

        if db:
            self.nbadb = NBAComPg()
        else:
            self.nbadb = None
Ejemplo n.º 6
0
from configparser import ConfigParser

from nba.scrapers.nbacom import NBAComScraper
from nba.db.nbacom import NBAComPg
from nba.db.queries import missing_games_meta

logging.basicConfig(stream=sys.stdout, level=logging.INFO)

config = ConfigParser()
configfn = os.path.join(os.path.expanduser('~'), '.pgcred')
config.read(configfn)

s = NBAComScraper(cache_name='games-meta')
nbapg = NBAComPg(username=config['nbadb']['username'],
                        password=config['nbadb']['password'],
                        database=config['nbadb']['database'])

teams = []
url = 'http://data.nba.com/data/10s/prod/v1/{game_date}/{game_id}_boxscore.json'
headers = ['game_id', 'gamecode', 'game_date', 'team_code', ]
for item in nbapg.select_dict(missing_games_meta()):
    try:
        content = s.get_json(url.format(game_date=item['game_date'], game_id=item['game_id']))
        vteam_code = content['basicGameData']['vTeam']['triCode']
        vscore = int(content['basicGameData']['vTeam']['score'])
        vls = [int(l['score']) for l in content['basicGameData']['vTeam']['linescore']]
        hteam_code = content['basicGameData']['hTeam']['triCode']
        hscore = int(content['basicGameData']['hTeam']['score'])
        hls = [int(l['score']) for l in content['basicGameData']['hTeam']['linescore']]
        off = [o['firstNameLastName'] for o in content['basicGameData']['officials']['formatted']]
Ejemplo n.º 7
0
def main():
    #logger = logging.getLogger('nbadb-update')
    #hdlr = logging.StreamHandler(sys.stdout)
    #formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
    #hdlr.setFormatter(formatter)
    #logger.addHandler(hdlr)
    #logger.setLevel(logging.INFO)
    #logger.propagate = False
    logging.basicConfig(stream=sys.stdout, level=logging.INFO)

    config = ConfigParser()
    configfn = os.path.join(os.path.expanduser('~'), '.nbadb')
    config.read(configfn)
    nbapg = NBAComPg(username=config['nbadb']['username'],
                     password=config['nbadb']['password'],
                     database=config['nbadb']['database'])
    flpg = FantasyLabsNBAPg(username=config['nbadb']['username'],
                            password=config['nbadb']['password'],
                            database=config['nbadb']['database'])

    cn = 'nba-agent-{}'.format(today())
    a = NBAComAgent(cache_name=cn, cookies=None, db=nbapg)
    a.scraper.delay = 2
    season = '2016-17'

    # ensures players table is up-to-date before inserting gamelogs, etc.
    a.new_players(season)
    logging.info('finished update nba.com players')

    # gets all missing (days) salaries from current seasons
    from nba.agents.fantasylabs import FantasyLabsNBAAgent
    fla = FantasyLabsNBAAgent(db=flpg, cache_name='flabs-nba')
    fla.salaries(all_missing=True)
    logging.info('finished dfs salaries')

    # ensures that player_xref table includes all players from salaries
    fla.update_player_xref()
    logging.info('finished update player_xref')

    # gets ownership data from fantasylabs
    fla.ownership(all_missing=True)
    logging.info('finished dfs ownership')

    # player_gamelogs
    a.player_gamelogs(season)
    logging.info('finished nba.com player gamelogs')

    # playerstats_daily
    ps = a.playerstats(season, all_missing=True)
    logging.info('finished playerstats daily')

    # update team_gamelogs
    a.team_gamelogs(season)
    logging.info('finished team gamelogs')

    # teamstats_daily
    a.teamstats(season, all_missing=True)
    logging.info('finished teamstats daily')

    # team_opponent_dashboards
    a.team_opponent_dashboards(season, all_missing=True)
    logging.info('finished team_opponent_dashboards')

    # refresh all materialized views
    refreshq = """SELECT RefreshAllMaterializedViews('*');"""
    nbapg.execute(refreshq)
Ejemplo n.º 8
0
class NBAComAgent(NBAAgent):
    '''
    Performs script-like tasks using NBA.com API
    Intended to replace standalone scripts so can use common API and tools

    Examples:
        a = NBAComAgent()
        gamelogs = a.cs_player_gamelogs('2015-16')

    '''

    def __init__(self, db=True, safe=True):
        '''

        Args:
            db (bool): compose NBAComPg object as self.nbadb
            safe (bool): create backups of tables prior to inserts

        '''

        NBAAgent.__init__(self)
        self.logger = logging.getLogger(__name__)
        self.scraper = NBAComScraper()
        self.parser = NBAComParser()
        self.safe = safe
        self.nbas = NBASeasons()

        if db:
            self.nbadb = NBAComPg()
        else:
            self.nbadb = None

    def combine_boxscores(self, boxes, advanced_boxes):
        '''
        Combines NBAComScraper.boxscores() and boxscores_advanced()

        Arguments:
            boxscores(list): list of 'base' boxscores
            boxscores(list): list of 'advanced' boxscores

        Returns:
            merged_players (list): base and advanced combined
            merged_teams (list): base and advanced combined

        Examples:
            a = NBAComAgent()
            combined = a.combine_boxscores(boxes, advanced_boxes)

        '''

        merged_players = []
        merged_teams = []

        for gid, box in boxes.iteritems():

            # players and teams are lists of dicts
            players, teams, starterbench = self.parser.boxscore(box)

            # players_adv and teams_adv are lists of dicts
            adv_box = advanced_boxes.get(gid)
            players_adv, teams_adv = self.parser.boxscore_advanced(adv_box)

            # need to transform into dicts
            players_dict = {p['PLAYER_ID']: p for p in players}
            players_adv_dict = {p['PLAYER_ID']: p for p in players_adv}
            teams_dict = {t['TEAM_ID']: t for t in teams}
            teams_adv_dict = {t['TEAM_ID']: t for t in teams_adv}

            # now loop through players
            for pid, player in players_dict.iteritems():
                player_adv = players_adv_dict.get(pid)

                if player_adv:
                    merged_players.append(self.merge_boxes(player, player_adv))

            # now loop through teams
            for tid, team in teams_dict.iteritems():
                team_adv = teams_adv_dict.get(tid)

                if team_adv:
                    merged_teams.append(self.merge_boxes(team, team_adv))

        self.nbadb.insert_boxscores(merged_players, merged_teams)


    def commonallplayers(self, season):
        '''
        Solves problem of players changing teams
        nba.com updates player teams regularly, so i look every day to make sure lists accurate

        Arguments:
            season (str): in YYYY-YY format

        Returns:
            to_insert (list): list of players that needed to be updated

        Examples:
            a = NBAComAgent()
            combined = a.commonallplayers('2015-16')

        '''

        game_date = dt.datetime.today()
        players = self.parser.players(self.scraper.players(season=season, cs_only='1'))

        to_insert = []

        convert = {
            "PERSON_ID": 'nbacom_player_id',
            "DISPLAY_LAST_COMMA_FIRST": '',
            "DISPLAY_FIRST_LAST": 'display_first_last',
            "ROSTERSTATUS": 'rosterstatus',
            "FROM_YEAR": '',
            "TO_YEAR": '',
            "PLAYERCODE": '',
            "TEAM_ID": 'team_id',
            "TEAM_CITY": '',
            "TEAM_NAME": '',
            "TEAM_ABBREVIATION": 'team_code',
            "TEAM_CODE": '',
            "GAMES_PLAYED_FLAG": ''
        }

        for p in players:
            pti = {'game_date': game_date, 'nbacom_season_id': 22015, 'season': 2016}

            for k,v in p.iteritems():
                converted = convert.get(k)
                if converted:
                    pti[converted] = v

            to_insert.append(pti)

        if self.nbadb:
            if to_insert:
                self.nbadb.insert_dicts(to_insert, 'stats.playerteams')

        return to_insert

    def cs_player_gamelogs(self, season, date_from=None, date_to=None):
        '''
        Fetches player_gamelogs and updates cs_player_gamelogs table

        Arguments:
             season (str): in YYYY-YY format (2015-16)

        Returns:
             players (list): player dictionary of stats + dfs points
        '''

        gamelogs = self.parser.season_gamelogs(self.scraper.season_gamelogs(season, 'P'), 'P')

        table_name = 'stats.cs_player_gamelogs'

        if self.nbadb:
            if self.safe:
                self.nbadb.postgres_backup_table(self.nbadb.database, table_name)
    
            gamelogs = self.nbadb.insert_player_gamelogs(gamelogs, table_name)
            self.nbadb.update_positions(table_name)
            self.nbadb.update_teamids(table_name)

        return gamelogs

    def cs_playerstats(self, season, date_from=None, date_to=None):
        '''
        Fetches cs_player_stats and updates database table

        Arguments:
             season (str): in YYYY-YY format (2015-16)
             date_from (str): in %Y-%m-%d format, default beginning of season
             date_from (str): in %Y-%m-%d format, default yesterday

        Returns:
             player_stats (list): player dictionary of basic and advanced stats

        Examples:
            a = NBAComAgent()
            ps = a.cs_playerstats('2015-16')
            ps = a.cs_playerstats(season='2015-16', date_from='2016-03-01', date_to='2016-03-08')

        '''

        # default is to get entire season through yesterday
        yesterday = dt.datetime.strftime(dt.datetime.today() - dt.timedelta(1), '%Y-%m-%d')

        if not date_from:
            date_from = self.nbas.season_start(season)

        if not date_to:
            date_to = yesterday

        ps_base = self.parser.playerstats(self.scraper.playerstats(season, DateFrom=date_from, DateTo=date_to))
        ps_advanced = self.parser.playerstats(self.scraper.playerstats(season, DateFrom=date_from, DateTo=date_to, MeasureType='Advanced'))

        # now need to merge base and advanced
        ps_base = {p['PLAYER_ID']: p for p in ps_base}

        for ps_adv in ps_advanced:
            pid = ps_adv['PLAYER_ID']
            base = ps_base.get(pid)

            if base:
                base.update(ps_adv)
                ps_base[pid] = base       

        return self.nbadb.insert_playerstats(ps_base.values(), table_name='stats.cs_playerstats', game_date=yesterday)

    def cs_team_gamelogs(self, season, date_from=None, date_to=None):
        '''
        Fetches team_gamelogs and updates cs_team_gamelogs table

        Arguments:
             season (str): in YYYY-YY format (2015-16)

        Returns:
             team_gl (list): player dictionary of stats

        Examples:
            a = NBAComAgent()
            tgl = a.cs_team_gamelogs('2015-16')
            tgl = a.cs_playerstats(season='2015-16', date_from='2016-03-01', date_to='2016-03-08')

        '''

        gamelogs = self.parser.season_gamelogs(self.scraper.season_gamelogs(season='2015-16', player_or_team='T'), 'T')
        self.logger.debug('there are {0} team gamelogs'.format(len(gamelogs)))

        if self.nbadb:

            table_name = 'stats.cs_team_gamelogs'

            if self.safe:
                self.nbadb.postgres_backup_table(self.nbadb.database, table_name)

            gamelogs = self.nbadb.insert_team_gamelogs(gamelogs, table_name)
            self.logger.debug('there are now {0} team gamelogs'.format(len(gamelogs)))

        return gamelogs

    def cs_teamstats(self, season, date_from=None, date_to=None):
        '''
        Fetches leaguedashteamstats and updates cs_leaguedashteamstats table

        Arguments:
             season (str): in YYYY-YY format (2015-16)
             date_from (str): in %Y-%m-%d format, default beginning of season
             date_from (str): in %Y-%m-%d format, default yesterday

        Returns:
             teamstats (list): team dictionary of basic and advanced stats
             
         Examples:
            a = NBAComAgent()
            ps = a.cs_teamstats('2015-16')
            ps = a.cs_teamstats(season='2015-16', date_from='2016-03-01', date_to='2016-03-08')

        '''

        # default is to get entire season through yesterday
        yesterday = dt.datetime.strftime(dt.datetime.today() - dt.timedelta(1), '%Y-%m-%d')

        if not date_from:
            date_from = self.nbas.season_start(season)

        if not date_to:
            date_to = yesterday

        ts_base = self.parser.teamstats(self.scraper.teamstats(season, DateFrom=date_from, DateTo=date_to))
        ts_adv = self.parser.teamstats(self.scraper.teamstats(season, DateFrom=date_from, DateTo=date_to, MeasureType='Advanced'))

        # now need to merge base and advanced
        ts_base = {t['TEAM_ID']: t for t in ts_base}

        for ts_adv in ts_adv:
            tid = ts_adv['TEAM_ID']
            base = ts_base.get(tid)

            if base:
                base.update(ts_adv)
                ts_base[tid] = base

        self.nbadb.insert_teamstats(ts_base.values(), table_name='stats.cs_teamstats', game_date=yesterday)

        return ts_base, ts_adv

    def merge_boxes(self, b1, b2):
        '''
        Combines base and advanced player or team boxscores from same game

        Arguments:
            base_box(dict): base boxscore
            adv_box(dict): advanced boxscore

        Returns:
            merged (dict) or None

        Examples:
            a = NBAComAgent()
            merged = a.merge_boxes(base_box, adv_box)

        '''

        z = b1
        z.update(b2)
        return z

    def players_to_add(self):
        '''
        Compare current_season_gamelogs and players tables to see if missing players in latter

        Arguments:
            None

        Returns:
            list
        '''

        sql = '''SELECT * FROM vw_add_players_table'''
        return self.nbadb.select_dict(sql)

    def scoreboards(self, season_start, season_end, pkl_fname=None):
        '''
        Downloads and parses range of scoreboards, optionally saves to pickle file

        Arguments:
            season_start (str): in %Y-%m-%d format
            season_end (str): in %Y-%m-%d format
            pkl_fname (optional [str]): example - 'scoreboards_2015-16.pkl'

        Returns:
             scoreboards (list): scoreboard dicts

         Examples:
            a = NBAComAgent()
            sb = a.scoreboards()
            sb = a.scoreboards(pkl_fname = 'scoreboards_2015-16.pkl')
            sb = a.scoreboards(season_start='2015-10-27', season_end='2016-04-15')
        '''

        scoreboards = []

        for day in reversed(self.date_list(season_end, season_start)):
            game_date = dt.datetime.strftime(day, '%Y-%m-%d')
            scoreboard_json = self.nbas.scoreboard(game_date=game_date)
            scoreboard = self.nbap.scoreboard(scoreboard_json, game_date=game_date)
            scoreboards.append(scoreboard)       

        if pkl_fname:
            try:
                with open('/home/sansbacon/scoreboards_20160108.pkl', 'wb') as outfile:
                    pickle.dump(scoreboards, outfile)

            except:
                logging.error('could not save scoreboards to {0}'.format(pkl_fname))

        return scoreboards
        
    def teamgames(self, games):
        '''
        Converts list of games into list in teamgames format, where there are2 teamgames for every game

        Arguments:
            games(list): list of games from nba.com where two teams are in 1 row (visitor, home)

        Returns:
            teamgames(list): list of games in teamgames format, 2 teamgames per game row
            
        Examples:
            # is in format {'game_id', 'visitor_team_id', 'home_team_id', . . . }
            games = NBAPostgres.select_dict('SELECT * FROM games')

            # is in format {'game_id', 'team_id', 'opponent_team_id', 'is_home' . . . }
            teamgames = NBAComAgent.teamgames(games)

        '''

        teamgames = []
        to_drop = ['home_team_code', 'home_team_id', 'visitor_team_code', 'visitor_team_id']

        for game in games:
            tg1 = copy.deepcopy(game)
            tg1['team_code'] = game['home_team_code']
            tg1['team_id'] = game['home_team_id']
            tg1['opponent_team_code'] = game['visitor_team_code']   
            tg1['opponent_team_id'] = game['visitor_team_id']
            tg1['is_home'] = True

            teamgames.append({k:v for k,v in tg1.iteritems() if not k in to_drop})

            tg2 = copy.deepcopy(game)
            tg2['team_code'] = game['visitor_team_code']
            tg2['team_id'] = game['visitor_team_id']
            tg2['opponent_team_code'] = game['home_team_code']
            tg2['opponent_team_id'] = game['home_team_id']
            tg2['is_home'] = False

            teamgames.append({k:v for k,v in tg2.iteritems() if not k in to_drop})

        return teamgames

    def team_opponents(self, season, season_start=None, season_end=None, pkl_fname=None):
        '''
        Downloads and parses range of team_opponents, optionally saves to pickle file

        Arguments:
            season (str): in YYYY-YY format
            season_start (str): in %Y-%m-%d format, default is actual start of season
            season_end (str): in %Y-%m-%d format, default is actual end of season
            pkl_fname (optional [str]): example - 'scoreboards_2015-16.pkl'

        Returns:
             topp (list): dicts

         Examples:
            a = NBAComAgent()
            topp = a.team_opponents('2014-15')

        '''

        topp = []

        # figure out season_start, season end
        if season_start is None:
            days = self.nbas.season_dates('2014-15')
            season_start = dt.datetime.strftime(days[-1], '%Y-%m-%d')
        else:
            days = date_list(season_end, season_start)

        for day in reversed(days):
            content = self.scraper.team_opponent_dashboard(season, DateFrom=season_start, DateTo=day)
            teamstats_opp = self.parser.team_opponent_dashboard(content)

            for team in teamstats_opp:
                fixed_team = {k.lower():v for k,v in team.iteritems()}
                fixed_team['game_date'] = dt.datetime.strftime(day, '%Y-%m-%d')
                topp.append(fixed_team)

        if pkl_fname:
            try:
                with open(pkl_fname, 'wb') as outfile:
                    pickle.dump(topp, outfile)

            except:
                self.logger.error('could not save scoreboards to {0}'.format(pkl_fname))

        return topp
Ejemplo n.º 9
0
def main():

    logging.basicConfig(stream=sys.stdout, level=logging.INFO)

    config = ConfigParser()
    configfn = os.path.join(os.path.expanduser('~'), '.pgcred')
    config.read(configfn)
    nbapg = NBAComPg(username=config['nbadb']['username'],
                    password=config['nbadb']['password'],
                    database=config['nbadb']['database'])
    flpg = FantasyLabsNBAPg(username=config['nbadb']['username'],
                    password=config['nbadb']['password'],
                    database=config['nbadb']['database'])
    fla = FantasyLabsNBAAgent(db=flpg, cache_name='flabs-nba', cookies=browsercookie.firefox())
    rgurua = RotoGuruNBAAgent(db=nbapg, cache_name='rg-nba')
    cn = 'nba-agent-{}'.format(today())
    a = NBAComAgent(cache_name=cn, cookies=None, db=nbapg)
    a.scraper.delay = 1
    season = '2016-17'

    # ensures players table is up-to-date before inserting gamelogs, etc.
    logging.info('starting update nba.com players')
    players = a.new_players(season[0:4])
    logging.info('finished update nba.com players')

    # gets all missing (days) salaries from current seasons
    logging.info('starting dfs salaries')
    fla.salaries(all_missing=True)
    rgurua.salaries(all_missing=True)
    logging.info('finished dfs salaries')

    # ensures that player_xref table includes all players from salaries
    #logging.info('starting update player_xref')
    #fla.update_player_xref()
    #logging.info('finished update player_xref')

    # gets model from fantasylabs
    #td = today('fl')
    #mn = 'phan'
    #flpg.insert_models([{
    #    'game_date': today('fl'),
    #    'data': fla.scraper.model(model_day=td, model_name=mn),
    #    'model_name': mn}])

    # gets ownership data from fantasylabs
    #logging.info('starting dfs ownership')
    #fla.ownership(all_missing=True)
    #logging.info('finished dfs ownership')

    # gets data from rotogrinders
    #logging.info('starting rotogrinders')
    #rs = RotoGrindersNBAScraper()
    #rp = RotoGrindersNBAParser()
    #rdb = RotoGrindersNBAPg(username=config['nbadb']['username'],
    #                password=config['nbadb']['password'],
    #                database=config['nbadb']['database'])
    #jsonstr = rp.odds(rs.odds())
    #rdb.insert_odds(today(), json.loads(jsonstr))
    #logging.info('finished rotogrinders')

    # player_gamelogs
    logging.info('starting nba.com player gamelogs')
    a.player_gamelogs(season)
    logging.info('finished nba.com player gamelogs')

    # playerstats_daily
    logging.info('starting playerstats daily')
    ps = a.playerstats(season, all_missing=True)
    logging.info('finished playerstats daily')

    # player_boxscores_combined
    logging.info('starting player_boxscores_combined')
    pbs = a.player_boxscores_combined()
    logging.info('finished player_boxscores_combined')

    # update team_gamelogs
    logging.info('starting team gamelogs')
    a.team_gamelogs(season)
    logging.info('finished team gamelogs')

    # teamstats_daily
    logging.info('starting teamstats daily')
    a.teamstats(season, all_missing=True)
    logging.info('finished teamstats daily')

    # team_boxscores_combined
    logging.info('start team_boxscores_combined')
    tbs = a.team_boxscores_combined()
    logging.info('finished team_boxscores_combined')

    # team_opponent_dashboards
    logging.info('start team_opponent_dashboards')
    a.team_opponent_dashboards(season, all_missing=True)
    logging.info('finished team_opponent_dashboards')

    # v2015 boxscores - linescores, refs, etc.
    logging.info('start linescores')
    a.linescores()
    logging.info('finished linescores')


    # odds and lines
    logging.info('start odds and lines')
    dba = DonBestNBAAgent(db=nbapg)
    odds = dba.odds(all_missing=True)
    logging.debug(odds)
    logging.info('finished odds and lines')

    # refresh all materialized views
    logging.info('start refresh materialized queries')
    nbapg.refresh_materialized()
    logging.info('refreshed materialized queries')