Server Package

Subpackages

• Crud Package
  • Submodules
  • Crud Run File
    • create()
    • delete()
    • read()
    • read_all()
    • read_all_W_filter()
    • update()
  • Crud Submission File
    • create()
    • delete()
    • get_latest_submission_for_each_team()
    • read()
    • read_all_W_filter()
    • read_all_by_team_id()
    • update()
  • Crud Submission Run Info File
    • create()
    • delete()
    • read()
    • read_all()
    • read_all_W_filter()
    • update()
  • Crud Team File
    • create()
    • delete()
    • read()
    • read_all()
    • read_all_W_filter()
    • update()
  • Crud Team Type File
    • create()
    • delete()
    • read()
    • read_all()
    • read_all_W_filter()
    • update()
  • Crud Tournament File
    • create()
    • delete()
    • get_latest_tournament()
    • read()
    • read_all()
    • read_all_W_filter()
    • update()
  • Crud Turn File
    • create()
    • create_all()
    • delete()
    • delete_all()
    • read()
    • read_all()
    • read_all_W_filter()
    • update()
  • Crud University File
    • create()
    • delete()
    • read()
    • read_all()
    • read_all_W_filter()
    • update()
  • Module contents
• Models Package
  • Submodules
  • Base Class
    • Base
      • Base.metadata
      • Base.registry
  • Run Class
    • Run
      • Run.results
      • Run.run_id
      • Run.run_time
      • Run.seed
      • Run.submission_run_infos
      • Run.tournament
      • Run.tournament_id
      • Run.turns
  • Submission Class
    • Submission
      • Submission.file_txt
      • Submission.submission_id
      • Submission.submission_run_infos
      • Submission.submission_time
      • Submission.team
      • Submission.team_uuid
  • Submission Run Info Class
    • SubmissionRunInfo
      • SubmissionRunInfo.error_txt
      • SubmissionRunInfo.player_num
      • SubmissionRunInfo.points_awarded
      • SubmissionRunInfo.run
      • SubmissionRunInfo.run_id
      • SubmissionRunInfo.submission
      • SubmissionRunInfo.submission_id
      • SubmissionRunInfo.submission_run_info_id
  • Team Class
    • Team
      • Team.submissions
      • Team.team_name
      • Team.team_type
      • Team.team_type_id
      • Team.team_uuid
      • Team.uni_id
      • Team.university
  • Team Type Class
    • TeamType
      • TeamType.eligible
      • TeamType.team_type_id
      • TeamType.team_type_name
      • TeamType.teams
  • Timestamp Class
    • TimeStamp
      • TimeStamp.impl
      • TimeStamp.process_bind_param()
      • TimeStamp.process_result_value()
  • Tournament Class
    • Tournament
      • Tournament.is_finished
      • Tournament.launcher_version
      • Tournament.runs
      • Tournament.runs_per_client
      • Tournament.start_run
      • Tournament.tournament_id
  • Turn Class
    • Turn
      • Turn.run
      • Turn.run_id
      • Turn.turn_data
      • Turn.turn_number
  • University Class
    • University
      • University.teams
      • University.uni_id
      • University.uni_name
  • Module contents
• Schemas Package
  • Subpackages
    • Run Package
      • Submodules
      • Run Base Class
      • Run Schema Class
      • Run Schema Without Tournament Class
      • Module contents
    • Submission Package
      • Submodules
      • Submission Base Class
      • Submission Partial Class
      • Submission Schema Class
      • Submission with Team Class
      • Module contents
    • Submission Run Info Package
      • Submodules
      • Submission Run Info Base Class
      • Submission Run Info Schema Class
      • Submission Run Info with Run Class
      • Submission Run Info with Submission Class
      • Module contents
    • Team Package
      • Submodules
      • Team Base Class
      • Team ID Schema Class
      • Team Schema Class
      • Team Schema Partial Class
      • Module contents
    • Team Type Package
      • Submodules
      • Team Type Class
      • Team Type Schema Class
      • Module contents
    • Tournament Package
      • Submodules
      • Tournament Base Class
      • Tournament Schema Class
      • Module contents
    • Turn Package
      • Submodules
      • Turn Base Class
      • Turn Schema Class
      • Module contents
    • University Package
      • Submodules
      • University Base Class
      • University Schema Class
      • Module contents
  • Module contents
• Server Unit Tests Package
  • Submodules
  • Test Main File
    • test_read_get_submission()
    • test_read_get_submissions()
    • test_read_root()
  • Test Run File
    • test_get_runs()
    • test_get_runs_param()
  • Test Submission File
    • test_get_nonexistent_submission()
    • test_get_submission()
    • test_get_submissions()
    • test_post_submission()
  • Test Team File
    • test_post_team()
  • Test Team Types File
    • test_get_team_types()
  • Test Tournament File
    • test_get_tournaments()
  • Test University File
    • test_get_universities()
  • Module contents

Submodules

Client Runner Class

class server.client_runner.ClientRunner

Bases: object

This class is responsible for running submitted client bots against each other and getting the results from the games.

buffUpData() → None

This will create the different universities and team types to add to the database. This can be modified for different competitions; add or subtract from it as needed. :return: None

close_server() → None

This method will delete the tournament from the database if it exists and is not finished with all the games. Regardless, the runner_temp folder will be deleted. :return: None

count_number_of_game_appearances(games: list[tuple[server.models.submission.Submission, server.models.submission.Submission]]) → int

Returns the number of games a client appears in. :param games: :return: the count of games a client appears in

delete_runner_temp() → None

Continually tries to delete the runner_temp folder. :return: None

delete_tournament_cascade(tournament_id: int) → None

Deletes the specified Tournament from the database by using the given id. :param tournament_id: :return: None

delete_turns() → None

Deletes all entries from the Turn datatable. :return: None

external_runner() → None

This method is extensive and has different steps to it. Print statements help show where the runner is in the process.

1. Step 1: Get the most recent submission for every team that is in the database.

2. Step 2:

   • 1. If there are less than 2 total submissions, end the method; nothing can be done

   • 2. Otherwise, proceed to the next step

3. Step 3: Get all team pairings based on all clients in the database. This will be the pairings for each game.

#. Step 4: Assign a value to self.total_number_of_games_for_one_client based on what’s returned from the self.count_number_of_game_appearances() method. #. Step 5: Insert a new tournament into the database and assign it to self.tournament. #. Step 6: Delete all turns from the database. Witihout doing so, the Turns table will continue to accumulate data for each new tournament and become very cumbersome. #. Step 7: Make the runner_temp and seeds folders #. Step 8: For the amount of games against the same client specified in server_config.py, run the runner. #. Step 9: Run the games in parallel with each other to increase performance. :return: None

get_version_number() → str

runs a script in the runner folder. end path is where the runner is located runner is the name of the script (no extension)

insert_logs(logs: list[server.schemas.turn.turn_base.TurnBase]) → None

Inserts the given logs in the database. :param logs: a list of Turn objects to insert into the database :return: None

insert_new_tournament() → Tournament

Inserts a new Tournament in the database and returns it. Relates all the runs in this process together :return: a Tournament object

insert_run(tournament_id: int, seed_id: int, results: dict) → int

Inserts a new Run in the database and returns it. :param tournament_id: :param seed_id: :param results: :return: the newly inserted Run’s id

insert_submission_run_info(submission_id: int, run_id: int, error: str | None, player_num: int, points_awarded: int) → None

Inserts a new SubmissionRunInfo entry in the database. :param submission_id: :param run_id: :param error: :param player_num: :param points_awarded: :return: None

internal_runner(submission_tuple, index) → None

Parameters:

• submission_tuple –

• index –

Returns:

read_best_logs_and_insert() → None

Finds the best logs from the client and inserts them into the database :return: None

return_team_parings(submissions: list[server.models.submission.Submission]) → list[tuple[server.models.submission.Submission, server.models.submission.Submission]]

This method will take a list of Submission entries and a list with every pairing of them. Also considers the number of games against the same team and increases the pairings by that value. :param submissions: :return: a list of tuples that has the submissions of each team pairing

run_runner(end_path, runner) → bytes

runs a script in the runner folder. end path is where the runner is located runner is the name of the script (no extension)

update_tournament_finished() → None

Updates the tournament to have the is_finished bool to be True. :return: None

Database Class

server.database.set_sqlite_pragma(dbapi_connection, connection_record)

Executes the following commands when the database is connected. :param dbapi_connection: :param connection_record: :return:

Main Class

This file is the main entry point for the server, creating endpoints for the clients. It should be noted that the runners do not require endpoints as they run on the server and utilize the crud files to interact with the DB.

server.main.get_db()

Get a database session for orm and query execution :return:

server.main.get_latest_tournament(db: Session = Depends(get_db))

An endpoint to retrieve the latest tournament. :param db: DB session. :return:

server.main.get_runs(db: Session = Depends(get_db))

Gets the runs in the DB. This is currently unused and would be a resource intensive call if it was used. :param db: DB session. :return:

server.main.get_submission(submission_id: int, team_uuid: str, db: Session = Depends(get_db))

Gets the submission information for an id provided. :param submission_id: An int representing the submission id. :param team_uuid: A string representing the team Universally Unique Identifier. :param db: DB session. :return:

server.main.get_submissions(team_uuid: str, db: Session = Depends(get_db))

Gets the submissions for a given team. :param team_uuid: A string representing the team Universally Unique Identifier. :param db: DB session. :return:

server.main.get_team_info(uuid: str, db: Session = Depends(get_db))

This endpoint is currently unused, this endpoint could be used to get the team information. :param uuid: UUID of the team, also known as vID. :param db: DB session. :return:

server.main.get_team_types(db: Session = Depends(get_db))

Gets the team types in the DB. :param db: DB session. :return:

server.main.get_tournament(tournament_id: int, db: Session = Depends(get_db))

Gets a single tournament from the DB by id. :param tournament_id: An int representing the id of a tournament. :param db: DB session. :return:

server.main.get_tournaments(db: Session = Depends(get_db))

Gets the tournaments from the DB. :param db: DB session. :return:

server.main.get_universities(db: Session = Depends(get_db))

Gets the universities in the DB. :param db: DB session. :return:

server.main.post_submission(submission: SubmissionWTeam, db: Session = Depends(get_db))

Submission post endpoint. :param submission: Submission with Team schema (dict) is what is expected in the request body. :param db: DB session. :return:

server.main.post_team(team: TeamBase, db: Session = Depends(get_db))

Team post endpoint. :param team: Team base schema (dict) is what is expected in the request body. :param db: DB session. :return:

server.main.root()

Root endpoint. :return:

server.main.run_with_return_to_client(func: Callable) → Callable

A decorator for returning errors to the client instead of leaving errors on serverside only :param func: :return:

Runner Utils Class

class server.runner_utils.DB

Bases: object

server.runner_utils.worker_main(jobqueue: Queue)

Server Config Class

class server.server_config.Config

Bases: object

Number Of Games Against Same Team

The Number Of Games Against Same Team is an int representing how many runs should be repeated. It is worth noting that this should be 1 if the development team has ensured that randomness is seeded, ensuring that two games with the same seed play out the same way. Competitor randomness is their own liability and not the development team’s responsibility.

The Sleep Time Between Runs is an int representing the number of seconds between each run of the client runner. Each time the client runner is run, it will generate an entire tournament. The run time of the client runner is not factored into this time.

The End DateTime is an ISO formatted string representing the end of the competition. This will need to be changed for every competition. Ex. ‘YYYY-mm-dd HH:MM’, like ‘2030-01-01 00:00’

The Sleep Time Between Vis is an int representing the number of seconds between each run of the visualizer. Each time the visualizer is run, it will visualize the best runs for each team of the tournament. The run time of the visualizer is not factored into this time. If the visualizer isn’t running on the server, increase this parameter as a potential solution.

---

property END_DATETIME: str

The End DateTime is an ISO formatted string representing the end of the competition. This will need to be changed for every competition. :return: str

property NUMBER_OF_GAMES_AGAINST_SAME_TEAM: int

The Number Of Games Against Same Team is an int representing how many runs should be repeated. It is worth noting that this should be 1 if the development team has ensured that randomness is seeded, ensuring that two games with the same seed play out the same way. Competitor randomness is their own liability and not the development team’s responsibility. :return: int

property SLEEP_TIME_SECONDS_BETWEEN_RUNS: int

The Sleep Time Between Runs is an int representing the number of seconds between each run of the client runner. Each time the client runner is run, it will generate an entire tournament. The run time of the client runner is not factored into this time. :return: int

property SLEEP_TIME_SECONDS_BETWEEN_VIS: int

The Sleep Time Between Vis is an int representing the number of seconds between each run of the visualizer. Each time the visualizer is run, it will visualize the best runs for each team of the tournament. The run time of the visualizer is not factored into this time. If the visualizer isn’t running on the server, increase this parameter as a potential solution. :return: int

Visualizer Runner Class

class server.visualizer_runner.VisualizerRunner

Bases: object

delete_vis_temp_folder() → None

get_latest_log_files(tournament: Tournament) → None

get_latest_tournament() → Tournament | None

internal_runner() → None

refresh_vis_temp_folder() → None

visualizer_loop() → None

Module contents