def resolve_user(parent, info, id):
user = User(id)
league_info = user.get_all_leagues("nfl", 2020)
info_list = []
for i in league_info:
info = UserType.from_json(i)
info_list.append(info)
return info_list
def main(argv):
# Parse all of the user-provided flags
args = parse_user_provided_flags()
# Convert the computed args into our more-verbose local fields
account_username = args.username
league_year = args.year
position = args.position
team = args.team
output_format = args.output_format
league_regex = re.compile(args.league_regex)
# Retrieve the user and all of their leagues
admin_user = User(account_username)
all_leagues = admin_user.get_all_leagues("nfl", league_year)
# Map to store the drafted player results
player_id_to_drafted_player = {}
for league_object in all_leagues:
league = League(league_object.get("league_id"))
league_name = league.get_league().get("name")
# Only look at leagues that match the provided regex
if league_regex.match(league_name):
draft_id = league.get_league().get("draft_id")
draft = Drafts(draft_id)
for pick in draft.get_all_picks():
player_id = pick["player_id"]
if player_id in player_id_to_drafted_player.keys():
drafted_player = player_id_to_drafted_player.get(player_id)
else:
drafted_player = DraftedPlayer(
pick["player_id"], pick["metadata"]["first_name"],
pick["metadata"]["last_name"],
pick["metadata"]["position"], pick["metadata"]["team"])
player_id_to_drafted_player[player_id] = drafted_player
drafted_player.add_draft_position(pick["pick_no"])
# Print the results of all the parsing
print("")
for player_id in sorted(player_id_to_drafted_player,
key=player_id_to_drafted_player.get):
drafted_player = player_id_to_drafted_player[player_id]
if position != INCLUDE_ALL and drafted_player.position != position:
continue
if team != INCLUDE_ALL and drafted_player.team != team:
continue
print(create_output_for_player(drafted_player, output_format))
def main(argv):
args = parse_user_provided_flags()
user = args.username
year = args.year
league_regex = re.compile(args.league_regex)
week = args.week
include_covid = args.include_covid
include_missing = args.include_missing
# Retrieve the list of all inactive players
nfl_players = Players()
inactive_players = find_all_inactive_players_for_week(
nfl_players.get_all_players(), week, include_covid)
if include_missing:
# Empty starting slots fill in as id 0, so add an entry for that
# 0th player in order to report the empty spot
inactive_players.append(
Player("Missing Player", "0", "None", "MISSING", "NONE"))
# Retrieve all of the leagues
admin_user = User(user)
all_leagues = admin_user.get_all_leagues("nfl", year)
user_store = UserStore()
inactive_rosters = []
# Iterate through each league to find the inactive owners in each
for league_object in all_leagues:
league = League(league_object.get("league_id"))
league_name = league.get_league().get("name")
# Only look at leagues that match the provided regex
if league_regex.match(league_name):
user_store.store_users_for_league(league)
inactive_rosters.extend(
find_inactive_starters_for_league_and_week(
league, week, inactive_players, user_store))
# Print out the final inactive rosters
print("")
for roster in inactive_rosters:
print(roster)
def test_get_all_leagues(capsys):
user = User("78623389212098560")
leagues = user.get_all_leagues("nfl", 2019)
assert isinstance(leagues, list)
assert isinstance(leagues[0], dict)
user = User("swa")
leagues = user.get_all_leagues("nfl", 2019)
assert isinstance(leagues, list)
assert isinstance(leagues[0], dict)
def save_draft_information(user):
""" Save the draft information for the current year of YAFL
This function might change in the future. I think it's possible to get past draft data, if so then I can get
draft data from those without the need to save them. It might also be possible to get past draft data from the
user endpoint.
Currently this function gets the draft data from YAFL and saves it to a file /saved_drafts/draft_xxxx.json, where
xxxx is the year.
Args:
user (str): Username of a YAFL manager
"""
# Get the user object to get league info
user_obj = User(user)
# Get the league object. Will be used to get draft info.
league = get_league_id(user_obj)
season = league.get_league()['season']
all_drafts = league.get_all_drafts()
# Sleeper will only have 1 draft, so we can access the first result from the list
draft_id = all_drafts[0]['draft_id']
draft = Drafts(draft_id)
draft_picks = draft.get_all_picks()
nice_print(draft_picks)
# Might be able to use draft.get_specific_draft() to get the season for the draft if this function changes in
# the future
# specific_picks = draft.get_specific_draft()
# If saved_drafts doesn't exist, create the directory
if not os.path.isdir('./saved_drafts'):
try:
os.mkdir('saved_drafts')
except Exception as e:
print(e)
assert False
with open('saved_drafts/draft_{}.json'.format(season), 'w') as f:
f.write(json.dumps(draft_picks))
def test_get_user(capsys):
user = User("swa")
user = user.get_user()
assert isinstance(user, dict)
assert user['username'] == "swa"
def test_get_all_drafts(capsys):
user = User("swa")
drafts = user.get_all_drafts("nfl", 2019)
assert isinstance(drafts, list)
assert isinstance(drafts[0], dict)
def wide_receivers(self, number):
return self.__num_of_players_in_pos__(number, 'WR')
def tight_ends(self, number):
return self.__num_of_players_in_pos__(number, 'TE')
def defenses(self, number):
return self.__num_of_players_in_pos__(number, 'DEF')
def kickers(self, number):
return self.__num_of_players_in_pos__(number, 'K')
if __name__ == "__main__":
PLAYER_DATABASE = player_data_base_load()
user = User(USER_NAME)
user_id = user.get_user_id()
league_objs = []
[
league_objs.append(League(league['league_id']))
for league in user.get_all_leagues("nfl", YEAR)
]
my_rosters = []
[[
my_rosters.append(Roster(obj.get_league()["name"], roster["players"]))
for roster in obj.get_rosters() if roster["owner_id"] == user_id
] for obj in league_objs]
[[print(backs) for backs in roster.defenses(5)] for roster in my_rosters]
def main_program(username, debug, refresh, position, offline):
""" Run the main application
Args:
username (str): Username of owner in YAFL 2.0
debug (bool): Debug argument flag. Print debug output.
refresh (bool): Refresh argument flag. Refresh player data from Sleeper API
position (str): Position argument. Get keeper value for given position.
offline (bool): Offline argument. Run in offline mode.
"""
if offline:
# For offline mode we need to get all the files from data_files. If the file does not exist, remind the user
# to use --refresh to get and store data
try:
with open('data_files/player_dict.json') as f:
player_dict = json.load(f)
except Exception as e:
print(e)
assert False, 'Unable to open data_files/player_dict.json. \n Use --refresh to get data from Sleeper API'
try:
with open('data_files/draft_dict.json') as f:
draft_dict = json.load(f)
except Exception as e:
print(e)
assert False, 'Unable to open data_files/draft_dict.json. \n Use --refresh to get data from Sleeper API'
try:
with open('data_files/rosters.json') as f:
roster_dict = json.load(f)
except Exception as e:
print(e)
assert False, 'Unable to open data_files/rosters.json. \n Use --refresh to get data from Sleeper API'
try:
with open('data_files/transactions.json') as f:
transactions = json.load(f)
except Exception as e:
print(e)
assert False, 'Unable to open data_files/transactions.json. \n Use --refresh to get data from Sleeper API'
try:
with open('data_files/trades.json') as f:
trades = json.load(f)
except Exception as e:
print(e)
assert False, 'Unable to open data_files/trades.json. \n Use --refresh to get data from Sleeper API'
try:
with open('data_files/traded_picks.json') as f:
traded_picks = json.load(f)
except Exception as e:
print(e)
assert False, 'Unable to open data_files/traded_picks.json. \n Use --refresh to get data from Sleeper API'
keeper_dict = determine_eligible_keepers(roster_dict, player_dict, draft_dict, transactions, traded_picks)
pretty_print_keepers(keeper_dict)
if position:
position_keeper(keeper_dict, position)
return
# Get the user object to get league info
user_obj = User(username)
# Get the league object. Will be used to get draft info, transactions, and rosters.
league = get_league_id(user_obj)
# Get the username and id
user_dict = get_users(league)
# Get a dictionary of all the players
player_dict = get_players(refresh)
# Get the trade deadline from the league settings
trade_deadline = get_trade_deadline(league)
# Get a dictionary of all the drafted players
draft_dict = get_drafted_players(league)
# Get a dictionary of all the rostered players
roster_dict = get_rosters(league, user_dict)
# Get the transactions after the trade deadline
transactions = get_transactions(league, trade_deadline)
# Get a list of traded players and dictionary of traded draft picks
trades, traded_picks = get_trades(league)
# DEBUG code to process traded_picks
# process_traded_picks(roster_dict, traded_picks)
# Get the final keeper list
keeper_dict = determine_eligible_keepers(roster_dict, player_dict, draft_dict, transactions, traded_picks)
if debug:
# If data_files doesn't exist, create the directory
if not os.path.isdir('./debug_files'):
try:
os.mkdir('debug_files')
except Exception as e:
print(e)
assert False
# Output everything to a file to figure out what is happening
with open('debug_files/user_dict.json', 'w') as f:
f.write('{}'.format(pformat(user_dict)))
with open('debug_files/draft_dict.json', 'w') as f:
f.write('{}'.format(pformat(draft_dict)))
with open('debug_files/rosters.json', 'w') as f:
f.write('{}'.format(pformat(roster_dict)))
with open('debug_files/player_dict.json', 'w') as f:
f.write('{}'.format(pformat(player_dict)))
with open('debug_files/keeper_dict.json', 'w') as f:
f.write('{}'.format(pformat(keeper_dict)))
with open('debug_files/transactions.json', 'w') as f:
f.write('{}'.format(pformat(transactions)))
with open('debug_files/trades.json', 'w') as f:
f.write('{}'.format(pformat(trades)))
with open('debug_files/traded_picks.json', 'w') as f:
f.write('{}'.format(pformat(traded_picks)))
if refresh:
if not os.path.isdir('./data_files'):
try:
os.mkdir('date_files')
except Exception as e:
print(e)
assert False
with open('data_files/user_dict.json', 'w') as f:
f.write(json.dumps(user_dict))
with open('data_files/draft_dict.json', 'w') as f:
f.write(json.dumps(draft_dict))
with open('data_files/rosters.json', 'w') as f:
f.write(json.dumps(roster_dict))
with open('data_files/player_dict.json', 'w') as f:
f.write(json.dumps(player_dict))
with open('data_files/keeper_dict.json', 'w') as f:
f.write(json.dumps(keeper_dict))
with open('data_files/transactions.json', 'w') as f:
f.write(json.dumps(transactions))
with open('data_files/trades.json', 'w') as f:
f.write(json.dumps(trades))
with open('data_files/traded_picks.json', 'w') as f:
f.write(json.dumps(traded_picks))
pretty_print_keepers(keeper_dict)
csv_print_keepers(keeper_dict)
if position:
position_keeper(keeper_dict, position)
return
def main(argv):
# Parse all of the user-provided flags
args = parse_user_provided_flags()
# Convert the computed args into our more-verbose local fields
account_username = args.username
league_year = args.year
league_regex = re.compile(args.league_regex)
starting_week = args.start
ending_week = args.end
weekly_score_output_count = args.weekly_count
seasonal_score_output_count = args.season_count
find_weekly = args.weekly or args.current_week
print_max_this_week = args.max and args.current_week
print_min_this_week = args.min and args.current_week
print_max_weekly = args.weekly and args.max
print_min_weekly = args.weekly and args.min
find_seasonal = args.season
print_max_seasonal = args.season and args.max
print_min_seasonal = args.season and args.min
# Lists containing all of the collated data
weekly_scores = []
seasonal_scores = []
user_store = UserStore()
# Retrieve all of the leagues
admin_user = User(account_username)
all_leagues = admin_user.get_all_leagues("nfl", league_year)
# Iterate over all the leagues in the account
for league_object in all_leagues:
league = League(league_object.get("league_id"))
league_name = league.get_league().get("name")
# Only look at leagues that match the provided regex
if league_regex.match(league_name):
user_store.store_users_for_league(league)
# Iterate over each indiviudal week, since we need to grab the max weekly score for the league
if find_weekly:
for week_num in range(starting_week, ending_week + 1):
weekly_scores.extend(
get_weekly_scores_for_league_and_week(
league, week_num, user_store))
if find_seasonal:
# Grab the points-for in each league
seasonal_scores.extend(
get_pf_for_entire_league(league, user_store))
# Sublists used for sorted results
max_weekly_scores = []
min_weekly_scores = []
max_scores_this_week = []
min_scores_this_week = []
max_seasonal_points_for = []
min_seasonal_points_for = []
# Sort all of the lists
if find_seasonal:
max_seasonal_points_for = seasonal_scores.copy()
max_seasonal_points_for.sort(
key=lambda annual_score: annual_score.points_for, reverse=True)
min_seasonal_points_for = seasonal_scores.copy()
min_seasonal_points_for.sort(
key=lambda annual_score: annual_score.points_for)
if find_weekly:
max_weekly_scores = weekly_scores.copy()
max_weekly_scores.sort(key=lambda weekly_score: weekly_score.points,
reverse=True)
min_weekly_scores = weekly_scores.copy()
min_weekly_scores.sort(key=lambda weekly_score: weekly_score.points)
max_scores_this_week = list(
filter(lambda weekly_score: weekly_score.week == ending_week,
max_weekly_scores.copy()))
min_scores_this_week = list(
filter(lambda weekly_score: weekly_score.week == ending_week,
min_weekly_scores.copy()))
# Print out the results
this_week_template = "{main_header}, Week {week_num}"
if print_max_this_week:
print_non_empty_list_with_header(
max_scores_this_week,
this_week_template.format(main_header="HIGHEST SCORES THIS WEEK",
week_num=ending_week),
weekly_score_output_count)
if print_min_this_week:
print_non_empty_list_with_header(
min_scores_this_week,
this_week_template.format(main_header="LOWEST SCORES THIS WEEK",
week_num=ending_week),
weekly_score_output_count)
if print_max_weekly:
print_non_empty_list_with_header(max_weekly_scores,
"HIGHEST WEEKLY SCORES THIS SEASON",
weekly_score_output_count)
if print_min_weekly:
print_non_empty_list_with_header(min_weekly_scores,
"LOWEST WEEKLY SCORES THIS SEASON",
weekly_score_output_count)
if print_max_seasonal:
print_non_empty_list_with_header(max_seasonal_points_for,
"HIGHEST POINTS-FOR THIS SEASON",
seasonal_score_output_count)
if print_min_seasonal:
print_non_empty_list_with_header(min_seasonal_points_for,
"LOWEST POINTS-FOR THIS SEASON",
seasonal_score_output_count)