plugin.py

""" Limnoria plugin to retrieve results from NBA.com using their
(undocumented) JSON API.
"""
###
# Copyright (c) 2018, Santiago Gil
#
#     This program is free software: you can redistribute it and/or modify
#     it under the terms of the GNU General Public License as published by
#     the Free Software Foundation, either version 3 of the License, or
#     (at your option) any later version.
#
#     This program is distributed in the hope that it will be useful,
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#     GNU General Public License for more details.
#
#     You should have received a copy of the GNU General Public License
#     along with this program.  If not, see <http://www.gnu.org/licenses/>.
###

#import supybot.utils as utils
#from supybot.commands import *
from supybot.commands import optional, wrap

#import supybot.plugins as plugins
import supybot.ircutils as ircutils
import supybot.callbacks as callbacks
try:
    from supybot.i18n import PluginInternationalization
    _ = PluginInternationalization('NBA')
except ImportError:
    # Placeholder that allows to run the plugin on a bot
    # without the i18n module
    _ = lambda x: x

import datetime
import dateutil.parser
import httplib2
import json
import pytz
from xml.etree import ElementTree

class NBA(callbacks.Plugin):
    """Get scores from NBA.com."""

    _ENDPOINT_BASE_URL = 'https://data.nba.net'

    _SCOREBOARD_ENDPOINT = (_ENDPOINT_BASE_URL
                            + '/10s/prod/v2/{}/'
                            + 'scoreboard.json')

    _TODAY_ENDPOINT = (_ENDPOINT_BASE_URL
                       + '/prod/v3/today.json')

    _FUZZY_DAYS = frozenset(('yesterday', 'tonight',
                             'today', 'tomorrow'))

    _TEAM_TRICODES = frozenset(('CHA', 'ATL', 'IND', 'MEM', 'DET',
                                'UTA', 'CHI', 'TOR', 'CLE', 'OKC',
                                'DAL', 'MIN', 'BOS', 'SAS', 'MIA',
                                'DEN', 'LAL', 'PHX', 'NOP', 'MIL',
                                'HOU', 'NYK', 'ORL', 'SAC', 'PHI',
                                'BKN', 'POR', 'GSW', 'LAC', 'WAS'))

    def __init__(self, irc):
        self.__parent = super(NBA, self)
        self.__parent.__init__(irc)

        self._http = httplib2.Http('.cache')

    def nba(self, irc, msg, args, optional_team, optional_date):
        """[<TTT>] [<YYYY-MM-DD>]

        Get games for a given date. If none is specified, return
        games scheduled for today. Optionally add team abbreviation
        to filter for a specific team.
        """

        # Check to see if there's optional input and if there is check
        # if it's a date or a team, or both.
        try:
            team, date = self._parseOptionalArguments(optional_team,
                                                      optional_date)
        except ValueError as error:
            irc.error(str(error))
            return

        try:
            games = self._getTodayGames() if date is None \
                    else self._getGamesForDate(date)
        except ConnectionError as error:
            irc.error('Could not connect to nba.com')
            return
        except:
            irc.error('Something went wrong')
            return

        games = self._filterGamesWithTeam(team, games)

        games_string = self._resultAsString(games)

        # Single game query? We can show some extra info.
        if len(games) == 1:
            game = games[0]

            # If the game has ended, we fetch the recap info from NBA.com:
            if game['ended']:
                try:
                    recap = self._getRecapInfo(game)
                    games_string += ' | {} {}'.format(ircutils.bold('Recap:'),
                                                      recap)
                except:
                    pass

            else:
                # Otherwise, when querying a specific game in progress,
                # we show the broadcaster list.
                # Also, if it has a text nugget, and it's not
                # 'Watch live', we show it:
                broadcasters = game['tv_broadcasters']
                broadcasters_string = self._broadcastersToString(broadcasters)
                games_string += ' [{}]'.format(broadcasters_string)

                nugget = game['text_nugget']
                nugget_is_interesting = nugget and 'Watch live' not in nugget
                if nugget_is_interesting:
                    games_string += ' | {}'.format(nugget)

        irc.reply(games_string)

    nba = wrap(nba, [optional('somethingWithoutSpaces'),
                     optional('somethingWithoutSpaces')])

    def tv(self, irc, msg, args, team):
        """[<TTT>]

        Given a team, if there is a game scheduled for today,
        return where it is being broadcasted.
        """
        try:
            team = self._parseTeamInput(team)
        except ValueError as error:
            irc.error(str(error))
            return

        games = self._filterGamesWithTeam(team, self._getTodayGames())

        if not games:
            irc.reply('{} is not playing today.'.format(team))
            return

        game = games[0]
        game_string = self._gameToString(game)
        broadcasters_string = self._broadcastersToString(game['tv_broadcasters'])
        irc.reply('{} on: {}'.format(game_string, broadcasters_string))

    tv = wrap(tv, ['somethingWithoutSpaces'])

    def next(self, irc, msg, args, n, team, team2):
        """[<n>] <TTT> [<TTT>]

        Get the next <n> games (1 by default; max. 10) for a given team
        or, if two teams are provided, matchups between them.

        """
        MAX_GAMES_IN_RESULT = 10

        try:
            if team == team2:
                irc.error('Both teams should be different.')
                return

            team = self._parseTeamInput(team)
            if team2 is not None:
                team2 = self._parseTeamInput(team2)

            team_schedule = self._getTeamSchedule(team)
        except ValueError as error:
            irc.error(str(error))
            return

        last_played = team_schedule['lastStandardGamePlayedIndex']

        # Keeping only the games that haven't been played:
        future_games = team_schedule['standard'][last_played+1:]

        if n is None:
            n = 1
        end = min(MAX_GAMES_IN_RESULT, n, len(future_games)-1)

        if team2 is None:
            games = future_games
        else:
            # Filtering matchups between team and team2:
            team2_id = self._tricodeToTeamId(team2)
            games = [g for g in future_games \
                     if team2_id in [g['vTeam']['teamId'],
                                     g['hTeam']['teamId']]]

        if not games:
            irc.error('I could not find future games.')
            return

        for game in games[:end]:
            irc.reply(self._upcomingGameToString(game))


    next = wrap(next, [optional('positiveInt'),
                       'somethingWithoutSpaces',
                       optional('somethingWithoutSpaces')])

    def last(self, irc, msg, args, n, team, team2):
        """[<n>] <TTT> [<TTT>]

        Get the last <n> games (1 by default; max. 10) for a given team
        or, if two teams are provided, matchups between them.

        """
        MAX_GAMES_IN_RESULT = 10

        try:
            if team == team2:
                irc.error('Both teams should be different.')
                return

            team = self._parseTeamInput(team)
            if team2 is not None:
                team2 = self._parseTeamInput(team2)

            team_schedule = self._getTeamSchedule(team)
        except ValueError as error:
            irc.error(str(error))
            return

        last_played = team_schedule['lastStandardGamePlayedIndex']

        # Keeping only the games that have been played:
        team_past_games = team_schedule['standard'][:last_played+1]

        # Making sure the number of games we will show is a valid one:
        if n is None:
            n = 1
        n = min(MAX_GAMES_IN_RESULT, n)

        if team2 is None:
            games = team_past_games
        else:
            # Filtering matchups between team and team2:
            team2_id = self._tricodeToTeamId(team2)
            games = [g for g in team_past_games \
                     if team2_id in [g['vTeam']['teamId'],
                                     g['hTeam']['teamId']]]

        if not games:
            irc.error('I could not find past games.')
            return

        for game in reversed(games[-n:]): # Most-recent game first.
            irc.reply(self._pastGameToString(game))


    last = wrap(last, [optional('positiveInt'),
                       'somethingWithoutSpaces',
                       optional('somethingWithoutSpaces')])

    @classmethod
    def _parseOptionalArguments(cls, optional_team, optional_date):
        """Parse the optional arguments, which could be None, and return
        a (team, date) tuple. In case of finding an invalid argument, it
        throws a ValueError exception.
        """
        # No arguments:
        if optional_team is None:
            return (None, None)

        # Both arguments:
        if (optional_date is not None) and (optional_team is not None):
            team = cls._parseTeamInput(optional_team)
            date = cls._parseDateInput(optional_date)
            return (team, date)

        # Only one argument:
        if cls._isPotentialDate(optional_team):
            # Should be a date.
            team = None
            date = cls._parseDateInput(optional_team)
        else:
            # Should be a team.
            team = cls._parseTeamInput(optional_team)
            date = None

        return (team, date)

    def _getTodayGames(self):
        return self._getGames(self._getTodayDate())

    def _getGamesForDate(self, date):
        return self._getGames(date)

    @staticmethod
    def _filterGamesWithTeam(team, games):
        """Given a list of games, return those that involve a given
        team. If team is None, return the list with no modifications.
        """
        if team is None:
            return games

        return [g for g in games if team == g['home_team']
                or team == g['away_team']]

