コード例 #1
0
ファイル: league_gen.py プロジェクト: scrbrd/scoreboard
def generate_league(league_name, players):
    player_ids = [p.id for p in players]
    if not player_ids:
        player_ids.append(95)
    league = League.create_league(
            league_name,
            random.choice(player_ids),
            player_ids)

    loaded_league = League.load_opponents(league.id)
    if loaded_league is not None:
        print("League ({0}) created successfully.".format(loaded_league.id))

    return loaded_league
コード例 #2
0
ファイル: schedule_gen.py プロジェクト: scrbrd/scoreboard
    played_ids = [opponent_ids[n] for n in range(0, number_of_players)]
    results = _prepare_result(played_ids, played)

    return _create_game(league_id, creator_id, results, sport_id)


def generate_competitive_game(league_id, opponent_ids):
    won = "won"
    lost = "lost"
    number_of_winners = random.randint(1, 4)
    number_of_losers = random.randint(1, 4)

    (creator_id, opponent_ids, sport_id) = _prepare_game_creation(opponent_ids)

    won_ids = [opponent_ids[n] for n in range(0, number_of_winners)]
    lost_ids = [opponent_ids[n] for n in range(
            number_of_winners, number_of_winners + number_of_losers)]

    won_results = _prepare_result(won_ids, won)
    lost_results = _prepare_result(lost_ids, lost)
    results = dict(won_results.items() + lost_results.items())

    return _create_game(league_id, creator_id, results, sport_id)


if __name__ == "__main__":
    league_id = int(sys.argv[1])
    print "Creating schedule for League {0}.".format(league_id)
    league = League.load_opponents(league_id)
    schedule = generate_schedule(league)
コード例 #3
0
ファイル: league.py プロジェクト: scrbrd/scoreboard
    def load(self):
        """ Populate context, aggregations, objects, and opponents. """

        # TODO: we should be able to do all this in one or two queries. given
        # player id, traverse to a league. from there get games and opponents
        # for those games. the only tricky thing is just getting one league. it
        # shouldn't be tricky to avoid manually loading opponents.

        person = Person.load_leagues(self.session.person_id)

        league = None
        if self._league_id is None:
            # if no league was requested than get the first league
            league = person.get_leagues().values()[0]
        else:
            league = person.get_leagues().get(self._league_id)
        # TODO: if league is None than throw some 'request invalid league
        # error'

        # TODO: we don't need to load Games from League when they can be loaded
        # from Opponents [or the vice-versa] all at the same time. we should
        # never be calling set_opponents() and set_games() outside the api.

        # RANKINGS LOAD
        opponents_list = League.load_opponents(league.id).get_opponents()
        league.set_opponents({o.id: o for o in opponents_list})

        # GAMES LOAD (WITH OPPONENTS AND COMMENTERS)
        games_list = League.load_games(league.id).get_games()

        # TODO: iterating through this list is only temporary becaue the
        # multiload should have happened in the api.
        game_ids = [g.id for g in games_list]

        # load opponents and commenters and creator for each game {g_id: Game}
        games_dict = Game.multiload_important_persons(game_ids)

        # load league with opponents and games into generic context
        league.set_games(games_dict)
        self._context = league

        # league's opponents by Win Count
        # store the list because the league has a dict, and sort returns None
        opponents = self._context.get_opponents()
        opponents.sort(
                key=lambda x: x.win_count,
                reverse=True)
        self._aggregations["standings"] = opponents
        self._aggregations["activity"] = None

        # store opponents loaded games in reverse order (so it's new first)
        games = games_dict.values()
        # sort returns None as it's in-place
        games.sort(
                key=lambda x: x.created_ts,
                reverse=True)
        self._objects = games

        # load opponents into rivals as well
        self._rivals = self._context.get_opponents()

        # load the list of sports
        self._sports = SPORT.ALL