def _init_managers(self): live_data_parser = LiveDataParser(self._current_event) threads = list( map( lambda id_: TransfersManager(id_, self._current_event, live_data_parser), self.__ids)) return threads
def __init__(self, ids_file, league_name="", league_id=-1, managers_count=-1): [self.__current_event, self.__gw_name, self.__is_dgw] = get_gw_info() self.__ids = read_ids(ids_file, league_id, managers_count) self.__live_data_parser = LiveDataParser(self.__current_event, self.__is_dgw) self.__managers = self.__init_managers() self.__init_each_manager_players_played() self.__output = [] # A list which stores the whole output self.__output_file = set_output_file(self.__current_event, "rivals", ids_file, league_name, league_id)
def __init_managers(self): threads = [] gw = 1 for i in range(gw, self.__current_event + 1): live_data_parser = LiveDataParser(i) manager = AutosubsManager(team_id=self.__id, current_event=i, live_data_parser=live_data_parser) threads.append(manager) return threads
def _init_managers(self): threads = [] gw_one = 1 for i in range(gw_one, self._current_event + 1): live_data_parser = LiveDataParser(i) manager = TransfersManager(team_id=self.__id_, current_event=i, live_data_parser=live_data_parser) threads.append(manager) return threads
def __init_managers(self): threads = [] gw = 1 for i in range(gw, self.__current_event + 1): live_data_parser = LiveDataParser(i) self.__live_data_parsers.append(live_data_parser) threads.append( ClassicManager(team_id=self.__id, current_event=i, is_dgw=False, live_data_parser=live_data_parser)) return threads
class HthAnalyzer(ABC): _current_event = get_current_event() _players_names = {} _live_data_parser = LiveDataParser(_current_event) _wins = _draws = _losses = 0 def __init__(self, team_id, set_leagues): self._id = team_id # Create our manager and start it (because it's a thread) self._team = HthManager(self._id, self._current_event, set_leagues) self._team.start() self._team.join() self.__manager_name = self._team.manager_name.split(" ")[0] self._output = [] @abstractmethod def print_all_matchups(self): pass def save_output_to_file(self, output_file): save_output_to_file(output_file, "w", self._output) def _print_one_matchup(self, opponent): ((team_unique_players, team_points), (opp_unique_players, opp_points)) = \ self._list_of_unique_players_and_their_points(opponent) team_manager = self._team.manager_name opponent_manager = opponent.manager_name unique_players = ["{}: [{}] vs.".format(team_manager, team_unique_players), "{}: [{}]".format(opponent_manager, opp_unique_players)] log_list_of_strings(unique_players, self._output) if self._team.active_chip != "None" or opponent.active_chip != "None": active_chip = ["[Active chip]", "{} vs. {}".format(self._team.active_chip, opponent.active_chip)] log_list_of_strings(active_chip, self._output) hits_taken = ["[Hits taken]", "{}: {}".format(team_manager, self._team.gw_hits), "{}: {}".format(opponent_manager, opponent.gw_hits)] log_list_of_strings(hits_taken, self._output) different_players_points = ["[Points gained by different players]", "{}: {}".format(team_manager, team_points), "{}: {}".format(opponent_manager, opp_points)] log_list_of_strings(different_players_points, self._output) if self._team.gw_hits != opponent.gw_hits: hit_cost = 4 team_points -= self._team.gw_hits*hit_cost opp_points -= opponent.gw_hits*hit_cost # Take hits into account self._current_points_difference(team_points, opp_points) winner = self._define_winner(team_manager, team_points, opponent_manager, opp_points) winner_string = "[Winner: {}]\n".format(winner) log_string(winner_string, self._output) def _print_record(self): record = "[Record: {}W, {}D, {}L]\n".format(self._wins, self._draws, self._losses) log_string(record, self._output) print("Good luck, {}! :)".format(self.__manager_name)) def _list_of_unique_players_and_their_points(self, opponent): (team_unique_players, team_points) = self._unique_players_and_points(self._team.players_ids, opponent.players_ids, self._team.captain_id) (opp_unique_players, opp_points) = self._unique_players_and_points(opponent.players_ids, self._team.players_ids, opponent.captain_id) if self._team.captain_id == opponent.captain_id: (team_unique_players, points) = self._check_same_captains(self._team, opponent, team_unique_players) team_points += points (opp_unique_players, points) = self._check_same_captains(opponent, self._team, opp_unique_players) opp_points += points elif self._team.captain_id != opponent.captain_id: (team_unique_players, points) \ = self._check_different_captains(self._team, team_unique_players, opponent.players_ids) team_points += points (opp_unique_players, points) = \ self._check_different_captains(opponent, opp_unique_players, self._team.players_ids) opp_points += points final_result = ((team_unique_players, team_points), (opp_unique_players, opp_points)) return final_result def __find_different_ids(self, team_a, team_b): return team_a.difference(team_b) def _unique_players_and_points(self, team_a, team_b, captain_id): players_ids = self.__find_different_ids(team_a, team_b) def helper(): result = [] points = 0 for player_id in players_ids: if player_id == captain_id: continue curr_player_points = self._live_data_parser.get_player_points(player_id) if player_id in self._players_names: curr_player = "{}={}".format(self._players_names[player_id], curr_player_points) result.append(curr_player) else: player_name = self._team.event_data_parser.get_player_name(player_id) self._players_names[player_id] = player_name curr_player = "{}={}".format(player_name, curr_player_points) result.append(curr_player) points += curr_player_points unique_players = ", ".join(result) result = (unique_players, points) return result return helper() def _check_same_captains(self, team_a, team_b, unique_players): result = (unique_players, 0) if team_a.active_chip == "TC" and team_b.active_chip != "TC": captain_points = self._live_data_parser.get_player_points(self._team.captain_id) captain_formatted = ", {}={}".format(self._team.captain_name, captain_points) unique_players += captain_formatted result = (unique_players, captain_points) return result def _check_different_captains(self, team, unique_players, opponent_players_ids): captain_name = team.captain_name captain_points = self._live_data_parser.get_player_points(team.captain_id) if team.active_chip == "TC": if team.captain_id in opponent_players_ids: points_to_add = 2*captain_points multiplier = "X2" else: points_to_add = 3*captain_points multiplier = "X3" captain_name = ", {} {}={}".format(captain_name, multiplier, points_to_add) else: if team.captain_id in opponent_players_ids: points_to_add = captain_points captain_name = ", {}={}".format(captain_name, points_to_add) else: points_to_add = 2*captain_points captain_name = ", {} X2={}".format(captain_name, points_to_add) unique_players = "{}{}".format(unique_players, captain_name) result = (unique_players, points_to_add) return result def _current_points_difference(self, team_a_points, team_b_points): current_result = "trailing" if team_a_points < team_b_points else "leading" points_difference = abs(team_a_points - team_b_points) formatter = "point" if points_difference == 1 else "points" points_difference_string = "You're {} by: {} {}.".format(current_result, abs(team_a_points - team_b_points), formatter) log_string(points_difference_string, self._output) def _define_winner(self, team_a_manager, team_a_points, team_b_manager, team_b_points): if team_a_points > team_b_points: self._wins += 1 return team_a_manager elif team_a_points < team_b_points: self._losses += 1 return team_b_manager else: self._draws += 1 return "Draw!" @abstractmethod def _init_opponents_ids(self): pass @abstractmethod def _init_opponents(self): pass
class ClassicAnalyzer: __LAST_EVENT = 38 @performance def __init__(self, ids_file, league_name="", league_id=-1, managers_count=-1): [self.__current_event, self.__gw_name, self.__is_dgw] = get_gw_info() self.__ids = read_ids(ids_file, league_id, managers_count) self.__live_data_parser = LiveDataParser(self.__current_event, self.__is_dgw) self.__managers = self.__init_managers() self.__init_each_manager_players_played() self.__output = [] # A list which stores the whole output self.__output_file = set_output_file(self.__current_event, "rivals", ids_file, league_name, league_id) def print_table(self): self.__sort_managers() self.__format_managers_properties() self.__print_legend() self.__print_table_output() def print_stats(self): stats = ClassicAnalyzerStats(self.__managers, self.__current_event, self.__output_file) stats.stats_menu() stats.save_stats_output_to_file() def save_output_to_file(self): save_output_to_file(self.__output_file, "w", self.__output) def find_manager_id(self, name): for manager in self.__managers: if manager.manager_name == name: return manager.get_id() return -1 @start_threads def __init_managers(self): threads = list( map( lambda id_: ClassicManager(id_, self.__current_event, self. __is_dgw), self.__ids)) return threads def __init_each_manager_players_played(self): for manager in self.__managers: (sgw_players_count, dgw_players_info) = self.__live_data_parser.count_players_played( manager.players_ids) manager.format_players_played(sgw_players_count) if self.__is_dgw: manager.format_dgw_players_played(*dgw_players_info) def __sort_managers(self): """ menu returns an integer which indicates how the data is going to be sorted by: 1: total points 2: gameweek points 3: team value """ comparator = self.__menu() # sort the data if comparator[0] == 1: self.__managers.sort(key=attrgetter(comparator[1]), reverse=False) elif comparator[0] == 2: self.__managers.sort(key=cmp_to_key(ClassicManager.cmp_gw_pts)) else: self.__managers.sort(key=attrgetter(comparator[1]), reverse=True) """ # This method prints a menu and returns a tuple which contains: # user choice and a string associated with it """ def __menu(self): option = -1 result = (-1, "") options_number = {1, 2, 3} while option not in options_number: options = [ "* How do you want to sort the sample by:", "1) Total points", "2) Gameweek points", "3) Total team value" ] exception_msg = "\n[!] Please enter an *integer*: either 1, 2 or 3." option = select_option_from_menu(options, exception_msg) if option == -1: continue if option == 1: result = (1, "overall_rank") elif option == 2: result = (2, "gw_points") elif option == 3: result = (3, "team_value") else: print("\n[!] Invalid option. Try again!") return result def __format_managers_properties(self): row_num = 1 # format some of its columns for manager in self.__managers: manager.format_total_points_and_overall_rank() manager.format_gw_points() manager.row_num = row_num row_num += 1 def __init_headers(self): headers = [ "No", "Manager", "OR", "OP", "Used Chips", "{} P".format(self.__gw_name), "C".format(self.__gw_name), "VC".format(self.__current_event), "Chip".format(self.__current_event), "PP", "{} TM".format(self.__gw_name), "{} H".format(self.__gw_name), "TV", "Bank", "Tot" ] if self.__is_dgw: index = 10 headers.insert(index, "PP II") return headers def __print_legend(self): print() legend = [ "> Legend: ", "OR = Overall Rank, OP = Overall Points,\n" "C = Captain, VC = Vice Captain,\n" "PP = Players Played, TM = Transfers Made, H = Hit(s),\n" "TV = Team Value", "Tot = TV + Bank\n" ] for string in legend: log_string(string, self.__output) def __print_table_output(self): # tabulate requires a list of lists, so that's why it's needed list_of_lists = [manager.to_list() for manager in self.__managers] headers = self.__init_headers() # tablefmt="fancy_grid" table_output = tabulate(list_of_lists, headers=headers, tablefmt="orgtbl", floatfmt=".1f", numalign="center", stralign="center") log_string(table_output, self.__output) log_string("", self.__output) formatter = "entry" if len(self.__managers) < 2 else "entries" print("\n{} {} have been loaded successfully.".format( len(self.__managers), formatter))
class MiniLeagueAnalyzer: __current_event = get_current_event() __live_data_parser = LiveDataParser(__current_event) __ZARATA_LEAGUE_ID = 156718 __ELITE_64_LEAGUE_ID = 2379 __DEFAULT_SAVE_PATH = "csv" def __init__(self, ids_file, save_dir="", league_name="", league_id=-1): self.__managers_ids = self.__load_ids(league_id, ids_file) self.__config_zarata(league_id) self.__managers = self.__init_managers() self.__all_players_ids = self.__collect_players_ids() self.__all_players_names = self.__collect_players_data() self.__csv_data = self.__all_managers_to_list() [self.__save_dir, self.__save_path] = self.__set_save_path(ids_file, save_dir, league_name, league_id) def write_data_to_csv(self): # headers = ["Manager Name", # "Player 1", "Player 2", "Player 3", "Player 4", "Player 5", "Player 6", # "Player 7", "Player 8", "Player 9", "Player 10", "Player 11", # "Sub 1", "Sub 2", "Sub 3", "Sub 4"] Path(self.__save_dir).mkdir(parents=True, exist_ok=True) with open(self.__save_path, "w", newline="\n", encoding="utf-8") as csvfile: csvwriter = csv.writer(csvfile) #csvwriter.writerow(headers) csvwriter.writerows(zip(*self.__csv_data)) def __load_ids(self, league_id, ids_file): if league_id == -1: managers_ids = read_ids_from_file(ids_file) else: managers_ids = extract_teams_ids_from_league(league_id) # managers_ids = read_ids_from_file(ids_file) if league_id == -1 else extract_teams_ids_from_league(league_id) return managers_ids def __config_zarata(self, league_id): if league_id == self.__ZARATA_LEAGUE_ID: self.__managers_ids.sort() self.__managers_ids_sorted = self.__managers_ids self.__managers_ids = [115, 21074, 99, 1908330, 503269 ] # General, Sutherns, Will, Magnus, Dayvy for id_ in self.__managers_ids_sorted: self.__managers_ids.append(id_) @start_threads def __init_managers(self): threads = list( map(lambda id_: ClassicManager(id_, self.__current_event), self.__managers_ids)) return threads def __collect_players_ids(self): result = set() for manager in self.__managers: players_ids = manager.all_players_ids for player_id in players_ids: result.add(player_id) return result """ This method returns a dictionary, which values are: (player_name, player_points) """ def __collect_players_data(self): result = {} event_data_parser = EventDataParser(1, self.__current_event) for player_id in self.__all_players_ids: result[player_id] = ( event_data_parser.get_player_name(player_id), self.__live_data_parser.get_player_points(player_id), event_data_parser.get_player_team(player_id)) return result def __one_manager_to_list(self, manager, result): #result = [manager.manager_name] result[0].append(manager.manager_name) #manager.format_gw_points() #result[1].append(manager.gw_points_string) result_length = len(result) for i in range(1, result_length): result[i].append("\n") players_ids = manager.all_players_ids for player_id in players_ids: (player_name, player_points, player_team) = self.__all_players_names[player_id] if player_id == manager.captain_id: captain_points = self.__live_data_parser.get_player_points( player_id) if manager.active_chip != "TC": result[0].append(player_name) result[1].append(captain_points * 2) result[2].append("C") else: result[0].append(player_name) result[1].append(captain_points * 3) result[2].append("TC") else: if player_id == manager.vice_captain_id: result[0].append(player_name) result[2].append("VC") else: result[0].append(player_name) result[2].append("-") result[1].append( self.__live_data_parser.get_player_points(player_id)) result[3].append(player_team) [row.append("\n") for row in result] #return result def __all_managers_to_list(self): # col 1: players' names # col 2: players' points # col 3: - / c / vc # col 4: players' teams result = [[], [], [], []] for manager in self.__managers: #result.append(self.__manager_to_list(manager)) self.__one_manager_to_list(manager, result) return result def __set_save_path(self, ids_file, save_dir, league_name, league_id): save_dir = self.__DEFAULT_SAVE_PATH if save_dir == "" else save_dir csv_filename = league_name if league_id != -1 else extract_file_name_from_path( ids_file) save_path = "{}/{}_gw{}.csv".format(save_dir, csv_filename, self.__current_event) result = (save_dir, save_path) return result