############################
# Content-getting helpers
############################
    def _getTodayJSON(self):
        today_url = self._ENDPOINT_BASE_URL + '/10s/prod/v3/today.json'
        return self._getJSON(today_url)

    def _getGames(self, date):
        """Given a date, populate the url with it and try to download
        its content. If successful, parse the JSON data and extract the
        relevant fields for each game. Returns a list of games.
        """
        url = self._getEndpointURL(date)

        # If asking for today's results, revalidate the cached data.
        # ('If-Mod.-Since' flag.). This allows to get real-time scores.
        revalidate_cache = (date == self._getTodayDate())
        response = self._getURL(url, revalidate_cache)

        json_data = self._extractJSON(response)

        return self._parseGames(json_data)

    @classmethod
    def _getEndpointURL(cls, date):
        return cls._SCOREBOARD_ENDPOINT.format(date)

    def _getTeamSchedule(self, tricode):
        """Fetch the json with the given team's schedule"""

        # First we fetch `today.json` to extract the path to teams'
        # schedules and `seasonScheduleYear`:
        today_json = self._getTodayJSON()
        schedule_path = today_json['links']['teamScheduleYear2']
        season_year = today_json['seasonScheduleYear']

        # We also need to convert the `tricode` to a `team_id`:
        team_id = self._tricodeToTeamId(tricode)

        # (The path looks like this:
        # '/prod/v1/{{seasonScheduleYear}}/teams/{{teamId}}/schedule.json')

        # Now we can fill-in the url:
        schedule_path = schedule_path.replace('{{teamId}}', team_id)
        schedule_path = schedule_path.replace('{{seasonScheduleYear}}',
                                              str(season_year))

        return self._getJSON(self._ENDPOINT_BASE_URL + schedule_path)['league']

    def _tricodeToTeamId(self, tricode):
        """Given a valid team tricode, get the `teamId` used in NBA.com"""

        teams_path = self._getJSON(self._TODAY_ENDPOINT)['links']['teams']
        teams_json = self._getJSON(self._ENDPOINT_BASE_URL + teams_path)

        for team in teams_json['league']['standard']:
            if team['tricode'] == tricode:
                return team['teamId']

        raise ValueError('{} is not a valid tricode'.format(tricode))

    def _teamIdToTricode(self, team_id):
        """Given a valid teamId, get the team's tricode"""

        teams_path = self._getJSON(self._TODAY_ENDPOINT)['links']['teams']
        teams_json = self._getJSON(self._ENDPOINT_BASE_URL + teams_path)

        for team in teams_json['league']['standard']:
            if team['teamId'] == team_id:
                return team['tricode']

        raise ValueError('{} is not a valid teamId'.format(team_id))

    def _getURL(self, url, force_revalidation=False):
        """Use httplib2 to download the URL's content.

        The `force_revalidation` parameter forces the data to be
        validated before being returned from the cache.
        In the worst case the data has not changed in the server,
        and we get a '304 - Not Modified' response.
        """
        user_agent = 'Mozilla/5.0 \
                      (X11; Ubuntu; Linux x86_64; rv:45.0) \
                      Gecko/20100101 Firefox/45.0'
        header = {'User-Agent': user_agent}

        if force_revalidation:
            header['Cache-Control'] = 'max-age=0'

        response, content = self._http.request(url, 'GET', headers=header)

        if response.fromcache:
            self.log.debug('%s - 304/Cache Hit', url)

        if response.status == 200:
            return content

        self.log.error('HTTP Error (%s): %s', url, error.code)
        raise ConnectionError('Could not access URL')

    @staticmethod
    def _extractJSON(body):
        return json.loads(body)

    def _getJSON(self, url):
        """Fetch `url` and return its contents decoded as json."""
        return self._extractJSON(self._getURL(url))

    @classmethod
    def _parseGames(cls, json_data):
        """Extract all relevant fields from NBA.com's scoreboard.json
        and return a list of games.
        """
        games = []
        for g in json_data['games']:
            # Starting times are in UTC. By default, we will show
            # Eastern times.
            # (In the future we could add a user option to select
            # timezones.)
            try:
                starting_time = cls._ISODateToEasternTime(g['startTimeUTC'])
            except:
                starting_time = 'TBD' if g['isStartTimeTBD'] else ''

            game_info = {'game_id': g['gameId'],
                         'home_team': g['hTeam']['triCode'],
                         'away_team': g['vTeam']['triCode'],
                         'home_score': g['hTeam']['score'],
                         'away_score': g['vTeam']['score'],
                         'starting_year': g['startDateEastern'][0:4],
                         'starting_month': g['startDateEastern'][4:6],
                         'starting_day': g['startDateEastern'][6:8],
                         'starting_time': starting_time,
                         'starting_time_TBD': g['isStartTimeTBD'],
                         'clock': g['clock'],
                         'period': g['period'],
                         'buzzer_beater': g['isBuzzerBeater'],
                         'ended': (g['statusNum'] == 3),
                         'text_nugget': g['nugget']['text'].strip(),
                         'tv_broadcasters': cls._extractGameBroadcasters(g)
                        }

            games.append(game_info)

        return games

    @staticmethod
    def _extractGameBroadcasters(game_json):
        """Extract the list of broadcasters from the API.
        Return a dictionary of broadcasts:
        (['vTeam', 'hTeam', 'national', 'canadian']) to
        the short name of the broadcaster.
        """
        json_data = game_json['watch']['broadcast']['broadcasters']
        game_broadcasters = dict()

        for category in json_data:
            broadcasters_list = json_data[category]
            if broadcasters_list and 'shortName' in broadcasters_list[0]:
                game_broadcasters[category] = broadcasters_list[0]['shortName']
        return game_broadcasters

############################
# Formatting helpers
############################
    @classmethod
    def _resultAsString(cls, games):
        if not games:
            return "No games found"

        # sort games list and put F(inal) games at end
        sorted_games = sorted(games, key=lambda k: k['ended'])
        return ' | '.join([cls._gameToString(g) for g in sorted_games])

    @classmethod
    def _gameToString(cls, game):
        """ Given a game, format the information into a string
        according to the context.

        For example:
        * "MEM @ CLE 07:00 PM ET" (a game that has not started yet),
        * "HOU 132 GSW 127 F OT2" (a game that ended and went to 2
        overtimes),
        * "POR 36 LAC 42 8:01 Q2" (a game in progress).
        """
        away_team = game['away_team']
        home_team = game['home_team']

        if game['period']['current'] == 0: # The game hasn't started yet
            starting_time = game['starting_time'] \
                            if not game['starting_time_TBD'] \
                            else "TBD"
            return "{} @ {} {}".format(away_team, home_team, starting_time)

        # The game started => It has points:
        away_score = game['away_score']
        home_score = game['home_score']

        away_string = "{} {}".format(away_team, away_score)
        home_string = "{} {}".format(home_team, home_score)

        # Bold for the winning team:
        if int(away_score) > int(home_score):
            away_string = ircutils.bold(away_string)
        elif int(home_score) > int(away_score):
            home_string = ircutils.bold(home_string)

        game_string = "{} {} {}".format(away_string, home_string,
                                        cls._clockBoardToString(game['clock'],
                                                                game['period'],
                                                                game['ended']))
        # Highlighting 'buzzer-beaters':
        if game['buzzer_beater'] and not game['ended']:
            game_string = ircutils.mircColor(game_string, fg='yellow',
                                             bg='black')

        return game_string

    @classmethod
    def _clockBoardToString(cls, clock, period, game_ended):
        """Get a string with current period and, if the game is still
        in progress, the remaining time in it.
        """
        period_number = period['current']
        # Game hasn't started => There is no clock yet.
        if period_number == 0:
            return ''

        # Halftime
        if period['isHalftime']:
            return ircutils.mircColor('Halftime', 'orange')

        period_string = cls._periodToString(period_number)

        # Game finished:
        if game_ended:
            if period_number == 4:
                return ircutils.mircColor('F', 'red')

            return ircutils.mircColor("F {}".format(period_string), 'red')

        # Game in progress:
        if period['isEndOfPeriod']:
            return ircutils.mircColor("E{}".format(period_string), 'blue')

        # Period in progress, show clock:
        return "{} {}".format(clock, ircutils.mircColor(period_string,
                                                        'green'))

    @staticmethod
    def _periodToString(period):
        """Get a string describing the current period in the game.

        Period is an integer counting periods from 1 (so 5 would be
        OT1).
        The output format is as follows: {Q1...Q4} (regulation);
        {OT, OT2, OT3...} (overtimes).
        """
        if period <= 4:
            return "Q{}".format(period)

        ot_number = period - 4
        if ot_number == 1:
            return "OT"
        return "OT{}".format(ot_number)

    @staticmethod
    def _broadcastersToString(broadcasters):
        """Given a broadcasters dictionary (category->name), where
        category is in ['vTeam', 'hTeam', 'national', 'canadian'],
        return a printable string representation of that list.
        """
        items = []
        for category in ['vTeam', 'hTeam', 'national', 'canadian']:
            if category in broadcasters:
                items.append(broadcasters[category])
        return ', '.join(items)

    def _upcomingGameToString(self, game):
        """Given a team's upcoming game, return a string with
        the opponent's tricode and the date of the game.
        """

        date = self._ISODateToEasternDatetime(game['startTimeUTC'])

        home_tricode = self._teamIdToTricode(game['hTeam']['teamId'])
        away_tricode = self._teamIdToTricode(game['vTeam']['teamId'])

        if game['isHomeTeam']:
            home_tricode = ircutils.bold(home_tricode)
        else:
            away_tricode = ircutils.bold(away_tricode)

        return '{} | {} @ {}'.format(date, away_tricode, home_tricode)

    def _pastGameToString(self, game):
        """Given a team's upcoming game, return a string with
        the opponent's tricode and the result.
        """
        date = self._ISODateToEasternDate(game['startTimeUTC'])

        home_tricode = self._teamIdToTricode(game['hTeam']['teamId'])
        away_tricode = self._teamIdToTricode(game['vTeam']['teamId'])

        home_score = int(game['hTeam']['score'])
        away_score = int(game['vTeam']['score'])

        if game['isHomeTeam']:
            was_victory = (home_score > away_score)
        else:
            was_victory = (away_score > home_score)

        if home_score > away_score:
            home_tricode = ircutils.bold(home_tricode)
            home_score = ircutils.bold(home_score)
        else:
            away_tricode = ircutils.bold(away_tricode)
            away_score = ircutils.bold(away_score)

        result = ircutils.mircColor('W', 'green') if was_victory \
                 else ircutils.mircColor('L', 'red')

        points = '{} {} {} {}'.format(away_tricode, away_score,
                                      home_tricode, home_score)

        if game['seasonStageId'] == 1:
            points += ' (Preseason)'

        return '{} {} | {}'.format(date, result, points)

############################
# Date-manipulation helpers
############################
    @classmethod
    def _getTodayDate(cls):
        """Get the current date formatted as "YYYYMMDD".
        Because the API separates games by day of start, we will
        consider and return the date in the Pacific timezone.
        The objective is to avoid reading future games anticipatedly
        when the day rolls over at midnight, which would cause us to
        ignore games in progress that may have started on the previous
        day.
        Taking the west coast time guarantees that the day will advance
        only when the whole continental US is already on that day.
        """
        today = cls._pacificTimeNow().date()
        today_iso = today.isoformat()
        return today_iso.replace('-', '')

    @staticmethod
    def _easternTimeNow():
        return datetime.datetime.now(pytz.timezone('US/Eastern'))

    @staticmethod
    def _pacificTimeNow():
        return datetime.datetime.now(pytz.timezone('US/Pacific'))

    @staticmethod
    def _ISODateToEasternDate(iso):
        """Convert the ISO date in UTC time that the API outputs into an
        Eastern-time date.
        (The default human-readable format for the listing of games).
        """
        date = dateutil.parser.parse(iso)
        date_eastern = date.astimezone(pytz.timezone('US/Eastern'))
        eastern_date = date_eastern.strftime('%a %m/%d')
        return "{}".format(eastern_date)

    @staticmethod
    def _ISODateToEasternTime(iso):
        """Convert the ISO date in UTC time that the API outputs into an
        Eastern time formatted with am/pm.
        (The default human-readable format for the listing of games).
        """
        date = dateutil.parser.parse(iso)
        date_eastern = date.astimezone(pytz.timezone('US/Eastern'))
        eastern_time = date_eastern.strftime('%-I:%M %p')
        return "{} ET".format(eastern_time)

    @staticmethod
    def _ISODateToEasternDatetime(iso):
        """Convert the ISO date in UTC time that the API outputs into a
        string with a date and Eastern time formatted with am/pm.
        """
        date = dateutil.parser.parse(iso)
        date_eastern = date.astimezone(pytz.timezone('US/Eastern'))
        eastern_datetime = date_eastern.strftime('%a %m/%d, %I:%M %p')
        return "{} ET".format(eastern_datetime)

    @staticmethod
    def _stripDateSeparators(date_string):
        return date_string.replace('-', '')

    @classmethod
    def _EnglishDateToDate(cls, date):
        """Convert a human-readable like 'yesterday' to a datetime
        object and return a 'YYYYMMDD' string.
        """
        if date == 'yesterday':
            day_delta = -1
        elif date == 'today' or date == 'tonight':
            day_delta = 0
        elif date == 'tomorrow':
            day_delta = 1
        # Calculate the day difference and return a string
        date_string = (cls._pacificTimeNow() +
                       datetime.timedelta(days=day_delta)).strftime('%Y%m%d')
        return date_string

    @classmethod
    def _isValidTricode(cls, team):
        return team in cls._TEAM_TRICODES

############################
# Input-parsing helpers
############################
    @classmethod
    def _isPotentialDate(cls, string):
        """Given a user-provided string, check whether it could be a
        date.
        """
        return (string.lower() in cls._FUZZY_DAYS or
                string.replace('-', '').isdigit())

    @classmethod
    def _parseTeamInput(cls, team):
        """Given a user-provided string, try to extract an upper-case
        team tricode from it. If not valid, throws a ValueError
        exception.
        """
        t = team.upper()
        if not cls._isValidTricode(t):
            raise ValueError('{} is not a valid team'.format(team))
        return t

    @classmethod
    def _parseDateInput(cls, date):
        """Verify that the given string is a valid date formatted as
        YYYY-MM-DD. Also, the API seems to go back until 2014-10-04,
        so we will check that the input is not a date earlier than that.
        In case of failure, throws a ValueError exception.
        """
        date = date.lower()

        if date in cls._FUZZY_DAYS:
            date = cls._EnglishDateToDate(date)

        elif date.replace('-', '').isdigit():
            try:
                parsed_date = datetime.datetime.strptime(date, '%Y-%m-%d')
            except:
                raise ValueError('Incorrect date format, should be YYYY-MM-DD')

            # The current API goes back until 2014-10-04. Is it in range?
            if parsed_date.date() < datetime.date(2014, 10, 4):
                raise ValueError('I can only go back until 2014-10-04')
        else:
            raise ValueError('Date is not valid')

        return cls._stripDateSeparators(date)


    def _getRecapInfo(self, game):
        """Given a finished game, fetch its recap summary and a link
        to its video recap. It returns a string with the format
        '{summary} (link to video)'.

        The link is shortened by calling _shortenURL(str) -> str.
        """

        recap_base_url = 'https://www.nba.com/video/'\
                         '{year}/{month}/{day}/'\
                         '{game_id}-{away_team}-{home_team}-recap.xml'

        url = recap_base_url.format(year=game['starting_year'],
                                    month=game['starting_month'],
                                    day=game['starting_day'],
                                    game_id=game['game_id'],
                                    away_team=game['away_team'].lower(),
                                    home_team=game['home_team'].lower())

        xml = self._getURL(url)
        tree = ElementTree.fromstring(xml)

        res = []

        summary = tree.find('description')
        if summary is not None:
            res.append(summary.text)

        video_recap = tree.find("*file[@bitrate='1920x1080_5904']")
        if video_recap is not None:
            url = self._shortenURL(video_recap.text)
            res.append('({})'.format(url))

        return ' '.join(res)

    @staticmethod
    def _shortenURL(url):
        """ Run a link through an URL shortener and return the new url."""

        # Complete with the code that uses your desired
        # shortener service.
        return url


Class = NBA

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79: