Who, What, and When: Transactional-Level Analysis of Senators' Trades with Accuracy Measuremenets and Trends Through the FMP API and the SEC website

				
					import yfinance as yf
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from matplotlib.lines import Line2D
import matplotlib.dates as mdates  # Import for handling date formatting

# Parameters
t_days = 30  # Number of days to check for accuracy
transaction_amount_threshold = 10000  # Amount threshold for visualization
top_n_symbols = 5

# Assuming 'senate_trading_df' is already defined
senate_trading_df['transactionDate'] = pd.to_datetime(senate_trading_df['transactionDate'])

def amount_to_numeric(amount_str):
    amounts = [int(s.replace(',', '').replace('$', '')) for s in amount_str.split('-')]
    return sum(amounts) / len(amounts)

senate_trading_df['numeric_amount'] = senate_trading_df['amount'].apply(amount_to_numeric)
senate_trading_df['transactionType'] = np.where(senate_trading_df['type'].str.contains('Purchase'), 'Buy', 'Sell')
total_avg_amount_by_date_and_type = senate_trading_df.groupby(['transactionDate', 'symbol', 'transactionType']).agg({'numeric_amount': 'sum'}).reset_index()

start_date = senate_trading_df['transactionDate'].min()
end_date = senate_trading_df['transactionDate'].max() + pd.Timedelta(days=5)  # Extend for accuracy check

top_symbols = senate_trading_df['symbol'].value_counts().head(top_n_symbols).index.tolist()

fig, axes = plt.subplots(nrows=len(top_symbols), figsize=(16, 4 * len(top_symbols)), squeeze=False)

#accuracies = []

for i, symbol in enumerate(top_symbols):
    ax = axes[i][0]
    stock_data = yf.download(symbol, start=start_date, end=end_date)

    ax.plot(stock_data.index, stock_data['Close'], label=f'{symbol} Close Price', color='blue')

    ax2 = ax.twinx()
    ax2.fill_between(stock_data.index, 0, stock_data['Volume'], color='grey', alpha=0.3)
    ax2.set_ylabel('Volume', color='grey')
    ax2.tick_params(axis='y', labelcolor='grey')
    ax2.set_ylim(0, max(stock_data['Volume'])*4)

    correct_buy_signals, total_buy_signals = 0, 0
    correct_sell_signals, total_sell_signals = 0, 0

    symbol_transactions = total_avg_amount_by_date_and_type[
        (total_avg_amount_by_date_and_type['symbol'] == symbol) &
        (total_avg_amount_by_date_and_type['numeric_amount'] > transaction_amount_threshold)]

    for _, row in symbol_transactions.iterrows():
        transaction_date = row['transactionDate']
        if transaction_date in stock_data.index:
            color = 'green' if row['transactionType'] == 'Buy' else 'red'
            price_on_transaction = stock_data.at[transaction_date, 'Close']

            # Scaling marker size based on transaction amount
            # ax.scatter(transaction_date, price_on_transaction, s=np.log(row['numeric_amount'] + 1) * 10, color=color, alpha=0.5) # log scaling
            # ax.scatter(transaction_date, price_on_transaction, s=row['numeric_amount'] / 1000 * 10, color=color, alpha=0.5) # linear scaling
            ax.scatter(transaction_date, price_on_transaction, s=np.sqrt(row['numeric_amount']) * 5, color=color, alpha=0.5) # square root scaling

            ax.axvline(x=transaction_date, color=color, linestyle='--', alpha=0.5)

            try:
                price_after_t_days = stock_data.loc[transaction_date + pd.Timedelta(days=t_days), 'Close']
                signal_correct = (row['transactionType'] == 'Buy' and price_after_t_days > price_on_transaction) or \
                                 (row['transactionType'] == 'Sell' and price_after_t_days < price_on_transaction)

                if row['transactionType'] == 'Buy':
                    total_buy_signals += 1
                    if signal_correct:
                        correct_buy_signals += 1
                elif row['transactionType'] == 'Sell':
                    total_sell_signals += 1
                    if signal_correct:
                        correct_sell_signals += 1
            except KeyError:
                # Skip if no price data available for the date after t_days
                continue

    buy_accuracy = (correct_buy_signals / total_buy_signals) * 100 if total_buy_signals > 0 else 0
    sell_accuracy = (correct_sell_signals / total_sell_signals) * 100 if total_sell_signals > 0 else 0

    # Collect accuracies for each symbol for further analysis or display
    #accuracies.append({'symbol': symbol, 'buy_accuracy': buy_accuracy, 'sell_accuracy': sell_accuracy})

    ax.set_title(f'{symbol} - Senate Trades - Buy Accuracy: {buy_accuracy:.2f}%, Sell Accuracy: {sell_accuracy:.2f}% - Transactions over {transaction_amount_threshold}$')
    ax.set_xlabel('Date')
    ax.set_ylabel('Price')

    ax.legend(handles=[Line2D([0], [0], color='blue', lw=2, label=f'{symbol} Close Price'), 
                       Line2D([0], [0], marker='o', color='w', markerfacecolor='green', markersize=10, label='Buy Signal (Marker Size Proportional to Amount)'), 
                       Line2D([0], [0], marker='o', color='w', markerfacecolor='red', markersize=10, label='Sell Signal (Marker Size Proportional to Amount)')],
              loc='upper left')

    ax.xaxis.set_major_locator(mdates.MonthLocator())
    ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m'))
    plt.setp(ax.xaxis.get_majorticklabels(), rotation=45)

plt.tight_layout()
plt.show()

# Optional: Print or analyze collected accuracies
# print(accuracies)