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)]: Can you help me find the matches in the atp_tennis dataset where Roger Federer is either Player_1 or Player_2? I would like to have a list of Match IDs for these matches. Please generate and display a list of match indices involving the player 'Federer R.' in the ATP tennis dataset.

[YOU (AI assistant)]: Sure, I can help you with that. To find the matches where Roger Federer is either Player_1 or Player_2, you can use the following code :
'''
import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file, assert_series, logical_or, to_list, fetch_index

atp_tennis = read_csv_file('atp_tennis.csv')

# Filter the DataFrame
federer_matches = atp_tennis[logical_or(assert_series(atp_tennis['Player_1'], 'Federer R.', 'equality'), assert_series(atp_tennis['Player_2'], 'Federer R.', 'equality'))]

# Get the index using the custom function
federer_match_ids_index = fetch_index(federer_matches)

# Convert the index to a list
federer_match_ids = to_list(federer_match_ids_index)

print(federer_match_ids)

'''

[USER (data scientist)]: Hey, I have a dataset of ATP tennis matches in a CSV file called "atp_tennis.csv". I'd like to analyze the performance of a player named "Raonic M." against all opponents that Roger Federer has faced. Can you help me with that? 

[YOU (AI assistant)]: Sure! First, let's load the dataset using pandas. Do you have pandas installed? 

[USER (data scientist)]: Yes, I have pandas installed. 

[YOU (AI assistant)]: Great! Let's start by importing pandas and loading the dataset: 
'''
import pandas as pd
from decision_company import read_csv_file

# Load the dataset 
atp_tennis = read_csv_file('atp_tennis.csv')
'''
[USER (data scientist)]: Awesome! Now, can you find all the matches where Federer has played? Please generate and display a list of unique opponents who have played against 'Federer R.' in the ATP tennis dataset.

[YOU (AI assistant)]: Sure, let's filter the dataset to find all the matches where Federer is either Player_1 or Player_2 :
'''
import pandas as pd
import pickle
from decision_company import read_csv_file, fetch_column, logical_or, search_where, extract_unique_values, assert_series

atp_tennis = read_csv_file('atp_tennis.csv')

# Find Federer matches
federer_matches = atp_tennis[logical_or(assert_series(atp_tennis['Player_1'], 'Federer R.', 'equality'), assert_series(atp_tennis['Player_2'], 'Federer R.', 'equality'))]

# Get Federer opponents
federer_opponents = extract_unique_values(search_where(fetch_column(federer_matches, 'Player_1'), assert_series(federer_matches['Player_1'], 'Federer R.', 'inequality'), federer_matches['Player_2'])) 

print(federer_opponents)

'''

[USER (data scientist)]: Great! Now, can you calculate the surface performance of Raonic M. against each of Federer's opponents? Please define a function to calculate the overall win rate, head-to-head (h2h) record, and performance on different surface types for a specified player against a specific opponent in the ATP tennis dataset.

[YOU (AI assistant)]: Sure, let's modify the existing function to include surface performance calculation :
'''
import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file, logical_and, logical_or, assert_series

atp_tennis = read_csv_file('atp_tennis.csv')

def calculate_performance(player, opponent, data, surface_types):
    player_matches = data[logical_or(logical_and(assert_series(data['Player_1'], player, 'equality'), assert_series(data['Player_2'], opponent, 'equality')), logical_and(assert_series(data['Player_1'], opponent, 'equality'), assert_series(data['Player_2'], player, 'equality')))]
    total_matches = len(player_matches)
    wins = len(player_matches[assert_series(player_matches['Winner'], player, 'equality')])
    win_rate = wins / total_matches if total_matches > 0 else 0

    h2h_record = wins / total_matches if total_matches > 0 else 0

    surface_performance = {}
    for surface in surface_types:
        player_surface_matches = player_matches[assert_series(player_matches['Surface'], surface, 'equality')]
        player_surface_wins = len(player_surface_matches[assert_series(player_surface_matches['Winner'], player, 'equality')])
        surface_performance[surface] = player_surface_wins / player_surface_matches.shape[0] if player_surface_matches.shape[0] > 0 else 0

    return win_rate, h2h_record, surface_performance

'''

[USER (data scientist)]: That's a nice function! Now, let's create a dataframe to store the results and loop through Federer's opponents to calculate the performance of Raonic M. Please generate and display a DataFrame containing win rate, head-to-head records, and surface performance of 'Raonic M.' against each of his opponents in the ATP tennis dataset.

