There is the data: atp_tennis containing the following columns: ['Tournament', 'Date', 'Series', 'Court', 'Surface', 'Round', 'Best of', 'Player_1', 'Player_2', 'Winner', 'Rank_1', 'Rank_2', 'Pts_1', 'Pts_2', 'Odd_1', 'Odd_2', 'score'].  
--- The description for each column this data is:
Tournament: Name of the tennis tournament (Brisbane International, Chennai Open, Qatar Exxon Mobil Open ...etc)
Date: Date the match was played (year-month-day)
Series: Category or level of the tennis tournament (ATP250, ATP500, Masters1000 and Grand Slams offer 250, 500, 1000, and 2000 ranking points to the winner seperately.)
Court: Place the match was held (Indoors or Outdoors)
Surface: Type of court surface (Hard, Grass and Clay)
Round: Stage of the tournament (1st Round, 2nd Round, Quarterfinals, Semifinal and The Final)
Best of: Tourament systems ("best of 3" or "best of 5")
Player_1: Name of the first competitor in each match
Player_2: Name of the second competitor in each match
Winner: Name of the Player_1 or Player_2 who won the match 
Rank_1: World rankings of the Player_1 at the time of the match
Rank_2: World rankings of the Player_2 at the time of the match
Pts_1: Ranking points held by Player_1 before the match (accumulated over the season and higher points typically indicate a more successful player)
Pts_2: Ranking points held by Player_2 before the match
Odd_1: Betting odds for Player_1 (reflecting their perceived chances of winning)
Odd_2: Betting odds for Player_2 
Score: Final score of the match ("score of Player_1" - "score of Player_2")
---
Considering contents from the dataset and requirements from user. Please note DO NOT CHANGE FILE AND VARIABLE NAMES THAT I HAVE SET!
Interactions begin:
[USER (data scientist)]: Hi Tapilot, I need your assistance in analyzing the atp_tennis dataset to answer some specific questions about the top 10 ranked players in the last five years. Who are the top 10 ranked players in the dataset from the last five years? Please provide a list of player names along with their rankings.

[YOU (AI assistant)]: Sure, I can help you with that. First, we need to filter the dataset to only include matches from the last five years. Then, we can find the top 10 ranked players based on their highest ranking during that period. Here's the code to do that :
'''
import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file, convert_to_datetime, get_max, to_list, get_min_value, sort_by_values, get_first_n_rows, create_date_offset, filter_by_date, concatenate_objects, reset_index, rename_columns, bind_dataframe

# Load the dataset
atp_tennis = read_csv_file("atp_tennis.csv")

# Convert the 'Date' column to datetime format
atp_tennis['Date'] = convert_to_datetime(atp_tennis['Date'])

# Find the last date in the dataset
last_date = get_max(atp_tennis['Date'])

# Filter the dataset to only include matches from the last five years
five_years_ago = last_date - create_date_offset(years=5)
recent_matches = filter_by_date(atp_tennis, 'Date', five_years_ago)

concatenated_data = concatenate_objects(
    recent_matches[['Player_1', 'Rank_1']],
    rename_columns(recent_matches[['Player_2', 'Rank_2']], {'Player_2': 'Player_1', 'Rank_2': 'Rank_1'})
)
grouped_data = bind_dataframe(concatenated_data, 'Player_1')
min_values = get_min_value(grouped_data)
sorted_data = sort_by_values(min_values, 'Rank_1')
top_10_ranked_players = get_first_n_rows(sorted_data, 10)

# Convert the top 10 ranked players and their rankings to a Python list
top_10_ranked_players_list = to_list(reset_index(top_10_ranked_players, drop=False))

print(top_10_ranked_players_list)

'''

[USER (data scientist)]: Great, now that we have the top 10 ranked players. What is the win rate of each of the top 10 players on grass courts in the last five years? Please provide a data table with player names, number of matches played, number of matches won, and win rate percentage.

[YOU (AI assistant)]: Sure, I can help you calculate the win rate of each of the top 10 players on grass courts in the last five years. We'll first filter the dataset to only include grass court matches played by the top 10 players in the last five years. Then, we'll calculate the number of matches played, number of matches won, and win rate percentage for each player. Here's the code to do that :
'''
import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file, check_elements_in_list, assert_series, logical_and, logical_or, count_unique_values, fill_missing_values, create_dataframe, reset_index

atp_tennis = read_csv_file('atp_tennis.csv')

# Remove any extra spaces from the player names
top_10_player_names = [player[0].strip() for player in top_10_ranked_players_list]

# Filter the dataset to only include grass court matches played by the top 10 players in the last five years
player_1_in_top_10 = check_elements_in_list(recent_matches['Player_1'], top_10_player_names)
player_2_in_top_10 = check_elements_in_list(recent_matches['Player_2'], top_10_player_names)
matches_with_top_10_players = logical_or(player_1_in_top_10, player_2_in_top_10)

matches_on_grass = assert_series(recent_matches['Surface'], 'Grass', 'equality')

grass_matches = recent_matches[logical_and(matches_on_grass, matches_with_top_10_players)]

# Calculate the number of matches played by each player
matches_played = count_unique_values(grass_matches['Player_1']) + count_unique_values(grass_matches['Player_2'])
matches_played = fill_missing_values(matches_played[top_10_player_names],0)

# Calculate the number of matches won by each player
matches_won = count_unique_values(grass_matches['Winner'])
matches_won = fill_missing_values(matches_won[top_10_player_names],0)

# Calculate the win rate percentage for each player
win_rate_percentage = (matches_won / matches_played) * 100

# Create a data table with player names, number of matches played, number of matches won, and win rate percentage
win_rate_table = create_dataframe({'Player': top_10_player_names, 'Matches Played': matches_played, 'Matches Won': matches_won, 'Win Rate Percentage': win_rate_percentage})
win_rate_table = reset_index(win_rate_table)

print(win_rate_table)

'''

[USER (data scientist)]: Thanks, Tapilot. Now, how do the top 10 players perform against each other in head-to-head matchups on grass courts in the last five years? Please provide a matrix table displaying head-to-head win-loss records between each pair of the top 10 players.

[YOU (AI assistant)]: Sure, I can help you create a matrix table displaying head-to-head win-loss records between each pair of the top 10 players on grass courts in the last five years. We'll first filter the dataset to only include grass court matches played between the top 10 players in the last five years. Then, we'll create a matrix table to display the head-to-head win-loss records. Here's the code to do that :
'''
import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file, create_zeros_array, create_dataframe, check_elements_in_list, iterate_rows, access_dataframe_loc, update_dataframe_loc

atp_tennis = read_csv_file('atp_tennis.csv')

# Assuming grass_matches and top_10_player_names are already defined
head_to_head_array = create_zeros_array((10, 10))
head_to_head_matrix = create_dataframe(head_to_head_array, columns=top_10_player_names, index=top_10_player_names)

# Filter grass matches where both players are in the top 10
head_to_head_matches = grass_matches[(check_elements_in_list(grass_matches['Player_1'], top_10_player_names)) & (check_elements_in_list(grass_matches['Player_2'], top_10_player_names))]

# Iterate over filtered matches, updating the head-to-head matrix with the winner and loser of each match
for index, row in iterate_rows(head_to_head_matches):
	winner = row['Winner']
	loser = row['Player_1'] if row['Player_1'] != winner else row['Player_2']
	current_value = access_dataframe_loc(head_to_head_matrix, winner, loser)
	update_dataframe_loc(head_to_head_matrix, winner, loser, current_value + 1)

print(head_to_head_matrix)

'''

[USER (data scientist)]: Great, how do the top 10 players perform in specific rounds of grass court tournaments (early rounds, quarterfinals, semifinals, finals) in the last five years? Please provide a data table with player names and their performance (number of matches played, won, and win rate) in each round of the grass court tournaments. Early Round contains 1-4th round.

[YOU (AI assistant)]: Sure, I can help you analyze the performance of the top 10 players in specific rounds of grass court tournaments in the last five years. We'll first filter the dataset to only include grass court matches played by the top 10 players in the last five years. Then, we'll calculate the number of matches played, won, and win rate for each player in each round of the grass court tournaments. Here's the code to do that :
'''
import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file, assert_series, logical_or, logical_and, create_dataframe

atp_tennis = read_csv_file('atp_tennis.csv')

# Define the tournament rounds
rounds = ['Early Round', 'Quarterfinals', 'Semifinals', 'Final']

# Initialize an empty list to store the performance data
performance_data_list = []

# Calculate the performance data for each player in each round
for player in top_10_player_names:
    for round_name in rounds:
        if round_name == 'Early Round':
            # Filter the dataset to only include matches played by the player in the early rounds
            player_round_matches = grass_matches[logical_or(logical_or(logical_or(assert_series(grass_matches['Round'], '1st Round', 'equality'), assert_series(grass_matches['Round'], '2nd Round', 'equality')), assert_series(grass_matches['Round'], '3rd Round', 'equality')), assert_series(grass_matches['Round'], '4th Round', 'equality')) & logical_or(assert_series(grass_matches['Player_1'], player, 'equality'), assert_series(grass_matches['Player_2'], player, 'equality'))]
        else:
            # Filter the dataset to only include matches played by the player in the specific round
            player_round_matches = grass_matches[logical_and(assert_series(grass_matches['Round'], round_name, 'equality'), logical_or(assert_series(grass_matches['Player_1'], player, 'equality'), assert_series(grass_matches['Player_2'], player, 'equality')))]

        # Calculate the number of matches played
        matches_played = len(player_round_matches)

        # Calculate the number of matches won
        matches_won = len(player_round_matches[assert_series(player_round_matches['Winner'], player, 'equality')])

        # Calculate the win rate
        win_rate = (matches_won / matches_played) * 100 if matches_played > 0 else 0

        # Append the performance data to the list
        performance_data_list.append({'Player': player, 'Round': round_name, 'Matches Played': matches_played, 'Matches Won': matches_won, 'Win Rate': win_rate})

# Convert the list to a DataFrame
performance_data = create_dataframe(performance_data_list)

print(performance_data)

'''

[USER (data scientist)]: Thanks, Tapilot. Finally, do the top 10 tennis players exhibit any patterns or trends in their performance on grass courts, particularly in terms of notable opponents they struggle against？Please generate a notable opponents list, and assume opponents who have won at least 3 matches as common oppnents.

My template of code snippet is:

---BEGIN CODE TEMPLATE---

import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file,

# please import the necessary private functions from decision_company first

atp_tennis = read_csv_file('atp_tennis.csv')

# YOUR SOLUTION BEGIN:
<code1>
[COMPLETE YOUR CODE] 
</code1>
# YOUR SOLUTION END

print(notable_opponents_list)

# save data
pickle.dump(notable_opponents_list,open("./pred_result/notable_opponents_list.pkl","wb"))

---END CODE TEMPLATE---

Please note that you have to generate the WHOLE python code instead of code segments based on the code snippet using Pandas library 2.0.3 version and Matplotlib library 3.7.4 version. You must keep all comments in code snippet unchanged.

[YOU (AI assistant)]: To answer these questions, we'll analyze the dataset to find notable opponents the top 10 players struggle against, identify areas of improvement for each player, and discuss other factors that may impact their performance on grass courts. Here's the code to do that:
'''
import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file,

# please import the necessary private functions from decision_company first

atp_tennis = read_csv_file('atp_tennis.csv')

# YOUR SOLUTION BEGIN:
