diff --git a/.gitignore b/.gitignore index 5589c77f..a314a1f8 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,10 @@ *FD_API_KEY *FPL_LOGIN *FPL_PASSWORD +*AIrsenalDBFile +*AIrsenalDBUri +*AIrsenalDBUser +*AIrsenalDBPassword # compiled stan models stan_model/ diff --git a/.travis.yml b/.travis.yml index 214a1239..6ffadfdd 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,18 +6,25 @@ env: jobs: include: - - name: "Python 3.7.4 on Xenial Linux" - python: 3.7 # this works for Linux but is ignored on macOS or Windows + - name: "Python 3.7" + python: 3.7 install: - pip3 install --upgrade pip - pip3 install . - - name: "Python 3.6 on Xenial Linux" - python: 3.6 # this works for Linux but is ignored on macOS or Windows + - name: "Python 3.8" + python: 3.8 install: - pip3 install --upgrade pip - pip3 install . - + + - name: "Python 3.9" + python: 3.9 + install: + - pip3 install --upgrade pip + - pip3 install numpy Cython + - pip3 install . + - name: "Python 3.7.4 on macOS" os: osx osx_image: xcode11.2 # Python 3.7.4 running on macOS 10.14.4 @@ -44,7 +51,7 @@ jobs: - conda activate test_env - conda install libpython m2w64-toolchain -c msys2 - conda install numpy cython -c conda-forge - - conda install pystan -c conda-forge + - conda install pystan=2.19.1.1 -c conda-forge install: - python -m pip install --upgrade pip - python -m pip install . diff --git a/README.md b/README.md index 30930e0a..51535b35 100644 --- a/README.md +++ b/README.md @@ -76,6 +76,8 @@ Once you've installed the module, you will need to set the following parameters: 4. `FPL_PASSWORD`: your FPL password (this is only required to get FPL league standings). +5. `AIrsenalDBFile`: Local path to where you would like to store the AIrsenal sqlite3 database. If not set a temporary directory will be used by default (`/tmp/data.db` on Unix systems). + The values for these should be defined either in environment variables with the names given above, or as files in the `airsenal/data` directory with the names given above. For example, to set your team ID you can create the file `airsenal/data/FPL_TEAM_ID` (with no file extension) and its contents should be your team ID and nothing else. So the contents of the file would just be something like: ``` 1234567 @@ -89,7 +91,6 @@ If you installed AIrsenal with conda, you should always make sure the `airsenale conda activate airsenalenv ``` - Note: Most the commands below can be run with the `--help` flag to see additional options and information. ### 1. Creating the database @@ -144,7 +145,7 @@ Instead of running the commands above individually you can use: ```shell airsenal_run_pipeline ``` -This will delete and recreate the database and then run the points predictions and transfer optimization. +This will update the database and then run the points predictions and transfer optimization. ## Docker diff --git a/airsenal/__init__.py b/airsenal/__init__.py index 37f195b0..e01ffd65 100644 --- a/airsenal/__init__.py +++ b/airsenal/__init__.py @@ -7,7 +7,7 @@ # AIrsenal package version. When merging changes to master: # - increment 2nd digit for new features # - increment 3rd digit for bug fixes -__version__ = "0.3.0" +__version__ = "0.4.0" # Cross-platform temporary directory if os.name == "posix": diff --git a/airsenal/data/fifa_team_ratings_1718.csv b/airsenal/data/fifa_team_ratings_1718.csv new file mode 100644 index 00000000..7f43204e --- /dev/null +++ b/airsenal/data/fifa_team_ratings_1718.csv @@ -0,0 +1,21 @@ +team_name,att,mid,defn,ovr +Chelsea,85,85,82,84 +Manchester United,86,83,81,83 +Arsenal,86,82,80,83 +Manchester City,84,85,81,83 +Tottenham Hotspur,86,82,81,82 +Liverpool,83,82,80,82 +Everton,79,82,79,80 +West Ham United,80,79,78,79 +Leicester City,79,79,76,78 +Southampton,78,78,77,78 +Stoke City,78,77,77,77 +Watford,77,76,76,77 +Crystal Palace,81,76,75,76 +West Bromwich Albion,80,75,76,76 +Swansea City,75,77,75,76 +Bournemouth,76,74,75,75 +Burnley,74,75,75,75 +Newcastle United,74,75,75,75 +Brighton & Hove Albion,74,74,73,74 +Huddersfield Town,73,73,72,73 \ No newline at end of file diff --git a/airsenal/framework/bpl_interface.py b/airsenal/framework/bpl_interface.py index d43ed505..f560249e 100644 --- a/airsenal/framework/bpl_interface.py +++ b/airsenal/framework/bpl_interface.py @@ -70,14 +70,26 @@ def get_ratings_df(season, dbsession): return df -def create_and_fit_team_model(df, df_X, teams=CURRENT_TEAMS): +def create_and_fit_team_model(df, df_X, teams=CURRENT_TEAMS, n_attempts=3): """ Get the team-level stan model, which can give probabilities of each potential scoreline in a given fixture. """ model_team = bpl.BPLModel(df, X=df_X) - model_team.fit() + for i in range(n_attempts): + print(f"attempt {i + 1} of {n_attempts}...", end=" ", flush=True) + try: + model_team.fit() + print("SUCCESS!") + break + except RuntimeError: + print("FAILED.") + if i + 1 == n_attempts: + raise + else: + continue + # check if each team is known to the model, and if not, add it using FIFA rankings for team in teams: if team not in model_team.team_indices.keys(): diff --git a/airsenal/framework/db_config.py b/airsenal/framework/db_config.py index 48e0e375..2cc483c7 100644 --- a/airsenal/framework/db_config.py +++ b/airsenal/framework/db_config.py @@ -1,27 +1,68 @@ """ Database can be either an sqlite file or a postgress server """ - import os from airsenal import TMPDIR -# Default connection string points to a local sqlite file in -# airsenal/data/data.db - -DB_CONNECTION_STRING = "sqlite:///{}/data.db".format(TMPDIR) +config_path = os.path.join(os.path.dirname(__file__), "..", "data") +AIrsenalDBFile_path = os.path.join(config_path, "AIrsenalDBFile") +AIrsenalDBUri_path = os.path.join(config_path, "AIrsenalDBUri") +AIrsenalDBUser_path = os.path.join(config_path, "AIrsenalDBUser") +AIrsenalDBPassword_path = os.path.join(config_path, "AIrsenalDBPassword") # Check that we're not trying to set location for both sqlite and postgres -if "AIrsenalDBFile" in os.environ.keys() and "AIrsenalDBUri" in os.environ.keys(): +if ("AIrsenalDBFile" in os.environ.keys() or os.path.exists(AIrsenalDBFile_path)) and ( + "AIrsenalDBUri" in os.environ.keys() or os.path.exists(AIrsenalDBUri_path) +): raise RuntimeError("Please choose only ONE of AIrsenalDBFile and AIrsenalDBUri") -# location of sqlite file overridden by an env var +# sqlite database in a local file with path specified by: +# - AIrsenalDBFile environment variable +# - airsenal/data/AIrsenalDBFile file +# - platform-dependent temporary directory (default) if "AIrsenalDBFile" in os.environ.keys(): - DB_CONNECTION_STRING = "sqlite:///{}".format(os.environ["AIrsenalDBFile"]) + AIrsenalDBFile = os.environ["AIrsenalDBFile"] +elif os.path.exists(AIrsenalDBFile_path): + AIrsenalDBFile = open(AIrsenalDBFile_path).read().strip() +else: + AIrsenalDBFile = os.path.join(TMPDIR, "data.db") + +DB_CONNECTION_STRING = "sqlite:///{}".format(AIrsenalDBFile) + +# postgres database specified by: AIrsenalDBUri, AIrsenalDBUser, AIrsenalDBPassword +# defined either as: +# - environment variables +# - Files in airsenal/data/ +if "AIrsenalDBUri" in os.environ.keys() or os.path.exists(AIrsenalDBUri_path): + if "AIrsenalDBUser" in os.environ.keys(): + AIrsenalDBUser = os.environ["AIrsenalDBUser"] + elif os.path.exists(AIrsenalDBUser_path): + AIrsenalDBUser = open(AIrsenalDBUser_path).read().strip() + else: + raise RuntimeError( + "AIrsenalDBUser must be defined when using a postgres database" + ) + + if "AIrsenalDBUser" in os.environ.keys(): + AIrsenalDBPassword = os.environ["AIrsenalDBPassword"] + elif os.path.exists(AIrsenalDBPassword_path): + AIrsenalDBPassword = open(AIrsenalDBPassword_path).read().strip() + else: + raise RuntimeError( + "AIrsenalDBPassword must be defined when using a postgres database" + ) + + if "AIrsenalDBUri" in os.environ.keys(): + AIrsenalDBUri = os.environ["AIrsenalDBUri"] + elif os.path.exists(AIrsenalDBUri_path): + AIrsenalDBUri = open(AIrsenalDBUri_path).read().strip() + else: + raise RuntimeError( + "AIrsenalDBUri must be defined when using a postgres database" + ) -# location of postgres server -if "AIrsenalDBUri" in os.environ.keys(): DB_CONNECTION_STRING = "postgres://{}:{}@{}/airsenal".format( - os.environ["AIrsenalDBUser"], - os.environ["AIrsenalDBPassword"], - os.environ["AIrsenalDBUri"], + AIrsenalDBUser, + AIrsenalDBPassword, + AIrsenalDBUri, ) diff --git a/airsenal/framework/multiprocessing_utils.py b/airsenal/framework/multiprocessing_utils.py index 9df0bdcb..913a3320 100644 --- a/airsenal/framework/multiprocessing_utils.py +++ b/airsenal/framework/multiprocessing_utils.py @@ -34,13 +34,13 @@ def __init__(self, n=0): self.count = multiprocessing.Value("i", n) def increment(self, n=1): - """ Increment the counter by n (default = 1) """ + """Increment the counter by n (default = 1)""" with self.count.get_lock(): self.count.value += n @property def value(self): - """ Return the value of the counter """ + """Return the value of the counter""" return self.count.value @@ -70,9 +70,9 @@ def get(self, *args, **kwargs): return super().get(*args, **kwargs) def qsize(self): - """ Reliable implementation of multiprocessing.Queue.qsize() """ + """Reliable implementation of multiprocessing.Queue.qsize()""" return self.size.value def empty(self): - """ Reliable implementation of multiprocessing.Queue.empty() """ + """Reliable implementation of multiprocessing.Queue.empty()""" return not self.qsize() diff --git a/airsenal/framework/optimization_utils.py b/airsenal/framework/optimization_utils.py index 7a1d08eb..48a7ada6 100644 --- a/airsenal/framework/optimization_utils.py +++ b/airsenal/framework/optimization_utils.py @@ -114,7 +114,7 @@ def get_starting_squad(fpl_team_id=None): # chip is activated transactions = ( session.query(Transaction) - .order_by(Transaction.id) + .order_by(Transaction.gameweek, Transaction.id) .filter_by(fpl_team_id=fpl_team_id) .filter_by(free_hit=0) .all() @@ -672,12 +672,13 @@ def make_new_squad( return best_squad -def fill_suggestion_table(baseline_score, best_strat, season): +def fill_suggestion_table(baseline_score, best_strat, season, fpl_team_id): """ Fill the optimized strategy into the table """ timestamp = str(datetime.now()) best_score = best_strat["total_score"] + points_gain = best_score - baseline_score for in_or_out in [("players_out", -1), ("players_in", 1)]: for gameweek, players in best_strat[in_or_out[0]].items(): @@ -689,6 +690,8 @@ def fill_suggestion_table(baseline_score, best_strat, season): ts.points_gain = points_gain ts.timestamp = timestamp ts.season = season + ts.fpl_team_id = fpl_team_id + ts.chip_played = best_strat["chips_played"][gameweek] session.add(ts) session.commit() diff --git a/airsenal/framework/player.py b/airsenal/framework/player.py index f2eb59e5..5827944d 100644 --- a/airsenal/framework/player.py +++ b/airsenal/framework/player.py @@ -38,6 +38,9 @@ def __init__( self.predicted_points = {} self.sub_position = None + def __str__(self): + return self.name + def calc_predicted_points(self, method): """ get expected points from the db. @@ -55,10 +58,6 @@ def get_predicted_points(self, gameweek, method): if method not in self.predicted_points.keys(): self.calc_predicted_points(method) if gameweek not in self.predicted_points[method].keys(): - print( - "No prediction available for {} week {}".format( - self.data.name, gameweek - ) - ) + print("No prediction available for {} week {}".format(self.name, gameweek)) return 0.0 return self.predicted_points[method][gameweek] diff --git a/airsenal/framework/prediction_utils.py b/airsenal/framework/prediction_utils.py index c18010ac..5399a011 100644 --- a/airsenal/framework/prediction_utils.py +++ b/airsenal/framework/prediction_utils.py @@ -17,7 +17,6 @@ NEXT_GAMEWEEK, get_fixtures_for_player, get_recent_minutes_for_player, - get_return_gameweek_for_player, get_max_matches_per_player, get_player, get_player_from_api_id, @@ -71,7 +70,7 @@ def get_player_history_df( for counter, player in enumerate(players): print( "Filling history dataframe for {}: {}/{} done".format( - player.name, counter, len(players) + player, counter, len(players) ) ) results = player.scores @@ -87,11 +86,7 @@ def get_player_history_df( match_id = row.result_id if not match_id: - print( - " Couldn't find result for {} {} {}".format( - row.fixture.home_team, row.fixture.away_team, row.fixture.date - ) - ) + print(" Couldn't find result for {}".format(row.fixture)) continue minutes = row.minutes goals = row.goals @@ -272,7 +267,7 @@ def calc_predicted_points_for_player( df_cards, season, gw_range=None, - fixtures_behind=3, + fixtures_behind=None, tag="", dbsession=session, ): @@ -284,13 +279,19 @@ def calc_predicted_points_for_player( if isinstance(player, int): player = get_player(player, dbsession=dbsession) - message = "Points prediction for player {}".format(player.name) + message = "Points prediction for player {}".format(player) if not gw_range: # by default, go for next three matches gw_range = list( range(NEXT_GAMEWEEK, min(NEXT_GAMEWEEK + 3, 38)) ) # don't go beyond gw 38! + + if fixtures_behind is None: + # default to getting recent minutes from the same number of matches we're + # predicting for + fixtures_behind = len(gw_range) + team = player.team( season, gw_range[0] ) # assume player stays with same team from first gameweek in range @@ -335,7 +336,7 @@ def calc_predicted_points_for_player( # calculate appearance points, defending points, attacking points. points = 0.0 - elif is_injured_or_suspended(player.fpl_api_id, gameweek, season, dbsession): + elif player.is_injured_or_suspended(season, gw_range[0], gameweek): # Points for fixture will be zero if suspended or injured points = 0.0 @@ -458,27 +459,6 @@ def get_all_fitted_player_models(player_model, season, gameweek, dbsession=sessi return df_positions -def is_injured_or_suspended(player_api_id, gameweek, season, dbsession=session): - """ - Query the API for 'chance of playing next round', and if this - is <=50%, see if we can find a return date. - """ - if season != CURRENT_SEASON: # no API info for past seasons - return False - # check if a player is injured or suspended - pdata = fetcher.get_player_summary_data()[player_api_id] - if ( - "chance_of_playing_next_round" in pdata.keys() - and pdata["chance_of_playing_next_round"] is not None - and pdata["chance_of_playing_next_round"] <= 50 - ): - # check if we have a return date - return_gameweek = get_return_gameweek_for_player(player_api_id, dbsession) - if return_gameweek is None or return_gameweek > gameweek: - return True - return False - - def fill_ep(csv_filename, dbsession=session): """ fill the database with FPLs ep_next prediction, and also diff --git a/airsenal/framework/schema.py b/airsenal/framework/schema.py index 232e3e9f..238b4011 100644 --- a/airsenal/framework/schema.py +++ b/airsenal/framework/schema.py @@ -34,39 +34,12 @@ def team(self, season, gameweek): at least one gameweek in specified season, return a best guess value based on data nearest to specified gameweek. """ - gw_before = 0 - gw_after = 100 - team_before = None - team_after = None - - for attr in self.attributes: - if attr.season != season: - continue - - if attr.gameweek == gameweek: - return attr.team - elif (attr.gameweek < gameweek) and (attr.gameweek > gw_before): - # update last available team before specified gameweek - gw_before = attr.gameweek - team_before = attr.team - elif (attr.gameweek > gameweek) and (attr.gameweek < gw_after): - # update next available team after specified gameweek - gw_after = attr.gameweek - team_after = attr.team - - # ran through all attributes without finding gameweek, return an - # appropriate estimate - if not team_before and not team_after: + attr = self.get_gameweek_attributes(season, gameweek) + if attr is not None: + return attr.team + else: print("No team found for", self.name, "in", season, "season.") return None - elif not team_after: - return team_before - elif not team_before: - return team_after - elif (gw_after - gameweek) >= (gameweek - gw_before): - return team_before - else: - return team_after def price(self, season, gameweek): """ @@ -75,51 +48,107 @@ def price(self, season, gameweek): at least one gameweek in specified season, return a best guess value based on data nearest to specified gameweek. """ + attr = self.get_gameweek_attributes(season, gameweek, before_and_after=True) + if attr is not None: + if isinstance(attr, tuple): + # interpolate price between nearest available gameweeks + gw_before = attr[0].gameweek + price_before = attr[0].price + gw_after = attr[1].gameweek + price_after = attr[1].price + + gradient = (price_after - price_before) / (gw_after - gw_before) + intercept = price_before - gradient * gw_before + price = gradient * gameweek + intercept + return round(price) + + else: + return attr.price + else: + print("No price found for", self.name, "in", season, "season.") + return None + + def position(self, season): + """ + get player's position for given season + """ + attr = self.get_gameweek_attributes(season, None) + if attr is not None: + return attr.position + else: + print("No position found for", self.name, "in", season, "season.") + return None + + def is_injured_or_suspended(self, season, current_gw, fixture_gw): + """Check whether a player is injured or suspended (<=50% chance of playing). + current_gw - The current gameweek, i.e. the gameweek when we are querying the + player's status. + fixture_gw - The gameweek of the fixture we want to check whether the player + is available for, i.e. we are checking whether the player is availiable in the + future week "fixture_gw" at the previous point in time "current_gw". + """ + attr = self.get_gameweek_attributes(season, current_gw) + if attr is not None: + if ( + attr.chance_of_playing_next_round is not None + and attr.chance_of_playing_next_round <= 50 + ) and (attr.return_gameweek is None or attr.return_gameweek > fixture_gw): + return True + else: + return False + else: + return False + + def get_gameweek_attributes(self, season, gameweek, before_and_after=False): + """Get the PlayerAttributes object for this player in the given gameweek and + season, or the nearest available gameweek(s) if the exact gameweek is not + available. + If no attributes available in the specified season, return None in all cases. + If before_and_after is True and an exact gameweek & season match is not found, + return both the nearest gameweek before and after the specified gameweek. + """ gw_before = 0 gw_after = 100 - price_before = None - price_after = None + attr_before = None + attr_after = None for attr in self.attributes: if attr.season != season: continue - if attr.gameweek == gameweek: - return attr.price + if gameweek is None: + # trying to match season only + return attr + elif attr.gameweek == gameweek: + return attr elif (attr.gameweek < gameweek) and (attr.gameweek > gw_before): - # update last available price before specified gameweek + # update last available attr before specified gameweek gw_before = attr.gameweek - price_before = attr.price + attr_before = attr elif (attr.gameweek > gameweek) and (attr.gameweek < gw_after): - # update next available price after specified gameweek + # update next available attr after specified gameweek gw_after = attr.gameweek - price_after = attr.price + attr_after = attr - # ran through all attributes without finding gameweek, return an - # appropriate estimate - if not price_before and not price_after: - print("No price found for", self.name, "in", season, "season.") + # ran through all attributes without finding exact gameweek and season match + if attr_before is None and attr_after is None: + # no attributes for this player in this season return None - elif not price_after: - return price_before - elif not price_before: - return price_after + elif not attr_after: + return attr_before + elif not attr_before: + return attr_after + elif before_and_after: + return (attr_before, attr_after) else: - # found a price before and after the requested gameweek, - # interpolate between the two - gradient = (price_after - price_before) / (gw_after - gw_before) - intercept = price_before - gradient * gw_before - price = gradient * gameweek + intercept - return round(price) + # return attributes at gameweeek nearest to input gameweek + if (gw_after - gameweek) >= (gameweek - gw_before): + return attr_before + else: + return attr_after - def position(self, season): - """ - get player's position for given season - """ - for attr in self.attributes: - if attr.season == season: - return attr.position - return None + def __str__(self): + return self.name class PlayerAttributes(Base): @@ -133,11 +162,20 @@ class PlayerAttributes(Base): team = Column(String(100), nullable=False) position = Column(String(100), nullable=False) + chance_of_playing_next_round = Column(Integer, nullable=True) + news = Column(String(100), nullable=True) + return_gameweek = Column(Integer, nullable=True) transfers_balance = Column(Integer, nullable=True) selected = Column(Integer, nullable=True) transfers_in = Column(Integer, nullable=True) transfers_out = Column(Integer, nullable=True) + def __str__(self): + return ( + f"{self.player} ({self.season} GW{self.gameweek}): " + f"£{self.price / 10}, {self.team}, {self.position}" + ) + class Result(Base): __tablename__ = "result" @@ -149,6 +187,13 @@ class Result(Base): player = relationship("Player", back_populates="results") player_id = Column(Integer, ForeignKey("player.player_id")) + def __str__(self): + return ( + f"{self.fixture.season} GW{self.fixture.gameweek} " + f"{self.fixture.home_team} {self.home_score} - " + f"{self.away_score} {self.fixture.away_team}" + ) + class Fixture(Base): __tablename__ = "fixture" @@ -163,6 +208,15 @@ class Fixture(Base): player = relationship("Player", back_populates="fixtures") player_id = Column(Integer, ForeignKey("player.player_id")) + def __str__(self): + if self.result: + return str(self.result) + else: + return ( + f"{self.season} GW{self.gameweek} " + f"{self.home_team} vs. {self.away_team}" + ) + class PlayerScore(Base): __tablename__ = "player_score" @@ -197,6 +251,19 @@ class PlayerScore(Base): threat = Column(Float, nullable=True) ict_index = Column(Float, nullable=True) + def __str__(self): + score_str = ( + f"{self.player} ({self.result}): " f"{self.points} pts, {self.minutes} mins" + ) + if self.goals > 0: + score_str += f", {self.goals} goals" + if self.assists > 0: + score_str += f", {self.assists} assists" + if self.bonus > 0: + score_str += f", {self.bonus} bonus" + + return score_str + class PlayerPrediction(Base): __tablename__ = "player_prediction" @@ -208,6 +275,9 @@ class PlayerPrediction(Base): player = relationship("Player", back_populates="predictions") player_id = Column(Integer, ForeignKey("player.player_id")) + def __str__(self): + return f"{self.player}: Predict {self.predicted_points} pts in {self.fixture}" + class Transaction(Base): __tablename__ = "transaction" @@ -216,11 +286,22 @@ class Transaction(Base): gameweek = Column(Integer, nullable=False) bought_or_sold = Column(Integer, nullable=False) # +1 for bought, -1 for sold season = Column(String(100), nullable=False) + time = Column(String(100), nullable=False) tag = Column(String(100), nullable=False) price = Column(Integer, nullable=False) free_hit = Column(Integer, nullable=False) # 1 if transfer on Free Hit, 0 otherwise fpl_team_id = Column(Integer, nullable=False) + def __str__(self): + trans_str = f"{self.season} GW{self.gameweek}: " + if self.bought_or_sold == 1: + trans_str += f"Team {self.fpl_team_id} bought player {self.player_id}" + else: + trans_str += f"Team {self.fpl_team_id} bought player {self.player_id}" + if self.free_hit: + trans_str += " (FREE HIT)" + return trans_str + class TransferSuggestion(Base): __tablename__ = "transfer_suggestion" @@ -231,6 +312,22 @@ class TransferSuggestion(Base): points_gain = Column(Float, nullable=False) timestamp = Column(String(100), nullable=False) # use this to group suggestions season = Column(String(100), nullable=False) + fpl_team_id = Column( + Integer, nullable=False + ) # to identify team to apply transfers. + chip_played = Column(String(100), nullable=True) + + def __str__(self): + sugg_str = f"{self.season} GW{self.gameweek}: " + if self.in_or_out == 1: + sugg_str += ( + f"Suggest buying {self.player_id} for gain of {self.points_gain}" + ) + else: + sugg_str += ( + f"Suggest selling {self.player_id} for gain of {self.points_gain}" + ) + return sugg_str class FifaTeamRating(Base): @@ -243,6 +340,12 @@ class FifaTeamRating(Base): mid = Column(Integer, nullable=False) ovr = Column(Integer, nullable=False) + def __str__(self): + return ( + f"{self.team} {self.season} FIFA rating: " + f"ovr {self.ovr}, def {self.defn}, mid {self.mid}, att {self.att}" + ) + class Team(Base): __tablename__ = "team" @@ -254,6 +357,9 @@ class Team(Base): Integer, nullable=False ) # the season-dependent team ID (from alphabetical order) + def __str__(self): + return f"{self.full_name} ({self.name})" + class SessionSquad(Base): __tablename__ = "sessionteam" diff --git a/airsenal/framework/squad.py b/airsenal/framework/squad.py index afca5ccb..4b77d597 100644 --- a/airsenal/framework/squad.py +++ b/airsenal/framework/squad.py @@ -99,25 +99,25 @@ def add_player( # check if constraints are met if not self.check_no_duplicate_player(player): if self.verbose: - print("Already have {} in team".format(player.name)) + print("Already have {} in team".format(player)) return False if not self.check_num_in_position(player): if self.verbose: print( "Unable to add player {} - too many {}".format( - player.name, player.position + player, player.position ) ) return False if check_budget and not self.check_cost(player): if self.verbose: - print("Cannot afford player {}".format(player.name)) + print("Cannot afford player {}".format(player)) return False if check_team and not self.check_num_per_team(player): if self.verbose: print( "Cannot add {} - too many players from {}".format( - player.name, player.team + player, player.team ) ) return False @@ -194,7 +194,7 @@ def get_sell_price_for_player( print( "Using purchase price as sale price for", player.player_id, - player.name, + player, ) price_now = price_bought diff --git a/airsenal/framework/transaction_utils.py b/airsenal/framework/transaction_utils.py index b3eef8fc..309a0249 100644 --- a/airsenal/framework/transaction_utils.py +++ b/airsenal/framework/transaction_utils.py @@ -3,6 +3,7 @@ hopefully with the correct price. Needs FPL_TEAM_ID to be set, either via environment variable, or a file named FPL_TEAM_ID in airsenal/data/ """ +from sqlalchemy import or_, and_ from airsenal.framework.schema import Transaction from airsenal.framework.utils import ( @@ -31,6 +32,70 @@ def free_hit_used_in_gameweek(gameweek, fpl_team_id=None): return 0 +def count_transactions(season, fpl_team_id, dbsession=session): + """Count the number of transactions we have in the database for a given team ID + and season. + """ + if fpl_team_id is None: + fpl_team_id = fetcher.FPL_TEAM_ID + + transactions = ( + dbsession.query(Transaction) + .filter_by(fpl_team_id=fpl_team_id) + .filter_by(season=season) + .all() + ) + return len(transactions) + + +def transaction_exists( + fpl_team_id, + gameweek, + season, + time, + pid_out, + price_out, + pid_in, + price_in, + dbsession=session, +): + """Check whether the transactions related to transferring a player in and out + in a gameweek at a specific time already exist in the database. + """ + transactions = ( + dbsession.query(Transaction) + .filter_by(fpl_team_id=fpl_team_id) + .filter_by(gameweek=gameweek) + .filter_by(season=season) + .filter_by(time=time) + .filter( + or_( + and_( + Transaction.player_id == pid_in, + Transaction.price == price_in, + Transaction.bought_or_sold == 1, + ), + and_( + Transaction.player_id == pid_out, + Transaction.price == price_out, + Transaction.bought_or_sold == -1, + ), + ) + ) + .all() + ) + if len(transactions) == 2: # row for player bought and player sold + return True + elif len(transactions) == 0: + return False + else: + raise ValueError( + f"Database error: {len(transactions)} transactions in the database with " + f"parameters: fpl_team_id={fpl_team_id}, gameweek={gameweek}, " + f"time={time}, pid_in={pid_in}, pid_out={pid_out}. Should be 2." + ) + + def add_transaction( player_id, gameweek, @@ -40,6 +105,7 @@ def add_transaction( tag, free_hit, fpl_team_id, + time, dbsession=session, ): """ @@ -54,6 +120,7 @@ def add_transaction( tag=tag, free_hit=free_hit, fpl_team_id=fpl_team_id, + time=time, ) dbsession.add(t) dbsession.commit() @@ -88,8 +155,10 @@ def fill_initial_squad( starting_gw += 1 print(f"Trying gameweek {starting_gw}...") init_players = get_players_for_gameweek(starting_gw, fpl_team_id) - free_hit = free_hit_used_in_gameweek(starting_gw, fpl_team_id) + print(f"Got starting squad from gameweek {starting_gw}. Adding player data...") + free_hit = free_hit_used_in_gameweek(starting_gw, fpl_team_id) + time = fetcher.get_event_data()[starting_gw]["deadline"] for pid in init_players: player_api_id = get_player(pid).fpl_api_id first_gw_data = fetcher.get_gameweek_data_for_player(player_api_id, starting_gw) @@ -108,7 +177,18 @@ def fill_initial_squad( else: price = first_gw_data[0]["value"] - add_transaction(pid, 1, 1, price, season, tag, free_hit, fpl_team_id, dbsession) + add_transaction( + pid, + starting_gw, + 1, + price, + season, + tag, + free_hit, + fpl_team_id, + time, + dbsession, + ) def update_squad( @@ -127,7 +207,10 @@ def update_squad( print("Updating db with squad with fpl_team_id={}".format(fpl_team_id)) # do we already have the initial squad for this fpl_team_id? existing_transfers = ( - dbsession.query(Transaction).filter_by(fpl_team_id=fpl_team_id).all() + dbsession.query(Transaction) + .filter_by(fpl_team_id=fpl_team_id) + .filter_by(season=season) + .all() ) if len(existing_transfers) == 0: # need to put the initial squad into the db @@ -141,34 +224,57 @@ def update_squad( api_pid_out = transfer["element_out"] pid_out = get_player_from_api_id(api_pid_out).player_id price_out = transfer["element_out_cost"] - if verbose: - print( - "Adding transaction: gameweek: {} removing player {} for {}".format( - gameweek, pid_out, price_out - ) - ) - free_hit = free_hit_used_in_gameweek(gameweek) - add_transaction( - pid_out, - gameweek, - -1, - price_out, - season, - tag, - free_hit, - fpl_team_id, - dbsession, - ) api_pid_in = transfer["element_in"] pid_in = get_player_from_api_id(api_pid_in).player_id price_in = transfer["element_in_cost"] - if verbose: - print( - "Adding transaction: gameweek: {} adding player {} for {}".format( - gameweek, pid_in, price_in + time = transfer["time"] + + if not transaction_exists( + fpl_team_id, + gameweek, + season, + time, + pid_out, + price_out, + pid_in, + price_in, + dbsession=dbsession, + ): + if verbose: + print( + "Adding transaction: gameweek: {} removing player {} for {}".format( + gameweek, pid_out, price_out + ) ) + free_hit = free_hit_used_in_gameweek(gameweek) + add_transaction( + pid_out, + gameweek, + -1, + price_out, + season, + tag, + free_hit, + fpl_team_id, + time, + dbsession, + ) + + if verbose: + print( + "Adding transaction: gameweek: {} adding player {} for {}".format( + gameweek, pid_in, price_in + ) + ) + add_transaction( + pid_in, + gameweek, + 1, + price_in, + season, + tag, + free_hit, + fpl_team_id, + time, + dbsession, ) - add_transaction( - pid_in, gameweek, 1, price_in, season, tag, free_hit, fpl_team_id, dbsession - ) - pass diff --git a/airsenal/framework/utils.py b/airsenal/framework/utils.py index e6260249..0e522d15 100644 --- a/airsenal/framework/utils.py +++ b/airsenal/framework/utils.py @@ -4,20 +4,18 @@ from functools import lru_cache from operator import itemgetter -from datetime import datetime, timezone -from dateutil.relativedelta import relativedelta +from datetime import datetime, timezone, date from typing import TypeVar import dateparser import re from pickle import loads, dumps -from sqlalchemy import or_, case, func, desc +from sqlalchemy import or_, case, desc from airsenal.framework.mappings import alternative_player_names from airsenal.framework.data_fetcher import FPLDataFetcher from airsenal.framework.schema import ( Player, PlayerAttributes, - Result, Fixture, PlayerScore, PlayerPrediction, @@ -36,54 +34,22 @@ def get_max_gameweek(season=CURRENT_SEASON, dbsession=session): generally be 38, but may be different in the case of major disruptino (e.g. Covid-19) """ - max_gw = ( - dbsession.query(func.max(Fixture.gameweek)).filter_by(season=season).first()[0] + max_gw_fixture = ( + dbsession.query(Fixture) + .filter_by(season=season) + .order_by(Fixture.gameweek.desc()) + .first() ) - if max_gw is None: + + if max_gw_fixture is None: # TODO Tests fail without this as tests don't populate fixture table in db max_gw = 100 + else: + max_gw = max_gw_fixture.gameweek return max_gw -def in_mid_gameweek(season=CURRENT_SEASON, dbsession=None, verbose=False): - """ - Use the current time to figure out whether we're in the middle of a gameweek - """ - if not dbsession: - dbsession = session - timenow = datetime.now(timezone.utc) - # find the most recent and the next fixtures, relative to now. - most_recent_fixture = None - most_recent_fixture_time = timenow - relativedelta(years=1) - next_fixture = None - next_fixture_time = timenow + relativedelta(years=1) - fixtures = dbsession.query(Fixture).filter_by(season=season).all() - for fixture in fixtures: - if not fixture.date: - continue - fixture_date = dateparser.parse(fixture.date) - fixture_date = fixture_date.replace(tzinfo=timezone.utc) - if fixture_date < timenow and fixture_date > most_recent_fixture_time: - most_recent_fixture = fixture - most_recent_fixture_time = fixture_date - elif fixture_date > timenow and fixture_date < next_fixture_time: - next_fixture = fixture - next_fixture_time = fixture_date - if verbose: - print( - "Last fixture was {}/{}, next fixture is {}/{}".format( - most_recent_fixture.date, - most_recent_fixture.gameweek, - next_fixture.date, - next_fixture.gameweek, - ) - ) - # see if the most recent and next fixtures are both in the same gameweek. - # if so, return True, as we are in the middle of a gameweek. - return most_recent_fixture.gameweek == next_fixture.gameweek - - def get_next_gameweek(season=CURRENT_SEASON, dbsession=None): """ Use the current time to figure out which gameweek we're in @@ -190,11 +156,12 @@ def get_current_players(gameweek=None, season=None, fpl_team_id=None, dbsession= current_players = [] transactions = ( dbsession.query(Transaction) - .filter_by(season=season) + .order_by(Transaction.gameweek, Transaction.id) .filter_by(fpl_team_id=fpl_team_id) - .order_by(Transaction.gameweek) + .filter_by(free_hit=0) # free_hit players shouldn't be considered part of squad .all() ) + if len(transactions) == 0: #  not updated the transactions table yet return [] @@ -231,53 +198,6 @@ def get_squad_value( return total_value -def get_sell_price_for_player(player_id, gameweek=None, fpl_team_id=None): - """ - find the price we bought the player for, - and the price at the specified gameweek, - if the price increased in that time, we only get half the profit. - if gameweek is None, get price we could sell the player for now. - """ - if not fpl_team_id: - fpl_team_id = fetcher.FPL_TEAM_ID - transactions = session.query(Transaction) - transactions = transactions.filter_by(fpl_team_id=fpl_team_id) - transactions = transactions.filter_by(player_id=player_id) - transactions = transactions.order_by(Transaction.gameweek).all() - - gw_bought = None - for t in transactions: - if gameweek and t.gameweek > gameweek: - break - if t.bought_or_sold == 1: - gw_bought = t.gameweek - - if not gw_bought: - print( - "Player {} is was not in the team at gameweek {}".format( - player_id, gameweek - ) - ) - # to query the API we need to use fpl_api_id for the player rather than player_id - player_api_id = get_player(player_id).fpl_api_id - - pdata_bought = fetcher.get_gameweek_data_for_player(player_api_id, gw_bought) - # will be a list - can be more than one match in a gw - just use the 1st. - price_bought = pdata_bought[0]["value"] - - if not gameweek: # assume we want the current (i.e. next) gameweek - price_now = fetcher.get_player_summary_data()[player_api_id]["now_cost"] - else: - pdata_now = fetcher.get_gameweek_data_for_player(player_api_id, gw_bought) - price_now = pdata_now[0]["value"] - # take off our half of the profit - boo! - if price_now > price_bought: - value = (price_now + price_bought) // 2 # round down - else: - value = price_now - return value - - def get_bank(gameweek=None, fpl_team_id=None): """ Find out how much this FPL team had in the bank before the specified gameweek. @@ -323,20 +243,26 @@ def get_free_transfers(gameweek=None, fpl_team_id=None): return num_free_transfers -def get_gameweek_by_date(date, dbsession=None): +@lru_cache(maxsize=365) +def get_gameweek_by_date(check_date, season=CURRENT_SEASON, dbsession=None): """ Use the dates of the fixtures to find the gameweek. """ # convert date to a datetime object if it isn't already one. if not dbsession: dbsession = session - if not isinstance(date, datetime): - date = dateparser.parse(date) - fixtures = dbsession.query(Fixture).all() + if not isinstance(check_date, date): + if not isinstance(check_date, datetime): + check_date = dateparser.parse(check_date) + check_date = check_date.date() + query = dbsession.query(Fixture) + if season is not None: + query = query.filter_by(season=season) + fixtures = query.all() for fixture in fixtures: try: - fixture_date = dateparser.parse(fixture.date) - if fixture_date.date() == date.date(): + fixture_date = dateparser.parse(fixture.date).date() + if fixture_date == check_date: return fixture.gameweek except (TypeError): # NULL date if fixture not scheduled continue @@ -433,7 +359,7 @@ def get_player_id(player_name, dbsession=None): # not found by name in DB - try alternative names for k, v in alternative_player_names.items(): if player_name in v: - p = session.query(Player).filter_by(name=k).first() + p = dbsession.query(Player).filter_by(name=k).first() if p: return p.player_id break @@ -468,9 +394,21 @@ def list_players( if not dbsession: dbsession = session - # if trying to get players from the future, return current players - if season == CURRENT_SEASON and gameweek > NEXT_GAMEWEEK: - gameweek = NEXT_GAMEWEEK + # if trying to get players from after DB has filled, return most recent players + if season == CURRENT_SEASON: + last_pa = ( + dbsession.query(PlayerAttributes) + .filter_by(season=season) + .order_by(PlayerAttributes.gameweek.desc()) + .first() + ) + if last_pa and gameweek > last_pa.gameweek: + if verbose: + print( + f"WARNING: Incomplete data in DB for GW{gameweek}, " + f"returning players from GW{last_pa.gameweek}." + ) + gameweek = last_pa.gameweek gameweeks = [gameweek] # check if the team (or all teams) play in the specified gameweek, if not @@ -529,7 +467,7 @@ def list_players( players.append(p.player) prices.append(p.price) if verbose and (len(gameweeks) == 1 or order_by != "price"): - print(p.player.name, p.team, p.position, p.price) + print(p.player, p.team, p.position, p.price) if len(gameweeks) > 1 and order_by == "price": # Query sorted by gameweek first, so need to do a final sort here to # get final price order if more than one gameweek queried. @@ -662,11 +600,7 @@ def get_fixtures_for_player( if season == CURRENT_SEASON and fixture.gameweek < NEXT_GAMEWEEK: continue if verbose: - print( - "{} vs {} gameweek {}".format( - fixture.home_team, fixture.away_team, fixture.gameweek - ) - ) + print(fixture) fixtures.append(fixture) return fixtures @@ -713,15 +647,28 @@ def get_fixtures_for_gameweek(gameweek, season=CURRENT_SEASON, dbsession=session return [(fixture.home_team, fixture.away_team) for fixture in fixtures] -def get_result_for_fixture(fixture, dbsession=session): - """Get result for a fixture.""" - result = session.query(Result).filter_by(fixture=fixture).all() - return result +def get_player_scores(fixture=None, player=None, dbsession=session): + """Get player scores for a fixture.""" + if fixture is None and player is None: + raise ValueError("At least one of fixture and player must be defined") + query = dbsession.query(PlayerScore) + if fixture is not None: + query = query.filter(PlayerScore.fixture == fixture) + if player is not None: + query = query.filter(PlayerScore.player == player) -def get_player_scores_for_fixture(fixture, dbsession=session): - """Get player scores for a fixture.""" - player_scores = session.query(PlayerScore).filter_by(fixture=fixture).all() + player_scores = query.all() + if not player_scores: + return None + + if fixture is not None and player is not None: + if len(player_scores) > 1: + raise ValueError( + f"More than one score found for player {player} in fixture {fixture}" + ) + else: + return player_scores[0] return player_scores @@ -744,20 +691,20 @@ def get_players_for_gameweek(gameweek, fpl_team_id=None): return player_list -def get_previous_points_for_same_fixture(player, fixture_id): +def get_previous_points_for_same_fixture(player, fixture_id, dbsession=session): """ Search the past matches for same fixture in past seasons, and how many points the player got. """ if isinstance(player, str): - player_record = session.query(Player).filter_by(name=player).first() + player_record = dbsession.query(Player).filter_by(name=player).first() if not player_record: print("Can't find player {}".format(player)) return {} player_id = player_record.player_id else: player_id = player - fixture = session.query(Fixture).filter_by(fixture_id=fixture_id).first() + fixture = dbsession.query(Fixture).filter_by(fixture_id=fixture_id).first() if not fixture: print("Couldn't find fixture_id {}".format(fixture_id)) return {} @@ -765,7 +712,7 @@ def get_previous_points_for_same_fixture(player, fixture_id): away_team = fixture.away_team previous_matches = ( - session.query(Fixture) + dbsession.query(Fixture) .filter_by(home_team=home_team) .filter_by(away_team=away_team) .order_by(Fixture.season) @@ -775,7 +722,7 @@ def get_previous_points_for_same_fixture(player, fixture_id): previous_points = {} for fid in fixture_ids: scores = ( - session.query(PlayerScore) + dbsession.query(PlayerScore) .filter_by(player_id=player_id, fixture_id=fid[0]) .all() ) @@ -955,30 +902,30 @@ def get_top_predicted_points( print("-" * 25) -def get_return_gameweek_for_player(player_api_id, dbsession=None): +def get_return_gameweek_from_news(news, season=CURRENT_SEASON, dbsession=None): + """Parse news strings from the FPL API for the return date of injured or + suspended players. If a date is found, determine and return the gameweek it + corresponds to. """ - If a player is injured and there is 'news' about them on FPL, - parse this string to get expected return date. - """ - pdata = fetcher.get_player_summary_data()[player_api_id] rd_rex = "(Expected back|Suspended until)[\\s]+([\\d]+[\\s][\\w]{3})" - if "news" in pdata.keys() and re.search(rd_rex, pdata["news"]): - - return_str = re.search(rd_rex, pdata["news"]).groups()[1] + if re.search(rd_rex, news): + return_str = re.search(rd_rex, news).groups()[1] # return_str should be a day and month string (without year) # create a date in the future from the day and month string return_date = dateparser.parse( return_str, settings={"PREFER_DATES_FROM": "future"} ) - if not return_date: raise ValueError( "Failed to parse date from string '{}'".format(return_date) ) - return_gameweek = get_gameweek_by_date(return_date, dbsession=dbsession) + return_gameweek = get_gameweek_by_date( + return_date.date(), season=season, dbsession=dbsession + ) return return_gameweek + return None @@ -1039,8 +986,6 @@ def get_recent_playerscore_rows( if not dbsession: dbsession = session - if not last_gw: - last_gw = NEXT_GAMEWEEK # If asking for gameweeks without results in DB, revert to most recent results. last_available_gameweek = get_last_complete_gameweek_in_db( season=season, dbsession=dbsession @@ -1049,7 +994,7 @@ def get_recent_playerscore_rows( # e.g. before this season has started return None - if last_gw > last_available_gameweek: + if last_gw is None or last_gw > last_available_gameweek: last_gw = last_available_gameweek first_gw = last_gw - num_match_to_use @@ -1127,25 +1072,19 @@ def get_last_complete_gameweek_in_db(season=CURRENT_SEASON, dbsession=None): """ query the result table to see what was the last gameweek for which we have filled the data. - Note that if we run this command while a gameweek is ongoing, we - want to return the week _before_ the latest result's gameweek, as - that will be the last complete gameweek. """ if not dbsession: dbsession = session - last_result = ( + first_missing = ( dbsession.query(Fixture) .filter_by(season=season) - .filter(Fixture.result != None) # noqa: E711 - .order_by(Fixture.gameweek.desc()) + .filter(Fixture.result == None) # noqa: E711 + .filter(Fixture.gameweek != None) # noqa: E711 + .order_by(Fixture.gameweek) .first() ) - if last_result: - # now check whether we're in the middle of a gameweek - if in_mid_gameweek(season=season, dbsession=dbsession): - return last_result.gameweek - 1 - else: - return last_result.gameweek + if first_missing: + return first_missing.gameweek - 1 else: return None @@ -1200,17 +1139,18 @@ def get_latest_fixture_tag(season=CURRENT_SEASON, dbsession=None): def find_fixture( - gameweek, team, was_home=None, other_team=None, - kickoff_time=None, + gameweek=None, season=CURRENT_SEASON, + kickoff_time=None, dbsession=session, ): - """Get a fixture given a gameweek, team and optionally whether - the team was at home or away, the kickoff time and the other team in the - fixture. + """Get a fixture given a team and optionally whether the team was at home or away, + the season, kickoff time and the other team in the fixture. Only returns the fixture + if exactly one is found that matches the input arguments, otherwise raises a + ValueError. """ fixture = None @@ -1227,9 +1167,9 @@ def find_fixture( else: other_team_name = other_team - query = ( - dbsession.query(Fixture).filter_by(gameweek=gameweek).filter_by(season=season) - ) + query = dbsession.query(Fixture).filter_by(season=season) + if gameweek: + query = query.filter_by(gameweek=gameweek) if was_home is True: query = query.filter_by(home_team=team_name) elif was_home is False: @@ -1260,8 +1200,10 @@ def find_fixture( raise ValueError( ( "No fixture with season={}, gw={}, team_name={}, was_home={}, " - "other_team_name={}" - ).format(season, gameweek, team_name, was_home, other_team_name) + "other_team_name={}, kickoff_time={}" + ).format( + season, gameweek, team_name, was_home, other_team_name, kickoff_time + ) ) if len(fixtures) == 1: @@ -1315,11 +1257,11 @@ def get_player_team_from_fixture( opponent_was_home = None fixture = find_fixture( - gameweek, opponent, was_home=opponent_was_home, - kickoff_time=kickoff_time, + gameweek=gameweek, season=season, + kickoff_time=kickoff_time, dbsession=dbsession, ) @@ -1352,5 +1294,5 @@ def get_player_team_from_fixture( def fastcopy(obj: T) -> T: - """ faster replacement for copy.deepcopy()""" + """faster replacement for copy.deepcopy()""" return loads(dumps(obj, -1)) diff --git a/airsenal/scripts/airsenal_run_pipeline.py b/airsenal/scripts/airsenal_run_pipeline.py index 743029e8..43f52494 100644 --- a/airsenal/scripts/airsenal_run_pipeline.py +++ b/airsenal/scripts/airsenal_run_pipeline.py @@ -4,7 +4,8 @@ import click -from airsenal import TMPDIR +from airsenal.framework.db_config import AIrsenalDBFile +from airsenal.framework.schema import session, Team from airsenal.framework.utils import NEXT_GAMEWEEK, fetcher @@ -35,21 +36,32 @@ required=False, help="fpl team id for pipeline run", ) +@click.option( + "--clean", + is_flag=True, + help="If set, delete and recreate the AIrsenal database", +) def run_pipeline( - num_thread, num_iterations, weeks_ahead, num_free_transfers, fpl_team_id + num_thread, num_iterations, weeks_ahead, num_free_transfers, fpl_team_id, clean ): if fpl_team_id is None: fpl_team_id = fetcher.FPL_TEAM_ID print("Running for FPL Team ID {}".format(fpl_team_id)) if not num_thread: num_thread = multiprocessing.cpu_count() - click.echo("Cleaning database..") - clean_database() - click.echo("Setting up Database..") - setup_database(fpl_team_id) - click.echo("Database setup complete..") + if clean: + click.echo("Cleaning database..") + clean_database() + if database_is_empty(): + click.echo("Setting up Database..") + setup_database(fpl_team_id) + click.echo("Database setup complete..") + update_attr = False + else: + click.echo("Found pre-existing AIrsenal database.") + update_attr = True click.echo("Updating database..") - update_database(fpl_team_id) + update_database(fpl_team_id, attr=update_attr) click.echo("Database update complete..") click.echo("Running prediction..") run_prediction(num_thread, weeks_ahead) @@ -62,21 +74,31 @@ def run_pipeline( click.echo("Running optimization..") run_optimization(num_thread, weeks_ahead, num_free_transfers, fpl_team_id) click.echo("Optimization complete..") + click.echo("Applying suggested transfers...") + make_transfers(fpl_team_id) def clean_database(): """ Clean up database """ - file_path = "{}/data.db".format(TMPDIR) try: - if os.path.exists(file_path): - os.remove(file_path) + if os.path.exists(AIrsenalDBFile): + os.remove(AIrsenalDBFile) except IOError as exc: - click.echo("Error while deleting file {}. Reason:{}".format(file_path, exc)) + click.echo( + "Error while deleting file {}. Reason:{}".format(AIrsenalDBFile, exc) + ) sys.exit(1) +def database_is_empty(): + """ + Basic check to determine whether the database is empty + """ + return session.query(Team).first() is None + + def setup_database(fpl_team_id): """ Set up database @@ -84,11 +106,14 @@ def setup_database(fpl_team_id): os.system("airsenal_setup_initial_db --fpl_team_id {}".format(fpl_team_id)) -def update_database(fpl_team_id): +def update_database(fpl_team_id, attr=True): """ Update database """ - os.system("airsenal_update_db --noattr --fpl_team_id {}".format(fpl_team_id)) + if attr: + os.system("airsenal_update_db --fpl_team_id {}".format(fpl_team_id)) + else: + os.system("airsenal_update_db --noattr --fpl_team_id {}".format(fpl_team_id)) def run_prediction(num_thread, weeks_ahead): @@ -122,6 +147,17 @@ def run_optimization(num_thread, weeks_ahead, num_free_transfers, fpl_team_id): os.system(cmd) +def make_transfers(fpl_team_id=None): + """ + Post transfers from transfer suggestion table. + + Team id not necessary as will be taken from transfer suggestion table. + """ + + cmd = ("airsenal_make_transfers --fpl_team_id {}").format(fpl_team_id) + os.system(cmd) + + def main(): sys.exit() diff --git a/airsenal/scripts/data_sanity_checks.py b/airsenal/scripts/data_sanity_checks.py index 8b447d29..09710c4e 100644 --- a/airsenal/scripts/data_sanity_checks.py +++ b/airsenal/scripts/data_sanity_checks.py @@ -3,8 +3,7 @@ session, CURRENT_SEASON, get_fixtures_for_season, - get_result_for_fixture, - get_player_scores_for_fixture, + get_player_scores, ) from airsenal.framework.schema import PlayerScore @@ -14,47 +13,12 @@ SEPARATOR = "\n" + ("=" * 50) + "\n" # used to separate groups of print statements -def fixture_string(fixture, result=None): - """Get a string with basic info about a fixture. - - Arguments: - fixture {SQLAlchemy class object} -- fixture from the database. - result {SQLAlchemy class object} -- result from the database. If given - returned string contains the match score. - - Returns: - [string] -- formatted string with id, season, gameweek, home team and - away team. - """ - - if result: - return "{} GW{} {} {}-{} {} (id {})".format( - fixture.season, - fixture.gameweek, - fixture.home_team, - result.home_score, - result.away_score, - fixture.away_team, - fixture.fixture_id, - ) - - else: - return "{} GW{} {} vs {} (id {})".format( - fixture.season, - fixture.gameweek, - fixture.home_team, - fixture.away_team, - fixture.fixture_id, - ) - - def result_string(n_error): """make string representing check result Arguments: n_error {int} -- number of errors encountered during check """ - if n_error == 0: return "OK!" else: @@ -146,22 +110,23 @@ def fixture_player_teams(seasons=CHECK_SEASONS, session=session): fixtures = get_fixtures_for_season(season=season) for fixture in fixtures: - player_scores = get_player_scores_for_fixture(fixture) - - for score in player_scores: - if not ( - (score.player_team == fixture.home_team) - or (score.player_team == fixture.away_team) - ): - n_error += 1 - msg = ( - "{}: {} in player_scores but labelled as playing for {}." - ).format( - fixture_string(fixture), - score.player.name, - score.player_team, - ) - print(msg) + if fixture.result: + player_scores = get_player_scores(fixture=fixture) + + for score in player_scores: + if not ( + (score.player_team == fixture.home_team) + or (score.player_team == fixture.away_team) + ): + n_error += 1 + msg = ( + "{}: {} in player_scores but labelled as playing for {}." + ).format( + fixture, + score.player, + score.player_team, + ) + print(msg) print("\n", result_string(n_error)) return n_error @@ -177,8 +142,10 @@ def fixture_num_players(seasons=CHECK_SEASONS, session=session): airsenal.framework.schema.session) """ print( - "Checking 11 to 14 players play per team in each fixture " - "(with exceptions for 19/20)...\n" + "Checking 11 to 14 players play per team in each fixture...\n" + "Note:\n" + "- 2019/20: 5 subs allowed after Covid-19 lockdown (accounted for in checks)\n" + "- From 2020/21: Concussion subs allowed (may cause false errors)\n" ) n_error = 0 @@ -186,10 +153,9 @@ def fixture_num_players(seasons=CHECK_SEASONS, session=session): fixtures = get_fixtures_for_season(season=season) for fixture in fixtures: - result = get_result_for_fixture(fixture) + result = fixture.result if result: - result = result[0] home_scores = ( session.query(PlayerScore) .filter_by(fixture=fixture, player_team=fixture.home_team) @@ -216,7 +182,7 @@ def fixture_num_players(seasons=CHECK_SEASONS, session=session): n_error += 1 print( "{}: {} players with minutes > 0 for home team.".format( - fixture_string(fixture, result), len(home_scores) + result, len(home_scores) ) ) @@ -226,7 +192,7 @@ def fixture_num_players(seasons=CHECK_SEASONS, session=session): n_error += 1 print( "{}: {} players with minutes > 0 for away team.".format( - fixture_string(fixture, result), len(away_scores) + result, len(away_scores) ) ) @@ -249,10 +215,9 @@ def fixture_num_goals(seasons=CHECK_SEASONS, session=session): fixtures = get_fixtures_for_season(season=season) for fixture in fixtures: - result = get_result_for_fixture(fixture) + result = fixture.result if result: - result = result[0] home_scores = ( session.query(PlayerScore) .filter_by(fixture=fixture, player_team=fixture.home_team) @@ -279,7 +244,7 @@ def fixture_num_goals(seasons=CHECK_SEASONS, session=session): "{}: Player scores sum to {} but {} goals in result " "for home team" ).format( - fixture_string(fixture, result), + result, home_goals, result.home_score, ) @@ -291,7 +256,7 @@ def fixture_num_goals(seasons=CHECK_SEASONS, session=session): "{}: Player scores sum to {} but {} goals in result " "for away team" ).format( - fixture_string(fixture, result), + result, away_goals, result.away_score, ) @@ -319,10 +284,8 @@ def fixture_num_assists(seasons=CHECK_SEASONS, session=session): fixtures = get_fixtures_for_season(season=season) for fixture in fixtures: - result = get_result_for_fixture(fixture) - + result = fixture.result if result: - result = result[0] home_scores = ( session.query(PlayerScore) .filter_by(fixture=fixture, player_team=fixture.home_team) @@ -344,7 +307,7 @@ def fixture_num_assists(seasons=CHECK_SEASONS, session=session): "{}: Player assists sum to {} but {} goals in result " "for home team" ).format( - fixture_string(fixture, result), + result, home_assists, result.home_score, ) @@ -356,7 +319,7 @@ def fixture_num_assists(seasons=CHECK_SEASONS, session=session): "{}: Player assists sum to {} but {} goals in result " "for away team" ).format( - fixture_string(fixture, result), + result, away_assists, result.away_score, ) @@ -384,10 +347,8 @@ def fixture_num_conceded(seasons=CHECK_SEASONS, session=session): fixtures = get_fixtures_for_season(season=season) for fixture in fixtures: - result = get_result_for_fixture(fixture) - + result = fixture.result if result: - result = result[0] home_scores = ( session.query(PlayerScore) .filter_by( @@ -411,7 +372,7 @@ def fixture_num_conceded(seasons=CHECK_SEASONS, session=session): n_error += 1 msg = "{}: Player conceded {} but {} goals in result for home team" msg = msg.format( - fixture_string(fixture, result), + result, home_conceded, result.away_score, ) @@ -421,7 +382,7 @@ def fixture_num_conceded(seasons=CHECK_SEASONS, session=session): n_error += 1 msg = "{}: Player conceded {} but {} goals in result for away team" msg = msg.format( - fixture_string(fixture, result), + result, away_conceded, result.home_score, ) diff --git a/airsenal/scripts/fill_fixture_table.py b/airsenal/scripts/fill_fixture_table.py index ea7db589..650f0bc0 100644 --- a/airsenal/scripts/fill_fixture_table.py +++ b/airsenal/scripts/fill_fixture_table.py @@ -12,7 +12,7 @@ from airsenal.framework.data_fetcher import FPLDataFetcher from airsenal.framework.mappings import alternative_team_names from airsenal.framework.schema import Fixture, session_scope, session -from airsenal.framework.utils import CURRENT_SEASON, get_past_seasons +from airsenal.framework.utils import CURRENT_SEASON, find_fixture, get_past_seasons def fill_fixtures_from_file(filename, season, dbsession=session): @@ -47,7 +47,18 @@ def fill_fixtures_from_api(season, dbsession=session): fetcher = FPLDataFetcher() fixtures = fetcher.get_fixture_data() for fixture in fixtures: - f = Fixture() + try: + f = find_fixture( + fixture["team_h"], + was_home=True, + other_team=fixture["team_a"], + season=season, + dbsession=dbsession, + ) + update = True + except ValueError: + f = Fixture() + update = False f.date = fixture["kickoff_time"] f.gameweek = fixture["event"] @@ -78,7 +89,8 @@ def fill_fixtures_from_api(season, dbsession=session): else: pass - dbsession.add(f) + if not update: + dbsession.add(f) dbsession.commit() return True diff --git a/airsenal/scripts/fill_player_attributes_table.py b/airsenal/scripts/fill_player_attributes_table.py index 3f686a62..d002216a 100644 --- a/airsenal/scripts/fill_player_attributes_table.py +++ b/airsenal/scripts/fill_player_attributes_table.py @@ -11,7 +11,7 @@ from airsenal.framework.schema import PlayerAttributes, session_scope, session from airsenal.framework.utils import ( - NEXT_GAMEWEEK, + get_next_gameweek, get_player, get_player_from_api_id, get_team_name, @@ -19,6 +19,7 @@ CURRENT_SEASON, get_player_attributes, get_player_team_from_fixture, + get_return_gameweek_from_news, ) from airsenal.framework.data_fetcher import FPLDataFetcher @@ -37,7 +38,7 @@ def fill_attributes_table_from_file(detail_data, season, dbsession=session): print("Couldn't find player {}".format(player_name)) continue - print("ATTRIBUTES {} {}".format(season, player.name)) + print("ATTRIBUTES {} {}".format(season, player)) # now loop through all the fixtures that player played in #  Only one attributes row per gameweek - create list of gameweeks # encountered so can ignore duplicates (e.g. from double gameweeks). @@ -65,13 +66,12 @@ def fill_attributes_table_from_file(detail_data, season, dbsession=session): dbsession.add(pa) -def fill_attributes_table_from_api( - season, gw_start=1, gw_end=NEXT_GAMEWEEK, dbsession=session -): +def fill_attributes_table_from_api(season, gw_start=1, dbsession=session): """ use the FPL API to get player attributes info for the current season """ fetcher = FPLDataFetcher() + next_gw = get_next_gameweek(season=season, dbsession=dbsession) # needed for selected by calculation from percentage below n_players = fetcher.get_current_summary_data()["total_players"] @@ -94,7 +94,7 @@ def fill_attributes_table_from_api( position = positions[p_summary["element_type"]] pa = get_player_attributes( - player.player_id, season=season, gameweek=NEXT_GAMEWEEK, dbsession=dbsession + player.player_id, season=season, gameweek=next_gw, dbsession=dbsession ) if pa: # found pre-existing attributes for this gameweek @@ -107,7 +107,7 @@ def fill_attributes_table_from_api( pa.player = player pa.player_id = player.player_id pa.season = season - pa.gameweek = NEXT_GAMEWEEK + pa.gameweek = next_gw pa.price = int(p_summary["now_cost"]) pa.team = get_team_name(p_summary["team"], season=season, dbsession=dbsession) pa.position = positions[p_summary["element_type"]] @@ -115,6 +115,17 @@ def fill_attributes_table_from_api( pa.transfers_in = int(p_summary["transfers_in_event"]) pa.transfers_out = int(p_summary["transfers_out_event"]) pa.transfers_balance = pa.transfers_in - pa.transfers_out + pa.chance_of_playing_next_round = p_summary["chance_of_playing_next_round"] + pa.news = p_summary["news"] + if ( + pa.chance_of_playing_next_round is not None + and pa.chance_of_playing_next_round <= 50 + ): + pa.return_gameweek = get_return_gameweek_from_news( + p_summary["news"], + season=season, + dbsession=dbsession, + ) if not update: # only need to add to the dbsession for new entries, if we're doing @@ -123,8 +134,11 @@ def fill_attributes_table_from_api( # now get data for previous gameweeks player_data = fetcher.get_gameweek_data_for_player(player_api_id) + if not player_data: + print("Failed to get data for", player.name) + continue for gameweek, data in player_data.items(): - if gameweek not in range(gw_start, gw_end): + if gameweek < gw_start: continue for result in data: @@ -166,7 +180,7 @@ def fill_attributes_table_from_api( pa.transfers_in = int(result["transfers_in"]) pa.transfers_out = int(result["transfers_out"]) - if update: + if not update: # don't need to add to dbsession if updating pre-existing row dbsession.add(pa) diff --git a/airsenal/scripts/fill_player_table.py b/airsenal/scripts/fill_player_table.py index b8e56df7..1d4cf89e 100644 --- a/airsenal/scripts/fill_player_table.py +++ b/airsenal/scripts/fill_player_table.py @@ -11,23 +11,23 @@ from airsenal.framework.utils import CURRENT_SEASON, get_past_seasons -def find_player_in_table(name, session): +def find_player_in_table(name, dbsession): """ see if we already have the player """ - player = session.query(Player).filter_by(name=name).first() + player = dbsession.query(Player).filter_by(name=name).first() return player if player else None -def num_players_in_table(session): +def num_players_in_table(dbsession): """ how many players already in player table """ - players = session.query(Player).all() + players = dbsession.query(Player).all() return len(players) -def fill_player_table_from_file(filename, season, session): +def fill_player_table_from_file(filename, season, dbsession): """ use json file """ @@ -37,7 +37,7 @@ def fill_player_table_from_file(filename, season, session): new_entry = False name = jp["name"] print("PLAYER {} {}".format(season, name)) - p = find_player_in_table(name, session) + p = find_player_in_table(name, dbsession) if not p: n_new_players += 1 new_entry = True @@ -47,11 +47,11 @@ def fill_player_table_from_file(filename, season, session): # ) # next id sequentially p.name = name if new_entry: - session.add(p) - session.commit() + dbsession.add(p) + dbsession.commit() -def fill_player_table_from_api(season, session): +def fill_player_table_from_api(season, dbsession): """ use the FPL API """ @@ -67,8 +67,8 @@ def fill_player_table_from_api(season, session): print("PLAYER {} {}".format(season, name)) p.name = name - session.add(p) - session.commit() + dbsession.add(p) + dbsession.commit() def make_player_table(seasons=[], dbsession=session): @@ -77,7 +77,7 @@ def make_player_table(seasons=[], dbsession=session): seasons = [CURRENT_SEASON] seasons += get_past_seasons(3) if CURRENT_SEASON in seasons: - fill_player_table_from_api(CURRENT_SEASON, session) + fill_player_table_from_api(CURRENT_SEASON, dbsession) for season in seasons: if season == CURRENT_SEASON: continue @@ -89,7 +89,7 @@ def make_player_table(seasons=[], dbsession=session): "player_summary_{}.json".format(season), ) ) - fill_player_table_from_file(filename, season, session) + fill_player_table_from_file(filename, season, dbsession) if __name__ == "__main__": diff --git a/airsenal/scripts/fill_playerscore_table.py b/airsenal/scripts/fill_playerscore_table.py index 406e5c45..4772f2f4 100644 --- a/airsenal/scripts/fill_playerscore_table.py +++ b/airsenal/scripts/fill_playerscore_table.py @@ -18,6 +18,7 @@ CURRENT_SEASON, find_fixture, get_player_team_from_fixture, + get_player_scores, ) @@ -30,7 +31,7 @@ def fill_playerscores_from_json(detail_data, season, dbsession=session): print("Couldn't find player {}".format(player_name)) continue - print("SCORES {} {}".format(season, player.name)) + print("SCORES {} {}".format(season, player)) # now loop through all the fixtures that player played in for fixture_data in detail_data[player_name]: # try to find the result in the result table @@ -50,21 +51,17 @@ def fill_playerscores_from_json(detail_data, season, dbsession=session): was_home = None fixture = find_fixture( - gameweek, played_for, - other_team=fixture_data["opponent"], was_home=was_home, - kickoff_time=fixture_data["kickoff_time"], + other_team=fixture_data["opponent"], + gameweek=gameweek, season=season, + kickoff_time=fixture_data["kickoff_time"], dbsession=dbsession, ) - if not fixture: - print( - " Couldn't find result for {} in gw {}".format( - player.name, gameweek - ) - ) + if not fixture or not fixture.result: + print(" Couldn't find result for {} in gw {}".format(player, gameweek)) continue ps = PlayerScore() ps.player_team = played_for @@ -107,21 +104,23 @@ def fill_playerscores_from_json(detail_data, season, dbsession=session): pass dbsession.add(ps) + dbsession.commit() def fill_playerscores_from_api( season, gw_start=1, gw_end=NEXT_GAMEWEEK, dbsession=session ): - fetcher = FPLDataFetcher() input_data = fetcher.get_player_summary_data() for player_api_id in input_data.keys(): - # find the player in the player table. If they're not - # there, then we don't care (probably not a current player). player = get_player_from_api_id(player_api_id, dbsession=dbsession) if not player: - print("No player with API id {}".format(player_api_id)) - print("SCORES {} {}".format(season, player.name)) + # If no player found with this API ID something has gone wrong with the + # Player table, e.g. clashes between players with the same name + print(f"ERROR! No player with API id {player_api_id}. Skipped.") + continue + + print("SCORES {} {}".format(season, player)) player_data = fetcher.get_gameweek_data_for_player(player_api_id) # now loop through all the matches that player played in for gameweek, results in player_data.items(): @@ -141,15 +140,22 @@ def fill_playerscores_from_api( return_fixture=True, ) - if not fixture or not played_for: + if not fixture or not played_for or not fixture.result: print( - " Couldn't find match for {} in gw {}".format( - player.name, gameweek + " Couldn't find match result for {} in gw {}".format( + player, gameweek ) ) continue - ps = PlayerScore() + ps = get_player_scores( + fixture=fixture, player=player, dbsession=dbsession + ) + if ps is None: + ps = PlayerScore() + add = True + else: + add = False ps.player_team = played_for ps.opponent = opponent ps.goals = result["goals_scored"] @@ -189,12 +195,14 @@ def fill_playerscores_from_api( except KeyError: pass - dbsession.add(ps) + if add: + dbsession.add(ps) print( " got {} points vs {} in gameweek {}".format( result["total_points"], opponent, gameweek ) ) + dbsession.commit() def make_playerscore_table(seasons=[], dbsession=session): @@ -214,8 +222,6 @@ def make_playerscore_table(seasons=[], dbsession=session): if CURRENT_SEASON in seasons: fill_playerscores_from_api(CURRENT_SEASON, dbsession=dbsession) - dbsession.commit() - if __name__ == "__main__": with session_scope() as session: diff --git a/airsenal/scripts/fill_result_table.py b/airsenal/scripts/fill_result_table.py index 1028b28b..6010b5ca 100644 --- a/airsenal/scripts/fill_result_table.py +++ b/airsenal/scripts/fill_result_table.py @@ -9,32 +9,16 @@ import os from airsenal.framework.mappings import alternative_team_names -from airsenal.framework.schema import Result, session_scope, Fixture, session +from airsenal.framework.schema import Result, session_scope, session from airsenal.framework.data_fetcher import FPLDataFetcher from airsenal.framework.utils import ( NEXT_GAMEWEEK, - get_latest_fixture_tag, get_past_seasons, + find_fixture, CURRENT_SEASON, ) -def _find_fixture(season, home_team, away_team, dbsession): - """ - query database to find corresponding fixture - """ - tag = get_latest_fixture_tag(season) - f = ( - dbsession.query(Fixture) - .filter_by(tag=tag) - .filter_by(season=season) - .filter_by(home_team=home_team) - .filter_by(away_team=away_team) - .first() - ) - return f - - def fill_results_from_csv(input_file, season, dbsession): for line in input_file.readlines()[1:]: ( @@ -52,7 +36,13 @@ def fill_results_from_csv(input_file, season, dbsession): elif away_team in v: away_team = k # query database to find corresponding fixture - f = _find_fixture(season, home_team, away_team, dbsession) + f = find_fixture( + home_team, + was_home=True, + other_team=away_team, + season=season, + dbsession=dbsession, + ) res = Result() res.fixture = f res.home_score = int(home_score) @@ -85,12 +75,25 @@ def fill_results_from_api(gw_start, gw_end, season, dbsession): raise ValueError("Unable to find team with id {}".format(away_id)) home_score = m["team_h_score"] away_score = m["team_a_score"] - f = _find_fixture(season, home_team, away_team, dbsession) - res = Result() + f = find_fixture( + home_team, + was_home=True, + other_team=away_team, + gameweek=gameweek, + season=season, + dbsession=dbsession, + ) + if f.result is None: + res = Result() + add = True + else: + res = f.result + add = False res.fixture = f res.home_score = int(home_score) res.away_score = int(away_score) - dbsession.add(res) + if add: + dbsession.add(res) dbsession.commit() diff --git a/airsenal/scripts/fill_transfersuggestion_table.py b/airsenal/scripts/fill_transfersuggestion_table.py index 167d3521..b8897a74 100644 --- a/airsenal/scripts/fill_transfersuggestion_table.py +++ b/airsenal/scripts/fill_transfersuggestion_table.py @@ -21,12 +21,12 @@ import time import json import sys - +import warnings import cProfile from multiprocessing import Process -from tqdm import tqdm +from tqdm import tqdm, TqdmWarning import argparse from airsenal.framework.multiprocessing_utils import CustomQueue @@ -49,6 +49,7 @@ get_latest_prediction_tag, get_next_gameweek, get_free_transfers, + fetcher, ) if os.name == "posix": @@ -380,6 +381,9 @@ def run_optimization( is not to be played, 0 for 'play it any week', or the gw in which it should be played. """ + if fpl_team_id is None: + fpl_team_id = fetcher.FPL_TEAM_ID + print("Running optimization with fpl_team_id {}".format(fpl_team_id)) # How many free transfers are we starting with? if not num_free_transfers: @@ -494,10 +498,11 @@ def update_progress(increment=1, index=None): best_strategy = find_best_strat_from_json(tag) baseline_score = find_baseline_score_from_json(tag, num_weeks) - fill_suggestion_table(baseline_score, best_strategy, season) + fill_suggestion_table(baseline_score, best_strategy, season, fpl_team_id) for i in range(len(procs)): print("\n") print("\n====================================\n") + print("Strategy for Team ID: {}".format(fpl_team_id)) print("Baseline score: {}".format(baseline_score)) print("Best score: {}".format(best_strategy["total_score"])) print_strat(best_strategy) @@ -673,18 +678,19 @@ def main(): "same input gameweeks and season you specified here.", ) sys.exit(1) - - run_optimization( - gameweeks, - tag, - season, - fpl_team_id, - chip_gameweeks, - num_free_transfers, - max_total_hit, - allow_unused_transfers, - 2, - num_iterations, - num_thread, - profile, - ) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", TqdmWarning) + run_optimization( + gameweeks, + tag, + season, + fpl_team_id, + chip_gameweeks, + num_free_transfers, + max_total_hit, + allow_unused_transfers, + 2, + num_iterations, + num_thread, + profile, + ) diff --git a/airsenal/scripts/get_transfer_suggestions.py b/airsenal/scripts/get_transfer_suggestions.py index af6a6ddd..5dfb68fd 100644 --- a/airsenal/scripts/get_transfer_suggestions.py +++ b/airsenal/scripts/get_transfer_suggestions.py @@ -1,17 +1,22 @@ #!/usr/bin/env python - """ -query the transfer_suggestion table. Each row of the table -will be in individual player in-or-out in a gameweek - we -therefore need to group together all the rows that correspond -to the same transfer strategy. We do this using the "timestamp". +query the transfer suggestion table and print the suggested strategy + """ + from airsenal.framework.schema import TransferSuggestion from airsenal.framework.utils import session, get_player_name -if __name__ == "__main__": - all_rows = session.query(TransferSuggestion).all() + +def get_transfer_suggestions(currentsession, Suggestions): + """ + query the transfer_suggestion table. Each row of the table + will be in individual player in-or-out in a gameweek - we + therefore need to group together all the rows that correspond + to the same transfer strategy. We do this using the "timestamp". + """ + all_rows = currentsession.query(Suggestions).all() last_timestamp = all_rows[-1].timestamp rows = ( session.query(TransferSuggestion) @@ -19,6 +24,10 @@ .order_by(TransferSuggestion.gameweek) .all() ) + return rows + + +def build_strategy_string(rows): output_string = "Suggested transfer strategy: \n" current_gw = 0 for row in rows: @@ -31,4 +40,10 @@ output_string += " buy " output_string += get_player_name(row.player_id) + "," output_string += " for a total gain of {} points.".format(rows[0].points_gain) + return output_string + + +if __name__ == "__main__": + rows = get_transfer_suggestions(session, TransferSuggestion) + output_string = build_strategy_string(rows) print(output_string) diff --git a/airsenal/scripts/make_transfers.py b/airsenal/scripts/make_transfers.py new file mode 100644 index 00000000..52109404 --- /dev/null +++ b/airsenal/scripts/make_transfers.py @@ -0,0 +1,225 @@ +""" +Script to apply recommended transfers from the current transfer suggestion table. + +Ref: +https://github.com/sk82jack/PSFPL/blob/master/PSFPL/Public/Invoke-FplTransfer.ps1 +https://www.reddit.com/r/FantasyPL/comments/b4d6gv/fantasy_api_for_transfers/ +https://fpl.readthedocs.io/en/latest/_modules/fpl/models/user.html#User.transfer +""" +from prettytable import PrettyTable +import requests +import json +import getpass +from airsenal.framework.schema import TransferSuggestion +from airsenal.framework.optimization_utils import get_starting_squad +from airsenal.framework.utils import ( + session, + get_player_name, + get_bank, + get_player, +) +from airsenal.scripts.get_transfer_suggestions import get_transfer_suggestions +from airsenal.framework.data_fetcher import FPLDataFetcher + +""" +TODO: +- confirm points loss +- write a test. +""" + + +def check_proceed(): + proceed = input("Apply Transfers? There is no turning back! (yes/no)") + if proceed == "yes": + print("Applying Transfers...") + return True + else: + return False + + +def deduct_transfer_price(pre_bank, priced_transfers): + + gain = [transfer[0][1] - transfer[1][1] for transfer in priced_transfers] + return pre_bank + sum(gain) + + +def print_output( + team_id, current_gw, priced_transfers, pre_bank, post_bank, points_cost="TODO" +): + + print("\n") + header = f"Transfers to apply for fpl_team_id: {team_id} for gameweek: {current_gw}" + line = "=" * len(header) + print(f"{header} \n {line} \n") + + print(f"Bank Balance Before transfers is: £{pre_bank/10}") + + t = PrettyTable(["Status", "Name", "Price"]) + for transfer in priced_transfers: + t.add_row(["OUT", get_player_name(transfer[0][0]), f"£{transfer[0][1]/10}"]) + t.add_row(["IN", get_player_name(transfer[1][0]), f"£{transfer[1][1]/10}"]) + + print(t) + + print(f"Bank Balance After transfers is: £{post_bank/10}") + # print(f"Points Cost of Transfers: {points_cost}") + print("\n") + + +def get_sell_price(team_id, player_id): + + squad = get_starting_squad(team_id) + for p in squad.players: + if p.player_id == player_id: + return squad.get_sell_price_for_player(p) + + +def price_transfers(transfer_player_ids, fetcher, current_gw): + + transfers = list(zip(*transfer_player_ids)) # [(out,in),(out,in)] + + # [[[out, price], [in, price]],[[out,price],[in,price]]] + priced_transfers = [ + [ + [t[0], get_sell_price(fetcher.FPL_TEAM_ID, t[0])], + [ + t[1], + fetcher.get_player_summary_data()[get_player(t[1]).fpl_api_id][ + "now_cost" + ], + ], + ] + for t in transfers + ] + + return priced_transfers + + +def get_gw_transfer_suggestions(fpl_team_id=None): + + # gets the transfer suggestions for the latest optimization run, + # regardless of fpl_team_id + rows = get_transfer_suggestions(session, TransferSuggestion) + if fpl_team_id and fpl_team_id != rows[0].fpl_team_id: + raise Exception( + f"Team ID passed is {fpl_team_id}, but transfer suggestions are for \ + team ID {rows[0].fpl_team_id}. We recommend re-running optimization." + ) + else: + fpl_team_id = rows[0].fpl_team_id + current_gw, chip = rows[0].gameweek, rows[0].chip_played + players_out, players_in = [], [] + + for row in rows: + if row.gameweek == current_gw: + if row.in_or_out < 0: + players_out.append(row.player_id) + else: + players_in.append(row.player_id) + return ([players_out, players_in], fpl_team_id, current_gw, chip) + + +def build_transfer_payload(priced_transfers, current_gw, fetcher, chip_played): + def to_dict(t): + { + "element_out": get_player(t[0][0]).fpl_api_id, + "selling_price": t[0][1], + "element_in": get_player(t[1][0]).fpl_api_id, + "purchase_price": t[1][1], + } + + transfer_list = [to_dict(transfer) for transfer in priced_transfers] + + transfer_payload = { + "confirmed": False, + "entry": fetcher.FPL_TEAM_ID, # not sure what the entry should refer to? + "event": current_gw, + "transfers": transfer_list, + "wildcard": False, + "freehit": False, + } + if chip_played: + transfer_payload[chip_played.replace("_", "")] = True + + print(transfer_payload) + + return transfer_payload + + +def login(session, fetcher): + + if ( + (not fetcher.FPL_LOGIN) + or (not fetcher.FPL_PASSWORD) + or (fetcher.FPL_LOGIN == "MISSING_ID") + or (fetcher.FPL_PASSWORD == "MISSING_ID") + ): + fetcher.FPL_LOGIN = input("Please enter FPL login: ") + fetcher.FPL_PASSWORD = getpass.getpass("Please enter FPL password: ") + + # print("FPL credentials {} {}".format(fetcher.FPL_LOGIN, fetcher.FPL_PASSWORD)) + login_url = "https://users.premierleague.com/accounts/login/" + headers = { + "login": fetcher.FPL_LOGIN, + "password": fetcher.FPL_PASSWORD, + "app": "plfpl-web", + "redirect_uri": "https://fantasy.premierleague.com/a/login", + } + session.post(login_url, data=headers) + return session + + +def post_transfers(transfer_payload, fetcher): + + session = requests.session() + + session = login(session, fetcher) + + # adapted from https://github.com/amosbastian/fpl/blob/master/fpl/utils.py + headers = { + "Content-Type": "application/json; charset=UTF-8", + "X-Requested-With": "XMLHttpRequest", + "Referer": "https://fantasy.premierleague.com/a/squad/transfers", + } + + transfer_url = "https://fantasy.premierleague.com/api/transfers/" + + resp = session.post( + transfer_url, data=json.dumps(transfer_payload), headers=headers + ) + if "non_form_errors" in resp: + raise Exception(resp["non_form_errors"]) + elif resp.status_code == 200: + print("SUCCESS....transfers made!") + else: + print("Transfers unsuccessful due to unknown error") + print(f"Response status code: {resp.status_code}") + print(f"Response text: {resp.text}") + + +def main(fpl_team_id=None): + + transfer_player_ids, team_id, current_gw, chip_played = get_gw_transfer_suggestions( + fpl_team_id + ) + + fetcher = FPLDataFetcher(team_id) + + pre_transfer_bank = get_bank(fpl_team_id=team_id) + priced_transfers = price_transfers(transfer_player_ids, fetcher, current_gw) + post_transfer_bank = deduct_transfer_price(pre_transfer_bank, priced_transfers) + + print_output( + team_id, current_gw, priced_transfers, pre_transfer_bank, post_transfer_bank + ) + + if check_proceed(): + transfer_req = build_transfer_payload( + priced_transfers, current_gw, fetcher, chip_played + ) + post_transfers(transfer_req, fetcher) + + +if __name__ == "__main__": + + main() diff --git a/airsenal/scripts/update_db.py b/airsenal/scripts/update_db.py index d87e4d50..eed560b6 100644 --- a/airsenal/scripts/update_db.py +++ b/airsenal/scripts/update_db.py @@ -12,16 +12,15 @@ get_last_complete_gameweek_in_db, get_last_finished_gameweek, NEXT_GAMEWEEK, - get_current_players, - get_players_for_gameweek, list_players, fetcher, get_player, ) from airsenal.scripts.fill_player_attributes_table import fill_attributes_table_from_api +from airsenal.scripts.fill_fixture_table import fill_fixtures_from_api from airsenal.scripts.fill_result_table import fill_results_from_api from airsenal.scripts.fill_playerscore_table import fill_playerscores_from_api -from airsenal.framework.transaction_utils import update_squad +from airsenal.framework.transaction_utils import update_squad, count_transactions from airsenal.framework.schema import Player, session_scope @@ -32,14 +31,12 @@ def update_transactions(season, fpl_team_id, dbsession): if NEXT_GAMEWEEK != 1: print("Checking team") - current_gameweek = NEXT_GAMEWEEK - 1 - db_players = sorted( - get_current_players( - season=season, fpl_team_id=fpl_team_id, dbsession=dbsession - ) - ) - api_players = sorted(get_players_for_gameweek(current_gameweek, fpl_team_id)) - if db_players != api_players: + n_transfers_api = len(fetcher.get_fpl_transfer_data(fpl_team_id)) + n_transactions_db = count_transactions(season, fpl_team_id, dbsession) + # DB has 2 rows per transfer, and rows for the 15 players selected in the + # initial squad which are not returned by the transfers API + n_transfers_db = (n_transactions_db - 15) / 2 + if n_transfers_db != n_transfers_api: update_squad( season=season, fpl_team_id=fpl_team_id, @@ -107,6 +104,7 @@ def update_players(season, dbsession): "Something strange has happened - more players in DB than API" ) else: + print("Updating player table...") # find the new player(s) from the API api_ids_from_db = [p.fpl_api_id for p in players_from_db] new_players = [p for p in players_from_api if p not in api_ids_from_db] @@ -114,13 +112,16 @@ def update_players(season, dbsession): first_name = player_data_from_api[player_api_id]["first_name"] second_name = player_data_from_api[player_api_id]["second_name"] name = "{} {}".format(first_name, second_name) - print("Adding player {}".format(name)) # check whether we alreeady have this player in the database - # if yes update that player's data, if no create a new player p = get_player(name, dbsession=dbsession) if p is None: + print("Adding player {}".format(name)) p = Player() update = False + elif p.fpl_api_id is None: + print("Updating player {}".format(name)) + update = True else: update = True p.fpl_api_id = player_api_id @@ -145,7 +146,6 @@ def update_attributes(season, dbsession): fill_attributes_table_from_api( season=season, gw_start=last_in_db, - gw_end=NEXT_GAMEWEEK, dbsession=dbsession, ) @@ -182,10 +182,12 @@ def main(): if not do_attributes and num_new_players > 0: print("New players added - enforcing update of attributes table") do_attributes = True - if do_attributes: update_attributes(season, session) + # update fixtures (which may have been rescheduled) + print("Updating fixture table...") + fill_fixtures_from_api(season, session) # update results and playerscores update_results(season, session) # update our squad diff --git a/airsenal/tests/test_attributes.py b/airsenal/tests/test_attributes.py index 942e4f13..2b46b386 100644 --- a/airsenal/tests/test_attributes.py +++ b/airsenal/tests/test_attributes.py @@ -109,3 +109,57 @@ def test_get_position(): assert player.position("1920") == pos_dict["1920"] # season not available assert player.position("1011") is None + + +def test_is_injured_or_suspended(): + """ + Check Player.is_injured_or_suspended() returns appropriate value both if details are + available in attributes table for requested gameweek, and if they're not available. + """ + player_id = 1 + season = "1920" + price = 50 + position = "MID" + team = "ABC" + # gw: (chance_of_playing_next_round, return_gameweek) + team_dict = { + 2: (100, None), + 3: (75, None), + 4: (50, 5), + 5: (0, None), + } + + player = Player() + player.player_id = player_id + player.name = "Test Player" + player.attributes = [] + + for gw, attr in team_dict.items(): + pa = PlayerAttributes() + pa.season = season + pa.team = team + pa.gameweek = gw + pa.price = price + pa.position = position + pa.player_id = player_id + pa.chance_of_playing_next_round = attr[0] + pa.return_gameweek = attr[1] + player.attributes.append(pa) + + # gameweek available in attributes table + # not injured, 100% available + assert player.is_injured_or_suspended(season, 2, 2) is False + assert player.is_injured_or_suspended(season, 2, 4) is False + # not injured, 75% available + assert player.is_injured_or_suspended(season, 3, 3) is False + assert player.is_injured_or_suspended(season, 3, 5) is False + # 50% available, expected back gw 5 + assert player.is_injured_or_suspended(season, 4, 4) is True + assert player.is_injured_or_suspended(season, 4, 5) is False + # 100% unavailable, mo return gameweek + assert player.is_injured_or_suspended(season, 5, 6) is True + assert player.is_injured_or_suspended(season, 5, 7) is True + # gameweek before earliest available: return status as of first available + assert player.is_injured_or_suspended(season, 1, 1) is False + # gameweek after last available: return status as of last available + assert player.is_injured_or_suspended(season, 6, 1) is True diff --git a/airsenal/tests/testdata/testdata_1718_1819.db b/airsenal/tests/testdata/testdata_1718_1819.db index 8cbb9aa6..4862b974 100644 Binary files a/airsenal/tests/testdata/testdata_1718_1819.db and b/airsenal/tests/testdata/testdata_1718_1819.db differ diff --git a/environment.yml b/environment.yml index 7c24553c..56edee95 100644 --- a/environment.yml +++ b/environment.yml @@ -5,7 +5,8 @@ channels: dependencies: - python=3.7 - pip - - pystan + - pystan=2.19.1.1 - pygmo - pip: - . + diff --git a/notebooks/bonus_points.ipynb b/notebooks/bonus_points.ipynb index afaae695..87d8b983 100644 --- a/notebooks/bonus_points.ipynb +++ b/notebooks/bonus_points.ipynb @@ -101,8 +101,8 @@ " 0\n", " 0\n", " 0\n", - " 415\n", - " 4\n", + " 575\n", + " 4.0\n", " ...\n", " 0\n", " 0\n", @@ -125,8 +125,8 @@ " 0\n", " 0\n", " 0\n", - " 415\n", - " 16\n", + " 575\n", + " 16.0\n", " ...\n", " 0\n", " 0\n", @@ -149,8 +149,8 @@ " 0\n", " 0\n", " 0\n", - " 415\n", - " 23\n", + " 575\n", + " 23.0\n", " ...\n", " 0\n", " 0\n", @@ -173,8 +173,8 @@ " 0\n", " 0\n", " 0\n", - " 415\n", - " 31\n", + " 575\n", + " 31.0\n", " ...\n", " 0\n", " 0\n", @@ -197,8 +197,8 @@ " 0\n", " 0\n", " 0\n", - " 415\n", - " 44\n", + " 575\n", + " 44.0\n", " ...\n", " 0\n", " 0\n", @@ -227,11 +227,11 @@ "\n", " player_id result_id ... penalties_saved penalties_missed \\\n", "id ... \n", - "1 415 4 ... 0 0 \n", - "2 415 16 ... 0 0 \n", - "3 415 23 ... 0 0 \n", - "4 415 31 ... 0 0 \n", - "5 415 44 ... 0 0 \n", + "1 575 4.0 ... 0 0 \n", + "2 575 16.0 ... 0 0 \n", + "3 575 23.0 ... 0 0 \n", + "4 575 31.0 ... 0 0 \n", + "5 575 44.0 ... 0 0 \n", "\n", " yellow_cards red_cards saves bps influence creativity threat \\\n", "id \n", @@ -258,7 +258,7 @@ } ], "source": [ - "df = pd.read_sql(session.query(PlayerScore).statement, engine)\n", + "df = pd.read_sql(session.query(PlayerScore).statement, session.bind)\n", "df.set_index(\"id\", inplace=True)\n", "df.head()" ] @@ -289,32 +289,39 @@ " \n", " \n", " \n", + " fpl_api_id\n", " name\n", " \n", " \n", " player_id\n", " \n", + " \n", " \n", " \n", " \n", " \n", " 1\n", + " 1.0\n", " Mesut Özil\n", " \n", " \n", " 2\n", + " 2.0\n", " Sokratis Papastathopoulos\n", " \n", " \n", " 3\n", + " 3.0\n", " David Luiz Moreira Marinho\n", " \n", " \n", " 4\n", + " 4.0\n", " Pierre-Emerick Aubameyang\n", " \n", " \n", " 5\n", + " 5.0\n", " Cédric Soares\n", " \n", " \n", @@ -322,13 +329,13 @@ "" ], "text/plain": [ - " name\n", - "player_id \n", - "1 Mesut Özil\n", - "2 Sokratis Papastathopoulos\n", - "3 David Luiz Moreira Marinho\n", - "4 Pierre-Emerick Aubameyang\n", - "5 Cédric Soares" + " fpl_api_id name\n", + "player_id \n", + "1 1.0 Mesut Özil\n", + "2 2.0 Sokratis Papastathopoulos\n", + "3 3.0 David Luiz Moreira Marinho\n", + "4 4.0 Pierre-Emerick Aubameyang\n", + "5 5.0 Cédric Soares" ] }, "execution_count": 3, @@ -337,7 +344,7 @@ } ], "source": [ - "players = pd.read_sql(session.query(Player).statement, engine)\n", + "players = pd.read_sql(session.query(Player).statement, session.bind)\n", "players.set_index(\"player_id\", inplace=True)\n", "players.head()" ] @@ -370,7 +377,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -395,336 +402,389 @@ " \n", " \n", " bonus\n", + " fpl_api_id\n", " name\n", " \n", " \n", " player_id\n", " \n", " \n", + " \n", " \n", " \n", " \n", " \n", - " 302\n", - " 1.285714\n", + " 405\n", + " 1.194444\n", + " 302.0\n", " Bruno Miguel Borges Fernandes\n", " \n", " \n", - " 1024\n", - " 1.153846\n", - " Philippe Coutinho\n", - " \n", - " \n", - " 315\n", - " 1.076923\n", - " Mason Greenwood\n", - " \n", - " \n", - " 831\n", - " 1.017241\n", - " Eden Hazard\n", + " 536\n", + " 0.981982\n", + " 388.0\n", + " Harry Kane\n", " \n", " \n", - " 4\n", - " 0.974026\n", - " Pierre-Emerick Aubameyang\n", + " 377\n", + " 0.904762\n", + " 284.0\n", + " Phil Foden\n", " \n", " \n", - " 268\n", - " 0.909091\n", + " 361\n", + " 0.895522\n", + " 268.0\n", " Sergio Agüero\n", " \n", " \n", - " 366\n", - " 0.905660\n", - " Danny Ings\n", - " \n", - " \n", - " 460\n", - " 0.901408\n", + " 637\n", + " 0.887500\n", + " 460.0\n", " Raúl Jiménez\n", " \n", " \n", - " 388\n", - " 0.900000\n", - " Harry Kane\n", + " 4\n", + " 0.884211\n", + " 4.0\n", + " Pierre-Emerick Aubameyang\n", " \n", " \n", - " 224\n", - " 0.870000\n", + " 271\n", + " 0.871795\n", + " 224.0\n", " Jamie Vardy\n", " \n", " \n", - " 282\n", - " 0.860465\n", - " Gabriel Fernando de Jesus\n", - " \n", - " \n", - " 272\n", + " 502\n", " 0.857143\n", - " Kevin De Bruyne\n", + " 366.0\n", + " Danny Ings\n", " \n", " \n", - " 436\n", - " 0.833333\n", - " Andriy Yarmolenko\n", + " 375\n", + " 0.854545\n", + " 282.0\n", + " Gabriel Fernando de Jesus\n", " \n", " \n", - " 1005\n", - " 0.833333\n", - " Wayne Rooney\n", + " 365\n", + " 0.847826\n", + " 272.0\n", + " Kevin De Bruyne\n", " \n", " \n", - " 256\n", + " 342\n", " 0.800000\n", + " 256.0\n", " Divock Origi\n", " \n", " \n", - " 275\n", - " 0.765625\n", + " 608\n", + " 0.769231\n", + " 436.0\n", + " Andriy Yarmolenko\n", + " \n", + " \n", + " 368\n", + " 0.743590\n", + " 275.0\n", " Riyad Mahrez\n", " \n", " \n", - " 709\n", - " 0.739130\n", - " Kieran Trippier\n", + " 152\n", + " 0.734694\n", + " 118.0\n", + " Tammy Abraham\n", " \n", " \n", - " 259\n", - " 0.737500\n", - " Trent Alexander-Arnold\n", + " 36\n", + " 0.727273\n", + " 29.0\n", + " Ahmed El Mohamady\n", " \n", " \n", - " 627\n", - " 0.733333\n", - " David Silva\n", + " 538\n", + " 0.710000\n", + " 390.0\n", + " Heung-Min Son\n", " \n", " \n", - " 91\n", - " 0.729730\n", - " Chris Wood\n", + " 303\n", + " 0.695652\n", + " 202.0\n", + " Patrick Bamford\n", " \n", " \n", - " 249\n", - " 0.729167\n", + " 335\n", + " 0.677966\n", + " 249.0\n", " Roberto Firmino\n", " \n", " \n", - " 118\n", - " 0.700000\n", - " Tammy Abraham\n", + " 34\n", + " 0.666667\n", + " 12.0\n", + " Emiliano Martínez\n", " \n", " \n", - " 284\n", - " 0.700000\n", - " Phil Foden\n", + " 369\n", + " 0.660550\n", + " 276.0\n", + " Raheem Sterling\n", " \n", " \n", - " 276\n", - " 0.696629\n", - " Raheem Sterling\n", + " 340\n", + " 0.656000\n", + " 254.0\n", + " Mohamed Salah\n", " \n", " \n", - " 68\n", - " 0.689655\n", - " Neal Maupay\n", + " 117\n", + " 0.648936\n", + " 91.0\n", + " Chris Wood\n", " \n", " \n", - " 625\n", - " 0.681818\n", - " Danilo Luiz da Silva\n", + " 344\n", + " 0.647059\n", + " 259.0\n", + " Trent Alexander-Arnold\n", " \n", " \n", - " 390\n", - " 0.662338\n", - " Heung-Min Son\n", + " 122\n", + " 0.645833\n", + " 96.0\n", + " Nick Pope\n", " \n", " \n", - " 306\n", - " 0.662162\n", - " Marcus Rashford\n", + " 464\n", + " 0.642857\n", + " 343.0\n", + " Billy Sharp\n", " \n", " \n", - " 254\n", - " 0.660194\n", - " Mohamed Salah\n", + " 79\n", + " 0.638298\n", + " 68.0\n", + " Neal Maupay\n", " \n", " \n", - " 654\n", - " 0.656250\n", - " Teemu Pukki\n", + " 401\n", + " 0.628571\n", + " 297.0\n", + " Phil Jones\n", " \n", " \n", - " 255\n", - " 0.652174\n", + " 68\n", + " 0.611765\n", + " 57.0\n", + " Pascal Groß\n", + " \n", + " \n", + " 341\n", + " 0.606838\n", + " 255.0\n", " Andrew Robertson\n", " \n", " \n", - " 251\n", - " 0.641304\n", + " 149\n", + " 0.600000\n", + " 114.0\n", + " Hakim Ziyech\n", + " \n", + " \n", + " 337\n", + " 0.598214\n", + " 251.0\n", " Sadio Mané\n", " \n", " \n", - " 523\n", - " 0.631579\n", - " Laurent Koscielny\n", + " 141\n", + " 0.595238\n", + " 104.0\n", + " Marcos Alonso\n", " \n", " \n", - " 297\n", - " 0.628571\n", - " Phil Jones\n", + " 190\n", + " 0.588235\n", + " 489.0\n", + " Eberechi Eze\n", " \n", " \n", - " 798\n", - " 0.625000\n", - " Sam Vokes\n", + " 418\n", + " 0.583333\n", + " 315.0\n", + " Mason Greenwood\n", " \n", " \n", - " 626\n", - " 0.622222\n", - " Leroy Sané\n", + " 646\n", + " 0.571429\n", + " 470.0\n", + " Max Kilman\n", " \n", " \n", - " 478\n", - " 0.611111\n", - " Willian Borges Da Silva\n", + " 78\n", + " 0.571429\n", + " 67.0\n", + " Joël Veltman\n", " \n", " \n", - " 104\n", - " 0.602564\n", - " Marcos Alonso\n", + " 458\n", + " 0.567308\n", + " 506.0\n", + " Callum Wilson\n", " \n", " \n", - " 29\n", - " 0.600000\n", - " Ahmed El Mohamady\n", + " 203\n", + " 0.566265\n", + " 155.0\n", + " Lucas Digne\n", " \n", " \n", - " 343\n", - " 0.600000\n", - " Billy Sharp\n", + " 364\n", + " 0.563380\n", + " 271.0\n", + " Ilkay Gündogan\n", " \n", " \n", - " 57\n", - " 0.597222\n", - " Pascal Groß\n", + " 409\n", + " 0.557895\n", + " 306.0\n", + " Marcus Rashford\n", + " \n", + " \n", + " 26\n", + " 0.554217\n", + " 478.0\n", + " Willian Borges Da Silva\n", " \n", " \n", - " 127\n", - " 0.584906\n", + " 168\n", + " 0.553571\n", + " 127.0\n", " Mamadou Sakho\n", " \n", " \n", - " 634\n", - " 0.584906\n", - " Romelu Lukaku\n", + " 44\n", + " 0.551724\n", + " 37.0\n", + " Jack Grealish\n", " \n", " \n", - " 96\n", - " 0.583333\n", - " Nick Pope\n", + " 6\n", + " 0.548780\n", + " 6.0\n", + " Alexandre Lacazette\n", " \n", " \n", - " 902\n", - " 0.583333\n", - " Shinji Okazaki\n", + " 66\n", + " 0.535714\n", + " 53.0\n", + " Glenn Murray\n", " \n", " \n", - " 355\n", - " 0.576923\n", - " John Lundstram\n", + " 370\n", + " 0.533333\n", + " 277.0\n", + " João Pedro Cavaco Cancelo\n", " \n", " \n", - " 862\n", - " 0.571429\n", - " Ryan Babel\n", + " 157\n", + " 0.531250\n", + " 123.0\n", + " Reece James\n", " \n", " \n", - " 155\n", - " 0.567164\n", - " Lucas Digne\n", + " 400\n", + " 0.529412\n", + " 296.0\n", + " Paul Pogba\n", " \n", " \n", - " 755\n", - " 0.566667\n", - " Javier Hernández Balcázar\n", + " 314\n", + " 0.521739\n", + " 213.0\n", + " Illan Meslier\n", " \n", " \n", - " 906\n", - " 0.562500\n", - " Ragnar Klavan\n", + " 322\n", + " 0.500000\n", + " 570.0\n", + " Raphael Dias Belloli\n", " \n", " \n", "\n", "" ], "text/plain": [ - " bonus name\n", - "player_id \n", - "302 1.285714 Bruno Miguel Borges Fernandes\n", - "1024 1.153846 Philippe Coutinho\n", - "315 1.076923 Mason Greenwood\n", - "831 1.017241 Eden Hazard\n", - "4 0.974026 Pierre-Emerick Aubameyang\n", - "268 0.909091 Sergio Agüero\n", - "366 0.905660 Danny Ings\n", - "460 0.901408 Raúl Jiménez\n", - "388 0.900000 Harry Kane\n", - "224 0.870000 Jamie Vardy\n", - "282 0.860465 Gabriel Fernando de Jesus\n", - "272 0.857143 Kevin De Bruyne\n", - "436 0.833333 Andriy Yarmolenko\n", - "1005 0.833333 Wayne Rooney\n", - "256 0.800000 Divock Origi\n", - "275 0.765625 Riyad Mahrez\n", - "709 0.739130 Kieran Trippier\n", - "259 0.737500 Trent Alexander-Arnold\n", - "627 0.733333 David Silva\n", - "91 0.729730 Chris Wood\n", - "249 0.729167 Roberto Firmino\n", - "118 0.700000 Tammy Abraham\n", - "284 0.700000 Phil Foden\n", - "276 0.696629 Raheem Sterling\n", - "68 0.689655 Neal Maupay\n", - "625 0.681818 Danilo Luiz da Silva\n", - "390 0.662338 Heung-Min Son\n", - "306 0.662162 Marcus Rashford\n", - "254 0.660194 Mohamed Salah\n", - "654 0.656250 Teemu Pukki\n", - "255 0.652174 Andrew Robertson\n", - "251 0.641304 Sadio Mané\n", - "523 0.631579 Laurent Koscielny\n", - "297 0.628571 Phil Jones\n", - "798 0.625000 Sam Vokes\n", - "626 0.622222 Leroy Sané\n", - "478 0.611111 Willian Borges Da Silva\n", - "104 0.602564 Marcos Alonso\n", - "29 0.600000 Ahmed El Mohamady\n", - "343 0.600000 Billy Sharp\n", - "57 0.597222 Pascal Groß\n", - "127 0.584906 Mamadou Sakho\n", - "634 0.584906 Romelu Lukaku\n", - "96 0.583333 Nick Pope\n", - "902 0.583333 Shinji Okazaki\n", - "355 0.576923 John Lundstram\n", - "862 0.571429 Ryan Babel\n", - "155 0.567164 Lucas Digne\n", - "755 0.566667 Javier Hernández Balcázar\n", - "906 0.562500 Ragnar Klavan" + " bonus fpl_api_id name\n", + "player_id \n", + "405 1.194444 302.0 Bruno Miguel Borges Fernandes\n", + "536 0.981982 388.0 Harry Kane\n", + "377 0.904762 284.0 Phil Foden\n", + "361 0.895522 268.0 Sergio Agüero\n", + "637 0.887500 460.0 Raúl Jiménez\n", + "4 0.884211 4.0 Pierre-Emerick Aubameyang\n", + "271 0.871795 224.0 Jamie Vardy\n", + "502 0.857143 366.0 Danny Ings\n", + "375 0.854545 282.0 Gabriel Fernando de Jesus\n", + "365 0.847826 272.0 Kevin De Bruyne\n", + "342 0.800000 256.0 Divock Origi\n", + "608 0.769231 436.0 Andriy Yarmolenko\n", + "368 0.743590 275.0 Riyad Mahrez\n", + "152 0.734694 118.0 Tammy Abraham\n", + "36 0.727273 29.0 Ahmed El Mohamady\n", + "538 0.710000 390.0 Heung-Min Son\n", + "303 0.695652 202.0 Patrick Bamford\n", + "335 0.677966 249.0 Roberto Firmino\n", + "34 0.666667 12.0 Emiliano Martínez\n", + "369 0.660550 276.0 Raheem Sterling\n", + "340 0.656000 254.0 Mohamed Salah\n", + "117 0.648936 91.0 Chris Wood\n", + "344 0.647059 259.0 Trent Alexander-Arnold\n", + "122 0.645833 96.0 Nick Pope\n", + "464 0.642857 343.0 Billy Sharp\n", + "79 0.638298 68.0 Neal Maupay\n", + "401 0.628571 297.0 Phil Jones\n", + "68 0.611765 57.0 Pascal Groß\n", + "341 0.606838 255.0 Andrew Robertson\n", + "149 0.600000 114.0 Hakim Ziyech\n", + "337 0.598214 251.0 Sadio Mané\n", + "141 0.595238 104.0 Marcos Alonso\n", + "190 0.588235 489.0 Eberechi Eze\n", + "418 0.583333 315.0 Mason Greenwood\n", + "646 0.571429 470.0 Max Kilman\n", + "78 0.571429 67.0 Joël Veltman\n", + "458 0.567308 506.0 Callum Wilson\n", + "203 0.566265 155.0 Lucas Digne\n", + "364 0.563380 271.0 Ilkay Gündogan\n", + "409 0.557895 306.0 Marcus Rashford\n", + "26 0.554217 478.0 Willian Borges Da Silva\n", + "168 0.553571 127.0 Mamadou Sakho\n", + "44 0.551724 37.0 Jack Grealish\n", + "6 0.548780 6.0 Alexandre Lacazette\n", + "66 0.535714 53.0 Glenn Murray\n", + "370 0.533333 277.0 João Pedro Cavaco Cancelo\n", + "157 0.531250 123.0 Reece James\n", + "400 0.529412 296.0 Paul Pogba\n", + "314 0.521739 213.0 Illan Meslier\n", + "322 0.500000 570.0 Raphael Dias Belloli" ] }, - "execution_count": 20, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df_more60.sort_values(by=\"bonus\", ascending=False).head(50)" + "df_more60.dropna().sort_values(by=\"bonus\", ascending=False).head(50)\n", + "# dropna to remove players without current fpl API id" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -749,121 +809,138 @@ " \n", " \n", " bonus\n", + " fpl_api_id\n", " name\n", " \n", " \n", " player_id\n", " \n", " \n", + " \n", " \n", " \n", " \n", " \n", - " 4\n", - " 0.600000\n", - " Pierre-Emerick Aubameyang\n", + " 271\n", + " 0.700000\n", + " 224.0\n", + " Jamie Vardy\n", " \n", " \n", - " 224\n", - " 0.600000\n", - " Jamie Vardy\n", + " 409\n", + " 0.545455\n", + " 306.0\n", + " Marcus Rashford\n", " \n", " \n", - " 6\n", - " 0.392857\n", - " Alexandre Lacazette\n", + " 276\n", + " 0.500000\n", + " 229.0\n", + " Ayoze Pérez\n", " \n", " \n", - " 755\n", - " 0.360000\n", - " Javier Hernández Balcázar\n", + " 502\n", + " 0.500000\n", + " 366.0\n", + " Danny Ings\n", " \n", " \n", - " 944\n", - " 0.357143\n", - " Lucas Pérez\n", + " 6\n", + " 0.466667\n", + " 6.0\n", + " Alexandre Lacazette\n", " \n", " \n", - " 918\n", - " 0.300000\n", - " Mikel Merino\n", + " 479\n", + " 0.307692\n", + " 359.0\n", + " Lys Mousset\n", " \n", " \n", - " 506\n", + " 458\n", " 0.300000\n", + " 506.0\n", " Callum Wilson\n", " \n", " \n", - " 522\n", + " 152\n", " 0.300000\n", - " Nacho Monreal\n", + " 118.0\n", + " Tammy Abraham\n", " \n", " \n", - " 130\n", + " 332\n", " 0.300000\n", - " James McArthur\n", + " 246.0\n", + " Joel Matip\n", " \n", " \n", - " 306\n", - " 0.280000\n", - " Marcus Rashford\n", + " 425\n", + " 0.300000\n", + " 569.0\n", + " Edinson Cavani\n", " \n", " \n", - " 140\n", - " 0.272727\n", - " Jordan Ayew\n", + " 501\n", + " 0.300000\n", + " 365.0\n", + " Nathan Redmond\n", " \n", " \n", - " 801\n", - " 0.260870\n", - " Peter Crouch\n", + " 318\n", + " 0.300000\n", + " 492.0\n", + " Rodrigo Moreno\n", " \n", " \n", - " 33\n", - " 0.250000\n", - " Conor Hourihane\n", + " 364\n", + " 0.300000\n", + " 271.0\n", + " Ilkay Gündogan\n", " \n", " \n", - " 249\n", - " 0.230769\n", - " Roberto Firmino\n", + " 279\n", + " 0.294118\n", + " 233.0\n", + " Kelechi Iheanacho\n", " \n", " \n", - " 927\n", - " 0.230769\n", - " Manolo Gabbiadini\n", + " 375\n", + " 0.222222\n", + " 282.0\n", + " Gabriel Fernando de Jesus\n", " \n", " \n", "\n", "" ], "text/plain": [ - " bonus name\n", - "player_id \n", - "4 0.600000 Pierre-Emerick Aubameyang\n", - "224 0.600000 Jamie Vardy\n", - "6 0.392857 Alexandre Lacazette\n", - "755 0.360000 Javier Hernández Balcázar\n", - "944 0.357143 Lucas Pérez\n", - "918 0.300000 Mikel Merino\n", - "506 0.300000 Callum Wilson\n", - "522 0.300000 Nacho Monreal\n", - "130 0.300000 James McArthur\n", - "306 0.280000 Marcus Rashford\n", - "140 0.272727 Jordan Ayew\n", - "801 0.260870 Peter Crouch\n", - "33 0.250000 Conor Hourihane\n", - "249 0.230769 Roberto Firmino\n", - "927 0.230769 Manolo Gabbiadini" + " bonus fpl_api_id name\n", + "player_id \n", + "271 0.700000 224.0 Jamie Vardy\n", + "409 0.545455 306.0 Marcus Rashford\n", + "276 0.500000 229.0 Ayoze Pérez\n", + "502 0.500000 366.0 Danny Ings\n", + "6 0.466667 6.0 Alexandre Lacazette\n", + "479 0.307692 359.0 Lys Mousset\n", + "458 0.300000 506.0 Callum Wilson\n", + "152 0.300000 118.0 Tammy Abraham\n", + "332 0.300000 246.0 Joel Matip\n", + "425 0.300000 569.0 Edinson Cavani\n", + "501 0.300000 365.0 Nathan Redmond\n", + "318 0.300000 492.0 Rodrigo Moreno\n", + "364 0.300000 271.0 Ilkay Gündogan\n", + "279 0.294118 233.0 Kelechi Iheanacho\n", + "375 0.222222 282.0 Gabriel Fernando de Jesus" ] }, - "execution_count": 7, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df_less60.sort_values(by=\"bonus\", ascending=False).head(15)" + "df_less60.dropna().sort_values(by=\"bonus\", ascending=False).head(15)" ] }, { @@ -911,7 +988,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -923,7 +1000,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -935,7 +1012,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -947,7 +1024,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1003,7 +1080,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1028,14 +1105,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[3.02380917e-05 6.92351888e-04 7.82810007e-04]\n" + "[3.26341995e-05 4.91545962e-04 9.21680186e-04]\n" ] }, { @@ -1044,13 +1121,13 @@ "Text(0, 0.5, 'bonus')" ] }, - "execution_count": 22, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1062,7 +1139,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1109,33 +1186,29 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/jroberts/opt/anaconda3/envs/airsenalenv/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3417: RankWarning: Polyfit may be poorly conditioned\n", - " exec(code_obj, self.user_global_ns, self.user_ns)\n", - "/Users/jroberts/opt/anaconda3/envs/airsenalenv/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3417: RankWarning: Polyfit may be poorly conditioned\n", - " exec(code_obj, self.user_global_ns, self.user_ns)\n", - "/Users/jroberts/opt/anaconda3/envs/airsenalenv/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3417: RankWarning: Polyfit may be poorly conditioned\n", + "/Users/jroberts/opt/anaconda3/envs/airsenalenv/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3418: RankWarning: Polyfit may be poorly conditioned\n", " exec(code_obj, self.user_global_ns, self.user_ns)\n", - "/Users/jroberts/opt/anaconda3/envs/airsenalenv/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3417: RankWarning: Polyfit may be poorly conditioned\n", + "/Users/jroberts/opt/anaconda3/envs/airsenalenv/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3418: RankWarning: Polyfit may be poorly conditioned\n", " exec(code_obj, self.user_global_ns, self.user_ns)\n", - "/Users/jroberts/opt/anaconda3/envs/airsenalenv/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3417: RankWarning: Polyfit may be poorly conditioned\n", + "/Users/jroberts/opt/anaconda3/envs/airsenalenv/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3418: RankWarning: Polyfit may be poorly conditioned\n", " exec(code_obj, self.user_global_ns, self.user_ns)\n" ] }, { "data": { "text/plain": [ - "136 16.162799\n", - "1079 4.757001\n", - "315 4.562938\n", - "436 4.307706\n", - "256 4.170446\n", + "177 18.217993\n", + "1180 4.603743\n", + "608 4.076245\n", + "1127 3.989050\n", + "1108 3.978966\n", " ... \n", - "1098 -0.333777\n", - "801 -0.442625\n", - "1077 -0.785866\n", - "892 -1.374572\n", - "302 -6.597365\n", - "Length: 1076, dtype: float64" + "1010 -0.127608\n", + "1199 -0.337441\n", + "90 -0.413058\n", + "908 -0.452803\n", + "1178 -0.801066\n", + "Length: 1255, dtype: float64" ] }, "execution_count": 12, @@ -1177,7 +1250,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[0.18327797 0.11135085]\n" + "[0.18272664 0.10185292]\n" ] }, { @@ -1192,7 +1265,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1233,7 +1306,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1266,7 +1339,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1302,7 +1375,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1335,26 +1408,26 @@ "data": { "text/plain": [ "player_id\n", - "171 7.500000\n", - "433 4.500000\n", - "717 4.333333\n", - "1053 4.142857\n", - "613 4.000000\n", - "859 3.827586\n", - "12 3.777778\n", - "803 3.710526\n", - "554 3.666667\n", - "656 3.638889\n", - "431 3.534653\n", - "8 3.516129\n", - "56 3.500000\n", - "657 3.500000\n", - "325 3.500000\n", - "483 3.459459\n", - "482 3.447368\n", - "696 3.428571\n", - "393 3.318182\n", - "553 3.250000\n", + "229 7.500000\n", + "605 4.500000\n", + "836 4.333333\n", + "195 4.142857\n", + "577 4.125000\n", + "750 4.000000\n", + "314 3.956522\n", + "964 3.827586\n", + "34 3.718750\n", + "910 3.710526\n", + "701 3.666667\n", + "784 3.638889\n", + "565 3.600000\n", + "435 3.500000\n", + "785 3.500000\n", + "254 3.458333\n", + "556 3.447368\n", + "483 3.419355\n", + "603 3.400000\n", + "122 3.350515\n", "Name: saves, dtype: float64" ] }, diff --git a/notebooks/card_points.ipynb b/notebooks/card_points.ipynb index bc85baa9..d1a3024b 100644 --- a/notebooks/card_points.ipynb +++ b/notebooks/card_points.ipynb @@ -31,7 +31,7 @@ " .filter(PlayerScore.minutes <= max_minutes)\n", ")\n", "# TODO filter on gw and season\n", - "df = pd.read_sql(query.statement, engine)\n" + "df = pd.read_sql(query.statement, session.bind)\n" ] }, { @@ -42,8 +42,8 @@ { "data": { "text/plain": [ - "0 0.884271\n", - "1 0.115729\n", + "0 0.885188\n", + "1 0.114812\n", "Name: yellow_cards, dtype: float64" ] }, @@ -64,8 +64,8 @@ { "data": { "text/plain": [ - "0 0.995784\n", - "1 0.004216\n", + "0 0.995732\n", + "1 0.004268\n", "Name: red_cards, dtype: float64" ] }, @@ -130,142 +130,164 @@ " \n", " \n", " card_pts\n", + " fpl_api_id\n", " name\n", " \n", " \n", " player_id\n", " \n", " \n", + " \n", " \n", " \n", " \n", " \n", - " 956\n", - " -0.583333\n", - " Marvin Zeegelaar\n", - " \n", - " \n", - " 294\n", + " 398\n", " -0.529412\n", + " 294.0\n", " Marcos Rojo\n", " \n", " \n", - " 172\n", + " 230\n", " -0.466667\n", + " 172.0\n", " Kevin McDonald\n", " \n", " \n", - " 1078\n", - " -0.454545\n", - " Charlie Adam\n", - " \n", - " \n", - " 406\n", + " 554\n", " -0.437500\n", + " 406.0\n", " Juan Foyth\n", " \n", " \n", - " 588\n", - " -0.412698\n", - " Jefferson Lerma\n", + " 591\n", + " -0.421053\n", + " 544.0\n", + " Conor Gallagher\n", " \n", " \n", " 2\n", " -0.409091\n", + " 2.0\n", " Sokratis Papastathopoulos\n", " \n", " \n", - " 955\n", - " -0.400000\n", - " Miguel Britos\n", + " 108\n", + " -0.385965\n", + " 82.0\n", + " Phil Bardsley\n", " \n", " \n", - " 552\n", - " -0.400000\n", - " Konstantinos Mavropanos\n", + " 87\n", + " -0.350000\n", + " 77.0\n", + " Tariq Lamptey\n", " \n", " \n", - " 82\n", - " -0.388889\n", - " Phil Bardsley\n", + " 444\n", + " -0.338710\n", + " 334.0\n", + " Fabian Schär\n", " \n", " \n", - " 741\n", - " -0.385714\n", - " José Holebas\n", + " 232\n", + " -0.333333\n", + " 174.0\n", + " Stefan Johansen\n", " \n", " \n", - " 1097\n", - " -0.384615\n", - " Papa Alioune Ndiaye\n", + " 219\n", + " -0.333333\n", + " 502.0\n", + " Allan Marques Loureiro\n", " \n", " \n", - " 894\n", - " -0.372881\n", - " Jonathan Hogg\n", + " 421\n", + " -0.333333\n", + " 318.0\n", + " Brandon Williams\n", " \n", " \n", - " 461\n", - " -0.370370\n", - " Romain Saïss\n", + " 252\n", + " -0.315789\n", + " 484.0\n", + " Antonee Robinson\n", " \n", " \n", - " 334\n", - " -0.369565\n", - " Fabian Schär\n", + " 259\n", + " -0.315789\n", + " 571.0\n", + " Joachim Andersen\n", " \n", " \n", - " 821\n", - " -0.368421\n", - " Harry Arter\n", + " 9\n", + " -0.313559\n", + " 9.0\n", + " Granit Xhaka\n", " \n", " \n", - " 318\n", - " -0.352941\n", - " Brandon Williams\n", + " 179\n", + " -0.312000\n", + " 138.0\n", + " Luka Milivojevic\n", " \n", " \n", - " 926\n", - " -0.352941\n", - " Vincent Kompany\n", + " 638\n", + " -0.308824\n", + " 461.0\n", + " Romain Saïss\n", " \n", " \n", - " 382\n", - " -0.350000\n", - " Moussa Djenepo\n", + " 75\n", + " -0.307692\n", + " 64.0\n", + " Florin Andone\n", " \n", " \n", - " 174\n", - " -0.333333\n", - " Stefan Johansen\n", + " 529\n", + " -0.300000\n", + " 643.0\n", + " Alexandre Jankewitz\n", + " \n", + " \n", + " 404\n", + " -0.297619\n", + " 300.0\n", + " Luke Shaw\n", + " \n", + " \n", + " 500\n", + " -0.289474\n", + " 364.0\n", + " Oriol Romeu Vidal\n", " \n", " \n", "\n", "" ], "text/plain": [ - " card_pts name\n", - "player_id \n", - "956 -0.583333 Marvin Zeegelaar\n", - "294 -0.529412 Marcos Rojo\n", - "172 -0.466667 Kevin McDonald\n", - "1078 -0.454545 Charlie Adam\n", - "406 -0.437500 Juan Foyth\n", - "588 -0.412698 Jefferson Lerma\n", - "2 -0.409091 Sokratis Papastathopoulos\n", - "955 -0.400000 Miguel Britos\n", - "552 -0.400000 Konstantinos Mavropanos\n", - "82 -0.388889 Phil Bardsley\n", - "741 -0.385714 José Holebas\n", - "1097 -0.384615 Papa Alioune Ndiaye\n", - "894 -0.372881 Jonathan Hogg\n", - "461 -0.370370 Romain Saïss\n", - "334 -0.369565 Fabian Schär\n", - "821 -0.368421 Harry Arter\n", - "318 -0.352941 Brandon Williams\n", - "926 -0.352941 Vincent Kompany\n", - "382 -0.350000 Moussa Djenepo\n", - "174 -0.333333 Stefan Johansen" + " card_pts fpl_api_id name\n", + "player_id \n", + "398 -0.529412 294.0 Marcos Rojo\n", + "230 -0.466667 172.0 Kevin McDonald\n", + "554 -0.437500 406.0 Juan Foyth\n", + "591 -0.421053 544.0 Conor Gallagher\n", + "2 -0.409091 2.0 Sokratis Papastathopoulos\n", + "108 -0.385965 82.0 Phil Bardsley\n", + "87 -0.350000 77.0 Tariq Lamptey\n", + "444 -0.338710 334.0 Fabian Schär\n", + "232 -0.333333 174.0 Stefan Johansen\n", + "219 -0.333333 502.0 Allan Marques Loureiro\n", + "421 -0.333333 318.0 Brandon Williams\n", + "252 -0.315789 484.0 Antonee Robinson\n", + "259 -0.315789 571.0 Joachim Andersen\n", + "9 -0.313559 9.0 Granit Xhaka\n", + "179 -0.312000 138.0 Luka Milivojevic\n", + "638 -0.308824 461.0 Romain Saïss\n", + "75 -0.307692 64.0 Florin Andone\n", + "529 -0.300000 643.0 Alexandre Jankewitz\n", + "404 -0.297619 300.0 Luke Shaw\n", + "500 -0.289474 364.0 Oriol Romeu Vidal" ] }, "execution_count": 7, @@ -274,13 +296,20 @@ } ], "source": [ - "players = pd.read_sql(session.query(Player).statement, engine)\n", + "players = pd.read_sql(session.query(Player).statement, session.bind)\n", "players.set_index(\"player_id\", inplace=True)\n", "\n", "avg_cards = pd.merge(avg_cards, players, how=\"left\", left_index=True, right_index=True)\n", - "avg_cards.sort_values(by=\"card_pts\", ascending=True).head(20)" + "avg_cards.dropna().sort_values(by=\"card_pts\", ascending=True).head(20)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/notebooks/save_points.ipynb b/notebooks/save_points.ipynb index 7147e86e..557a4f6e 100644 --- a/notebooks/save_points.ipynb +++ b/notebooks/save_points.ipynb @@ -42,7 +42,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -64,7 +64,7 @@ " .filter(PlayerScore.minutes >= min_minutes)\n", ")\n", "# TODO filter on gw and season\n", - "df = pd.read_sql(query.statement, engine)\n", + "df = pd.read_sql(query.statement, session.bind)\n", "\n", "# 1pt per 3 saves\n", "df[\"save_pts\"] = (df[\"saves\"] / 3).astype(int)\n", @@ -93,7 +93,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -125,7 +125,7 @@ " .filter(PlayerScore.minutes >= min_minutes)\n", " )\n", " # TODO filter on gw and season\n", - " df = pd.read_sql(query.statement, engine)\n", + " df = pd.read_sql(query.statement, session.bind)\n", "\n", " # 1pt per 3 saves\n", " df[\"save_pts\"] = (df[\"saves\"] / 3).astype(int)\n", @@ -162,7 +162,7 @@ "cell_type": "code", "execution_count": 7, "metadata": { - "scrolled": true + "scrolled": false }, "outputs": [ { @@ -187,280 +187,353 @@ " \n", " \n", " save_pts\n", + " fpl_api_id\n", " name\n", " \n", " \n", " player_id\n", " \n", " \n", + " \n", " \n", " \n", " \n", " \n", - " 325\n", - " 0.916667\n", - " Karl Darlow\n", + " 314\n", + " 1.000000\n", + " 213.0\n", + " Illan Meslier\n", + " \n", + " \n", + " 577\n", + " 1.000000\n", + " 417.0\n", + " Sam Johnstone\n", + " \n", + " \n", + " 34\n", + " 0.966667\n", + " 12.0\n", + " Emiliano Martínez\n", " \n", " \n", - " 433\n", + " 605\n", " 0.900000\n", + " 433.0\n", " Roberto Jimenez Gago\n", " \n", " \n", - " 431\n", - " 0.891089\n", - " Lukasz Fabianski\n", + " 435\n", + " 0.882353\n", + " 325.0\n", + " Karl Darlow\n", " \n", " \n", - " 8\n", - " 0.822581\n", - " Bernd Leno\n", + " 603\n", + " 0.861789\n", + " 431.0\n", + " Lukasz Fabianski\n", " \n", " \n", " 483\n", - " 0.820513\n", + " 0.838710\n", + " 483.0\n", " Aaron Ramsdale\n", " \n", " \n", - " 523\n", - " 0.809524\n", + " 167\n", + " 0.787234\n", + " 126.0\n", + " Wayne Hennessey\n", + " \n", + " \n", + " 519\n", + " 0.772727\n", + " 523.0\n", " Fraser Forster\n", " \n", " \n", - " 128\n", - " 0.803571\n", - " Vicente Guaita\n", + " 541\n", + " 0.761905\n", + " 393.0\n", + " Paulo Gazzaniga\n", " \n", " \n", - " 126\n", - " 0.787234\n", - " Wayne Hennessey\n", + " 122\n", + " 0.760417\n", + " 96.0\n", + " Nick Pope\n", " \n", " \n", - " 393\n", - " 0.761905\n", - " Paulo Gazzaniga\n", + " 8\n", + " 0.743902\n", + " 8.0\n", + " Bernd Leno\n", " \n", " \n", - " 482\n", - " 0.736842\n", - " Joe Hart\n", + " 169\n", + " 0.743590\n", + " 128.0\n", + " Vicente Guaita\n", " \n", " \n", - " 28\n", - " 0.707317\n", - " Tom Heaton\n", + " 556\n", + " 0.736842\n", + " 482.0\n", + " Joe Hart\n", " \n", " \n", - " 12\n", - " 0.700000\n", - " Emiliano Martínez\n", + " 254\n", + " 0.708333\n", + " 516.0\n", + " Alphonse Areola\n", " \n", " \n", - " 96\n", - " 0.698630\n", - " Nick Pope\n", + " 35\n", + " 0.707317\n", + " 28.0\n", + " Tom Heaton\n", " \n", " \n", - " 326\n", + " 436\n", " 0.693182\n", + " 326.0\n", " Martin Dubravka\n", " \n", " \n", - " 371\n", + " 507\n", " 0.681818\n", + " 371.0\n", " Angus Gunn\n", " \n", " \n", - " 70\n", - " 0.678571\n", - " Mathew Ryan\n", + " 331\n", + " 0.666667\n", + " 245.0\n", + " Adrián San Miguel del Castillo\n", " \n", " \n", - " 383\n", - " 0.670330\n", + " 531\n", + " 0.663717\n", + " 383.0\n", " Hugo Lloris\n", " \n", " \n", - " 245\n", - " 0.642857\n", - " Adrián San Miguel del Castillo\n", + " 25\n", + " 0.655738\n", + " 70.0\n", + " Mathew Ryan\n", " \n", " \n", - " 305\n", - " 0.611111\n", + " 408\n", + " 0.631579\n", + " 305.0\n", " Dean Henderson\n", " \n", " \n", - " 363\n", - " 0.589041\n", + " 499\n", + " 0.595745\n", + " 363.0\n", " Alex McCarthy\n", " \n", " \n", - " 291\n", - " 0.578947\n", - " David de Gea\n", - " \n", - " \n", - " 157\n", - " 0.577586\n", + " 205\n", + " 0.586466\n", + " 157.0\n", " Jordan Pickford\n", " \n", " \n", - " 455\n", - " 0.545455\n", - " Rui Pedro dos Santos Patrício\n", + " 264\n", + " 0.568182\n", + " 217.0\n", + " Kasper Schmeichel\n", " \n", " \n", - " 151\n", + " 199\n", " 0.544118\n", + " 151.0\n", " Jonas Lössl\n", " \n", " \n", - " 217\n", - " 0.536364\n", - " Kasper Schmeichel\n", + " 395\n", + " 0.531250\n", + " 291.0\n", + " David de Gea\n", " \n", " \n", - " 183\n", + " 241\n", " 0.500000\n", + " 183.0\n", " Marcus Bettinelli\n", " \n", " \n", - " 101\n", - " 0.500000\n", + " 633\n", + " 0.480000\n", + " 455.0\n", + " Rui Pedro dos Santos Patrício\n", + " \n", + " \n", + " 138\n", + " 0.454545\n", + " 101.0\n", " Willy Caballero\n", " \n", " \n", - " 171\n", + " 229\n", " 0.400000\n", + " 171.0\n", " Fabricio Agosto Ramírez\n", " \n", " \n", - " 112\n", - " 0.366197\n", + " 565\n", + " 0.400000\n", + " 56.0\n", + " David Button\n", + " \n", + " \n", + " 147\n", + " 0.383562\n", + " 112.0\n", " Kepa Arrizabalaga\n", " \n", " \n", - " 252\n", - " 0.313433\n", + " 338\n", + " 0.325581\n", + " 252.0\n", " Alisson Ramses Becker\n", " \n", " \n", - " 429\n", + " 162\n", " 0.300000\n", - " David Martin\n", + " 548.0\n", + " Edouard Mendy\n", " \n", " \n", - " 56\n", + " 601\n", " 0.300000\n", - " David Button\n", + " 429.0\n", + " David Martin\n", " \n", " \n", - " 278\n", - " 0.296296\n", + " 371\n", + " 0.292308\n", + " 278.0\n", " Ederson Santana de Moraes\n", " \n", " \n", - " 35\n", + " 42\n", " 0.200000\n", + " 35.0\n", " Ørjan Nyland\n", " \n", " \n", - " 213\n", - " 0.200000\n", - " Illan Meslier\n", + " 631\n", + " 0.100000\n", + " 453.0\n", + " John Ruddy\n", " \n", " \n", - " 348\n", + " 602\n", " 0.100000\n", - " Simon Moore\n", + " 430.0\n", + " Darren Randolph\n", " \n", " \n", - " 417\n", + " 393\n", " 0.100000\n", - " Sam Johnstone\n", + " 289.0\n", + " Sergio Romero\n", " \n", " \n", - " 430\n", + " 469\n", " 0.100000\n", - " Darren Randolph\n", + " 348.0\n", + " Simon Moore\n", " \n", " \n", - " 453\n", - " 0.100000\n", - " John Ruddy\n", + " 383\n", + " 0.000000\n", + " 538.0\n", + " Zack Steffen\n", " \n", " \n", - " 289\n", - " 0.100000\n", - " Sergio Romero\n", + " 244\n", + " 0.000000\n", + " 186.0\n", + " Marek Rodák\n", " \n", " \n", - " 516\n", - " 0.100000\n", - " Alphonse Areola\n", + " 125\n", + " 0.000000\n", + " 99.0\n", + " Bailey Peacock-Farrell\n", " \n", " \n", - " 267\n", + " 295\n", " 0.000000\n", - " Claudio Bravo\n", + " 194.0\n", + " Francisco Casilla Cortés\n", " \n", " \n", - " 186\n", + " 360\n", " 0.000000\n", - " Marek Rodák\n", + " 267.0\n", + " Claudio Bravo\n", " \n", " \n", "\n", "" ], "text/plain": [ - " save_pts name\n", - "player_id \n", - "325 0.916667 Karl Darlow\n", - "433 0.900000 Roberto Jimenez Gago\n", - "431 0.891089 Lukasz Fabianski\n", - "8 0.822581 Bernd Leno\n", - "483 0.820513 Aaron Ramsdale\n", - "523 0.809524 Fraser Forster\n", - "128 0.803571 Vicente Guaita\n", - "126 0.787234 Wayne Hennessey\n", - "393 0.761905 Paulo Gazzaniga\n", - "482 0.736842 Joe Hart\n", - "28 0.707317 Tom Heaton\n", - "12 0.700000 Emiliano Martínez\n", - "96 0.698630 Nick Pope\n", - "326 0.693182 Martin Dubravka\n", - "371 0.681818 Angus Gunn\n", - "70 0.678571 Mathew Ryan\n", - "383 0.670330 Hugo Lloris\n", - "245 0.642857 Adrián San Miguel del Castillo\n", - "305 0.611111 Dean Henderson\n", - "363 0.589041 Alex McCarthy\n", - "291 0.578947 David de Gea\n", - "157 0.577586 Jordan Pickford\n", - "455 0.545455 Rui Pedro dos Santos Patrício\n", - "151 0.544118 Jonas Lössl\n", - "217 0.536364 Kasper Schmeichel\n", - "183 0.500000 Marcus Bettinelli\n", - "101 0.500000 Willy Caballero\n", - "171 0.400000 Fabricio Agosto Ramírez\n", - "112 0.366197 Kepa Arrizabalaga\n", - "252 0.313433 Alisson Ramses Becker\n", - "429 0.300000 David Martin\n", - "56 0.300000 David Button\n", - "278 0.296296 Ederson Santana de Moraes\n", - "35 0.200000 Ørjan Nyland\n", - "213 0.200000 Illan Meslier\n", - "348 0.100000 Simon Moore\n", - "417 0.100000 Sam Johnstone\n", - "430 0.100000 Darren Randolph\n", - "453 0.100000 John Ruddy\n", - "289 0.100000 Sergio Romero\n", - "516 0.100000 Alphonse Areola\n", - "267 0.000000 Claudio Bravo\n", - "186 0.000000 Marek Rodák" + " save_pts fpl_api_id name\n", + "player_id \n", + "314 1.000000 213.0 Illan Meslier\n", + "577 1.000000 417.0 Sam Johnstone\n", + "34 0.966667 12.0 Emiliano Martínez\n", + "605 0.900000 433.0 Roberto Jimenez Gago\n", + "435 0.882353 325.0 Karl Darlow\n", + "603 0.861789 431.0 Lukasz Fabianski\n", + "483 0.838710 483.0 Aaron Ramsdale\n", + "167 0.787234 126.0 Wayne Hennessey\n", + "519 0.772727 523.0 Fraser Forster\n", + "541 0.761905 393.0 Paulo Gazzaniga\n", + "122 0.760417 96.0 Nick Pope\n", + "8 0.743902 8.0 Bernd Leno\n", + "169 0.743590 128.0 Vicente Guaita\n", + "556 0.736842 482.0 Joe Hart\n", + "254 0.708333 516.0 Alphonse Areola\n", + "35 0.707317 28.0 Tom Heaton\n", + "436 0.693182 326.0 Martin Dubravka\n", + "507 0.681818 371.0 Angus Gunn\n", + "331 0.666667 245.0 Adrián San Miguel del Castillo\n", + "531 0.663717 383.0 Hugo Lloris\n", + "25 0.655738 70.0 Mathew Ryan\n", + "408 0.631579 305.0 Dean Henderson\n", + "499 0.595745 363.0 Alex McCarthy\n", + "205 0.586466 157.0 Jordan Pickford\n", + "264 0.568182 217.0 Kasper Schmeichel\n", + "199 0.544118 151.0 Jonas Lössl\n", + "395 0.531250 291.0 David de Gea\n", + "241 0.500000 183.0 Marcus Bettinelli\n", + "633 0.480000 455.0 Rui Pedro dos Santos Patrício\n", + "138 0.454545 101.0 Willy Caballero\n", + "229 0.400000 171.0 Fabricio Agosto Ramírez\n", + "565 0.400000 56.0 David Button\n", + "147 0.383562 112.0 Kepa Arrizabalaga\n", + "338 0.325581 252.0 Alisson Ramses Becker\n", + "162 0.300000 548.0 Edouard Mendy\n", + "601 0.300000 429.0 David Martin\n", + "371 0.292308 278.0 Ederson Santana de Moraes\n", + "42 0.200000 35.0 Ørjan Nyland\n", + "631 0.100000 453.0 John Ruddy\n", + "602 0.100000 430.0 Darren Randolph\n", + "393 0.100000 289.0 Sergio Romero\n", + "469 0.100000 348.0 Simon Moore\n", + "383 0.000000 538.0 Zack Steffen\n", + "244 0.000000 186.0 Marek Rodák\n", + "125 0.000000 99.0 Bailey Peacock-Farrell\n", + "295 0.000000 194.0 Francisco Casilla Cortés\n", + "360 0.000000 267.0 Claudio Bravo" ] }, "execution_count": 7, @@ -469,7 +542,7 @@ } ], "source": [ - "players = pd.read_sql(session.query(Player).statement, engine)\n", + "players = pd.read_sql(session.query(Player).statement, session.bind)\n", "players.set_index(\"player_id\", inplace=True)\n", "\n", "avg_saves = pd.merge(avg_saves, players, how=\"left\", left_index=True, right_index=True)\n", @@ -486,7 +559,7 @@ { "data": { "text/plain": [ - "0.6986301369863014" + "0" ] }, "execution_count": 8, diff --git a/pyproject.toml b/pyproject.toml index 6f387cf2..b74620da 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,2 +1,2 @@ [build-system] -requires = ["cython", "numpy", "pystan","setuptools"] +requires = ["cython", "numpy", "pystan~=2.19.1.1", "setuptools"] diff --git a/requirements.txt b/requirements.txt index dcac3832..925d1864 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,12 +8,13 @@ dateparser matplotlib scipy pip -pystan>=2.14 +pystan~=2.19.1.1 pytest -bpl==0.0.4 +bpl @ git+https://github.com/anguswilliams91/bpl@5c5962c#egg=bpl flask flask_cors flask_session jupyter seaborn click>=7.1.2 +prettytable diff --git a/setup.py b/setup.py index d3f95519..ebb46955 100644 --- a/setup.py +++ b/setup.py @@ -61,6 +61,7 @@ def compile_stan_models(target_dir, model_dir=MODEL_DIR): "airsenal_dump_db=airsenal.scripts.dump_db_contents:main", "airsenal_run_pipeline=airsenal.scripts.airsenal_run_pipeline:run_pipeline", "airsenal_replay_season=airsenal.scripts.replay_season:main", + "airsenal_make_transfers=airsenal.scripts.make_transfers:main", ] setup(