nishanthmuruganantham / points-table-simulator Goto Github PK

This package will simulate the points table based on different possible results in a sports tournament and generate the favorable outcomes needed to make your favorite team to be placed at your expected position in the points table

Home Page: https://pypi.org/project/points-table-simulator/

License: MIT License

Python 99.64% Shell 0.36%

cricket football indian-premier-league ipl playoff points-table sports tournament ipl-calculator points

points-table-simulator's Introduction

points-table-simulator🔢

During the later part of the league stages in many multi-team tournaments 🏆 such as 🏏 Indian Premier League(IPL), Australian Big Bash League (BBL), ets., the fans will look for possible match outcomes for the remaining league matches, which could lead their favourite team to get qualified for further stage in the tournament (Playoffs). Here, the fans calculate their points table📊 to see their favourite team being placed in the position needed to qualify for Playoffs🏃🏻.

This tool🛠️ come as handy for those Sports enthusiasts which would help them to forsee the necessary remaining match outcomes to see their favourite team qualifying for playoffs✅ with the necessary match outcomes along with the respective points table📊.

This python package📦 will simulate the points table📊 based on different possible results in a sports tournament.

The PointsTableSimulator package provides a powerful tool for simulating and analyzing points tables for sports tournaments. Whether you're organizing or following a tournament, this package offers the flexibility to input tournament schedules, define points systems, and explore various match outcome scenarios to understand team standings and qualification possibilities.

Installation

Install this package with pip

pip install points-table-simulator

Usage/Examples

Please find the example usage from the below python code

from points_table_simulator import PointsTableSimulator
import pandas as pd

# Load the tournament schedule DataFrame
tournament_schedule = pd.read_csv("tournament_schedule.csv")

# Note: 
# The tournament schedule DataFrame should have the following columns:
#   - "match_number" column containing the match number
#   - "home" column containing the home team names
#   - "away" column containing the away team names
#   - "winner" column containing the match result (winning_team_name, draw, or no result)

# If the tournament schedule DataFrame contains different names than this, you can use arguments in PointsTableSimulator class to
# specify the column names. 

# Instantiate the PointsTableSimulator object
simulator = PointsTableSimulator(
    tournament_schedule=tournament_schedule,
    points_for_a_win=3,
    points_for_a_no_result=1,
    points_for_a_draw=1
)

# Get the current points table
current_table = simulator.current_points_table      # current_points_table is an attribute of PointsTableSimulator class

# Simulate qualification scenarios for a specific team
points_tables, qualification_match_results = simulator.simulate_the_qualification_scenarios(
    team_name="Team A",
    top_x_position_in_the_table=4,
    desired_number_of_scenarios=5
)

# points_tables - will return the list of points_tables (pd.Dataframe) for different qualification scenarios
# qualification_match_results - will return the list of table containing remaining match outcomes which could favour their team to get qualified for the given position

This package can also be used in Football tournaments such as English Premier League (EPL), Laliga, etc., when you want to generate the scenarios in which your favourite team can be placed in your expected position in the pointstable.

License

MIT

points-table-simulator's People

Contributors

Watchers

points-table-simulator's Issues

Correct the PyPI url for release

Add pyright check in the quality_check pipeline

Configure a pipeline to check for imports check whenever an MR is created

Add checks to validate the input schedule Dataframe

Configure the quality_checks pipeline with the MR creation and MR commits

Correct the Readme file

Return the remaining matches schedule dataframe with result instead of returning the df with results for all the matches

In the simulate_the_qualification_scenarios function of PointsTableSimulator class, while simulating the possible qualification scenarios, the full schedule df is being copied and considered for updating with possible results for remaining matches. Instead of updating a dataframe with all the matches, a new df should be formed with only the remaining schedule and the same has to be updated while simulating the winning scenarios

Correct the match lost count in generated points table

Add success tests to test the simulate_qualification_scenario function

Add the docstring for all test functions

Rename the arguments name for teams in the PointsTableSimulator class

Add the tournament_completion_percentage as an attribute to TournamentCompletionBelowCutoffError

Update tournament completion cutoff percentage

Configure a pipeline to create the virtual environment with the necessary packages to install

Update the release workflow to publish only for PyPI

Add all_possible_outcomes_for_remaining_fixture as an attribute to the class

Configure back the Test PyPI release in pipeline

Write a function to calculate the current points table based on provided Schedule Dataframe

Add an attribute to find the number_of_completed_matches

Draft the Github Readme Page

Add column name as attribute for InvalidScheduleDataError exception

Implement the Functionality to Find Qualification Scenarios for Teams in Points Table

Add validation functions to validate the input parameters and incoming dataframe columns

Correct the exception message and column name as attribute for InvalidColumnNamesError exception

Correct the pylint errors in points_table_simulator file

Write the unit test to check the behavior of Validation functions

Keep the logic of finding the favorable scenario as a private function

Setup the initial files for this Repository

Optimize the code and improve the performance of the simulate_the_qualification_scenarios function

Update the Readme File

Remove the line
# Calculate the current points table current_table = simulator.current_points_table()

Keep the sh codes in a separate file and folder

Define the class and basic constructor for points table simulator

Import the major classes in the init file to make the module import simpler

Draft the workflow to publish the package in testPyPI and PyPI

Configure the pipeline for PyPI release

Add Cutoff Percentage for simulate_the_qualification_scenarios Function

In the simulate_the_qualification_scenarios function of the PointsTableSimulator class, the itertools.product function is currently being used to generate all possible outcomes of the remaining matches. However, this approach may lead to a large number of scenarios and iterations, especially when the number of remaining group stage matches is high. As a result, it can potentially increase memory consumption and complexity.

To address this issue and improve the efficiency of the function, we propose adding a cutoff percentage based on the completion of the tournament. Once the percentage of matches completed in the tournament exceeds this cutoff percentage, the function will become available for use. Otherwise, attempting to use the function will result in an exception being thrown, informing the user about this restriction.

This cutoff percentage will help prevent excessive memory usage and streamline the process of generating qualification scenarios, ensuring a better user experience. Additionally, it aligns with our goal of optimizing the function's performance while providing valuable insights for users.