[YOU (AI assistant)]: Sure, let's initialize an empty dataframe with the required columns and loop through Federer's opponents to calculate the performance :
'''
import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file, create_dataframe, concatenate_objects, extract_unique_values, update_dict

atp_tennis = read_csv_file('atp_tennis.csv')

# Retrieve unique surface types
surface_types = extract_unique_values(atp_tennis['Surface'])

# Initialize an empty dataframe for storing the results
columns = ['Player', 'Opponent', 'Win Rate', 'Head-to-Head'] + [f'{surface} Surface Performance' for surface in surface_types]
player_stats = create_dataframe(data=[], columns=columns)

# Loop through Federer's opponents
for opponent in federer_opponents:
    # Calculate win rate, head-to-head record, and surface performance for Raonic M. against each opponent
    win_rate, h2h_record, surface_performance = calculate_performance('Raonic M.', opponent, atp_tennis, surface_types)

    # Append the results to the dataframe
    row_data = {'Player': 'Raonic M.', 'Opponent': opponent, 'Win Rate': win_rate, 'Head-to-Head': h2h_record}
    update_dict(row_data, {f'{surface} Surface Performance': surface_performance[surface] for surface in surface_types})
    player_stats = concatenate_objects(player_stats, create_dataframe(row_data, index=[0]))  

# Display the resulting dataframe   
print(player_stats)

'''

[USER (data scientist)]: Hey Tapilot, I have this dataset of tennis matches, and I want to update the odds for each match based on the new competitors' performance. Can you help me figure out the head-to-head win rates for each player? Please define a function to calculate the head-to-head win rates for all unique player pairings in the ATP tennis dataset.

[YOU (AI assistant)]: Absolutely! Here's a function that calculates the head-to-head win rates for each player in your dataset :
'''
import pandas as pd
import numpy as np
import pickle
from decision_company import read_csv_file, concatenate_objects, bind_dataframe, reset_index, rename_columns, join_dataframes, assert_series, extract_unique_values, fetch_df_size, create_multiindex_from_product, convert_multiindex_to_dataframe, remove_labels, fill_missing_values

atp_tennis = read_csv_file('atp_tennis.csv')

def calculate_head_to_head_win_rate(data):
    unique_players = extract_unique_values(concatenate_objects(data['Player_1'], data['Player_2']))

    total_matches = reset_index(fetch_df_size(bind_dataframe(data, ['Player_1', 'Player_2'])), drop=False)
    total_matches = rename_columns(total_matches, columns={0: 'count_total'})

    player_wins = fetch_df_size(bind_dataframe(data[assert_series(data['Winner'], data['Player_1'], 'equality')], ['Player_1', 'Player_2']))
    player_wins = reset_index(player_wins, drop=False)
    player_wins = rename_columns(player_wins, {0: 'count_wins'})

    multiindex = create_multiindex_from_product([unique_players, unique_players], names=['Player', 'Opponent'])
    all_pairs = convert_multiindex_to_dataframe(multiindex, index=False)
    all_pairs = all_pairs[assert_series(all_pairs['Player'], all_pairs['Opponent'], 'inequality')]

    h2h_win_rates = remove_labels(join_dataframes(all_pairs, total_matches, left_on=['Player', 'Opponent'], right_on=['Player_1', 'Player_2'], how='left'), columns=['Player_1', 'Player_2'])
    h2h_win_rates = remove_labels(join_dataframes(h2h_win_rates, player_wins, left_on=['Player', 'Opponent'], right_on=['Player_1', 'Player_2'], how='left'), columns=['Player_1', 'Player_2'])

    fill_missing_values(h2h_win_rates['count_wins'], value=0, inplace=True)
    fill_missing_values(h2h_win_rates['count_total'], value=1, inplace=True)

    h2h_win_rates['Head-to-Head Win Rate'] = h2h_win_rates['count_wins'] / h2h_win_rates['count_total']
    h2h_win_rates = remove_labels(h2h_win_rates, columns=['count_total', 'count_wins'])

    return h2h_win_rates

'''

[USER (data scientist)]: Awesome! Now, I'd like to estimate the probabilities using player performance and head-to-head records, with a 70% weight for the new competitor's win rate. Please define a function to estimate the probability of winning for two players in a tennis match, based on their individual win rates, head-to-head win rates, and specified weights for overall performance and head-to-head results.

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

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

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

---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)]: Sure thing! Here's a function that does just that, taking into account the performance and head-to-head weights: 
'''
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

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

# YOUR SOLUTION BEGIN:
