Refactor assist projection calculations in app.py to improve accuracy by scaling based on total kills instead of kill predictions. This change enhances the integrity of player performance metrics in both team and player data initialization functions, ensuring more reliable projections.

Refactor assist projection calculations in app.py to improve accuracy. Updated the logic for calculating 'Assist_Proj' to scale based on total kills, ensuring projections do not exceed actual performance metrics. This change enhances the integrity of player performance data in both team and player data initialization functions.

Fix game number indexing in player summary generation to correctly reference previous game data. This change ensures accurate retrieval of player statistics by adjusting the conditional check for kill predictions, enhancing the integrity of player summaries during simulations.

Fix game number indexing in player summary generation by removing unnecessary conditional checks. This change simplifies the logic for retrieving game data, ensuring accurate player statistics are generated consistently across simulations.

Fix game number indexing in player summary generation to support data type selection. Updated logic to correctly reference game numbers based on the selected data type ("Team" or "Player"), ensuring accurate retrieval of player statistics. This change enhances data integrity and improves the clarity of player summaries during simulations.

Refactor init_team_data and init_player_data functions in app.py to accept game_count as a parameter. This change improves function clarity and ensures consistent handling of game count across team and player data initialization. Updated function calls in the simulation logic to reflect this modification.

Merge branch 'main' of https://huggingface.co/spaces/Multichem-PD/LOL_Matchups_Model

Refactor assist projection calculations in app.py to ensure they do not exceed total kills. Introduced scaling for assist projections based on raw assist calculations, improving accuracy in player performance metrics. Additionally, added duplicate removal based on 'position' to enhance data integrity in team data initialization.

Update app.py

Update game simulation settings in app.py to allow selection of the number of games (1-5) instead of match format (BO1, BO3, BO5). Adjusted game count extraction logic to reflect the new selection method, improving user experience and clarity in simulation configurations.

Update player data query in app.py to support multiple player names. Changed the query to use the "$in" operator for playername, allowing for more flexible data retrieval across multiple players. This enhancement improves the accuracy of game log data retrieval for player statistics.

Enhance player data handling in app.py by introducing a new data type selection feature. Users can now choose between "Team" and "Player" data types, allowing for more flexible data analysis. Updated the player data initialization function to support player-specific statistics, including average performance metrics based on game outcomes. This change improves the overall functionality and user experience of the application.

Fix game number indexing in player summary generation in app.py. Updated the dictionary key format to correctly reference game numbers, ensuring accurate data retrieval for player statistics. This change improves the integrity of the player summary during simulations.

Refactor player summary generation in app.py to correctly iterate over results_dict using game number keys. Updated player summary aggregation logic to ensure team names and positions are accurately reflected. This change enhances data accuracy and improves the clarity of player statistics during simulations.

Refactor variable naming in app.py for improved clarity. Changed 'game_num' to 'game_count' in the results dictionary iteration to better reflect its purpose. Minor formatting adjustment to remove unnecessary whitespace, enhancing code readability.

Refactor app.py to enhance data presentation and organization. Introduced a new tabbed layout with three tabs: "Overall Data", "Individual Game Data", and "Opponent Data". Improved the display of overall simulations by adding subheaders and individual player tabs for better clarity. Updated the styling for dataframes to maintain a consistent visual theme using the 'RdYlGn' colormap. These changes enhance user experience and readability of simulation results.

Enhance data presentation in app.py by updating the background gradient styling for player statistics. The new gradient uses the 'RdYlGn' colormap for improved visual clarity, enhancing the user experience when viewing simulation results.

Enhance overall simulation data presentation in app.py. Introduced tabbed layout for displaying player statistics (Kills, Deaths, Assists, CS) to improve user experience. Each tab presents a filtered view of the overall simulation DataFrame, enhancing clarity and readability of performance metrics.

Refactor overall simulation DataFrame in app.py. Updated overall_sim_df to drop duplicates based on 'Player' and 'Stat', simplifying data structure and enhancing clarity. Adjusted data presentation by removing background gradient styling for improved readability of simulation results.

Refactor overall simulation data handling in app.py. Removed the setting of 'Player' as the index in overall_sim_df to simplify data structure. This change enhances the clarity and usability of the simulation results by maintaining a more straightforward DataFrame format.

Refactor overall simulation data handling in app.py. Updated overall_sim_df to drop duplicate entries based on 'Player', 'Position', and 'Stat', and set 'Player' as the index for improved data organization. Adjusted the placement of the "Individual Game Simulations" subheader for better clarity in the user interface. These changes enhance the readability and usability of simulation results.

Refactor simulation data handling in app.py. Updated variable names for clarity, changing 'sim_results' to 'individual_sim_results' and added 'overall_sim_results' for aggregated player statistics. Enhanced data presentation by introducing subheaders for individual game simulations and overall simulations, improving user experience and data readability. This change streamlines the simulation process and enhances the clarity of displayed results.

Refactor player data handling in init_team_data function of app.py. Updated results_dict assignment to drop NaN values, ensuring cleaner data output for each game iteration. Adjusted playername indexing to maintain clarity in player statistics during simulations. This change enhances the overall quality and usability of the player summary data.

Refactor player summary generation in app.py to utilize results_dict for improved performance metrics aggregation. Updated the init_team_data function to return results_dict instead of player_summary, and added logic to clean player names for better clarity. This change enhances the overall organization of player statistics and streamlines the data handling process during simulations.

Enhance player summary generation in init_team_data function of app.py. Introduced a results dictionary to aggregate player statistics across multiple games, allowing for a comprehensive summary of performance metrics. Updated the return statement to include the new player summary DataFrame, improving the clarity and usability of simulation results for users.

Refactor player data handling in init_team_data function of app.py. Changed variable name from 'player_tables' to 'working_tables' for clarity, and updated the assignment of player statistics to improve readability. Enhanced the 'playername' formatting to include a space before the game iteration number, ensuring better presentation of player data during simulations.

Refactor caching mechanism in app.py by removing the TTL parameter from the @st .cache_data decorator. This change simplifies the caching behavior for simulated statistics, ensuring data is cached without a time limit, which may improve performance during repeated simulations.

Refactor overall_team_data structure in app.py by removing the 'Opponent' column and updating the 'playername' assignment to include game iteration. This change streamlines the data representation and enhances clarity in player statistics during simulations.

Add game iteration display in init_team_data function of app.py. Introduced a new line to output the current game number and display the team data for each game iteration, enhancing user feedback and clarity during the prediction process.

Refactor overall_team_data structure in app.py by removing the 'game' column and renaming it to 'playername' for improved clarity. This change streamlines the data representation in the init_team_data function, enhancing the organization of player statistics and maintaining focus on key performance metrics.

Refactor game prediction settings in app.py to support multiple games. Introduced dynamic tab creation for each game, allowing users to input win/loss settings and kill/death predictions individually. This enhances the user experience by providing a more organized and intuitive interface for managing predictions across multiple games.

Add prediction settings to app.py for match format selection. Introduced a new subheader and selectbox for users to choose between BO1, BO3, or BO5 formats, enhancing the user interface and improving the prediction process.

Refactor UI layout in app.py to enhance user experience. Updated the selection interface for teams, opponents, win/loss options, and prediction settings by organizing them into two-column layouts. This change improves the visual structure and accessibility of input fields, facilitating a more intuitive interaction for users when making predictions.

Enhance statistical projections in init_team_data function of app.py. Updated the calculation of Kill, Death, and Assist projections to incorporate kill and death predictions, improving the accuracy of player performance metrics during win and loss scenarios. This change enhances the depth of analysis available for team data, allowing for more informed decision-making based on projected statistics.

Refactor player data display in app.py by removing background gradient for improved clarity. This change simplifies the presentation of player statistics while maintaining precision formatting, enhancing the overall user experience in analyzing performance metrics.

Refactor player data display in app.py by simplifying the presentation of statistics. Removed the pivot table and directly displayed player metrics, enhancing clarity and improving the visual representation with background gradients. This change streamlines the data display process while maintaining the integrity of the information presented.

Enhance player data display in app.py by pivoting statistics for improved clarity. Introduced a pivot table to reorganize player metrics, ensuring percentiles are displayed in the correct order. Updated the background gradient direction for better visual representation, enhancing user experience in analyzing player performance.

Fix background gradient direction in player data display in app.py. Changed the gradient axis from 0 to 1 to enhance the visual representation of player statistics, improving clarity and user experience.

Refactor percentile keys in app.py for improved clarity. Changed percentile labels from 'P10', 'P25', 'P50', 'P75', 'P90' to '10%', '25%', '50%', '75%', '90%' to enhance readability and user understanding of statistical projections for player performance metrics.

Update app.py to convert unique player list to a list format for improved tab creation. This change enhances the functionality of player-specific tabs, ensuring compatibility with the Streamlit framework and improving user experience in navigating player statistics.

Enhance player data display in app.py by introducing individual player tabs. Each tab presents player-specific statistics, including percentiles for various metrics, improving the user experience and allowing for a more detailed analysis of player performance. This update builds on previous enhancements to statistical projections and opponent performance metrics.

Add simulation of statistical projections in app.py. Introduced a new function to simulate player statistics using a normal distribution, generating percentiles for kills, deaths, assists, and CS projections. This enhancement allows for a more comprehensive analysis of player performance by incorporating simulated data, improving the overall depth of statistical insights available in the application.

Enhance opponent performance data display in init_team_data function of app.py. Added a DataFrame to output opponent-specific metrics for kills, deaths, assists, and CS projections during both win and loss scenarios. Updated the return statement to include this new DataFrame, allowing for a more comprehensive analysis of opponent performance alongside team data. This change improves the visibility and usability of performance metrics for informed decision-making.

Refactor init_team_data function in app.py to improve data handling and output format. Removed unnecessary display of opponent performance metrics and changed the return format to set the playername as the index. This update enhances the clarity of the returned data structure while maintaining the integrity of team performance evaluations.

Refactor init_team_data function in app.py to streamline statistical calculations and enhance clarity. Removed redundant statistics calculations and reorganized the logic for player and team performance metrics, focusing on win/loss scenarios. This update improves the readability and efficiency of the code while maintaining the accuracy of performance evaluations based on opponent statistics.

Refactor opponent data retrieval in init_team_data function of app.py. Updated the query to exclude the opponent filter, allowing for a broader analysis of performance metrics over the specified date range. This change enhances the flexibility of data retrieval for team performance evaluations.

Add display of opponent performance boosts in init_team_data function of app.py. Enhanced the function by including output for opponent-specific metrics related to kills, deaths, assists, and CS projections during win scenarios. This update improves the visibility of opponent performance data, aiding in more informed team performance evaluations.

Refactor statistical calculations in init_team_data function of app.py. Replaced direct calculations for kill, death, assist, and CS projections with apply method for improved readability and performance. This change enhances the clarity of the code and maintains the accuracy of team performance evaluations based on opponent statistics.

Enhance opponent performance metrics in init_team_data function of app.py. Added calculations for kills, deaths, assists, and CS projections based on opponent statistics for both win and loss scenarios. This update improves the accuracy of team performance evaluations by incorporating opponent-specific boosts, enhancing the overall depth of statistical analysis.

Refactor init_team_data function in app.py to enhance clarity and streamline table handling. Replaced count_var with a loop to iterate through data tables, improving readability and organization of statistical calculations for team performance metrics. This change contributes to better structure and understanding of kills, deaths, assists, and total CS analysis.