I like how this works and is visualized but I want it to be more interactive so i can better inspect the values. Can you refactor it but maintain the orginal functionality?

"""
class SeasonalityRadar:
    def __init__(self, tickers, start_date='1990-01-01', end_date=None, triple_witching_weeks=None, odds_ratio=2, output_dir='seasonality_data'):
        self.tickers = tickers if isinstance(tickers, list) else [tickers]
        self.start_date = start_date
        self.end_date = end_date if end_date else datetime.now().strftime('%Y-%m-%d')
        self.triple_witching_weeks = triple_witching_weeks or []
        self.odds_ratio = odds_ratio
        self.output_dir = output_dir
        self.data = None

    def fetch_data(self):
        self.data = yf.download(self.tickers, start=self.start_date, end=self.end_date, group_by='ticker')

    def calculate_kelly_ratio(self, returns):
        """
        Calculate the Kelly ratio and fraction based on the returns.
        
        Parameters:
            returns (pd.Series): A series of returns.
        
        Returns:
            tuple: (kelly_ratio, kelly_fraction)
        """
        win_rate = (returns > 0).mean()
        loss_rate = (returns < 0).mean()
        avg_win = returns[returns > 0].mean()
        avg_loss = returns[returns < 0].mean()
        
        if avg_loss == 0:  # Avoid division by zero
            return (0, 0)
        
        kelly_ratio = win_rate - (loss_rate * (avg_win / -avg_loss))  # Fixed missing closing parenthesis
        kelly_fraction = kelly_ratio / (avg_win / -avg_loss) if avg_loss != 0 else 0
        
        return kelly_ratio, kelly_fraction

    def analyze_monthly_seasonality(self, ticker):
        df = self.data[ticker]['Adj Close']
        
        # Calculate monthly returns
        monthly_data = df.resample('M').ffill()
        monthly_returns = monthly_data.pct_change().dropna() * 100  # Convert to percentage
        
        # Organize returns into a pivot table
        monthly_returns = monthly_returns.to_frame(name='Adj Close')
        monthly_returns['Year'] = monthly_returns.index.year
        monthly_returns['Month'] = monthly_returns.index.month
        monthly_returns['Month'] = monthly_returns['Month'].apply(lambda x: pd.Timestamp(2023, x, 1).strftime('%b'))
        pivot_table = monthly_returns.pivot_table(index='Year', columns='Month', values='Adj Close', aggfunc='mean')
        pivot_table = pivot_table.fillna(0)

        # Ensure columns are in the correct order
        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
        pivot_table = pivot_table[months]

        # Calculate metrics
        avg_returns = pivot_table.mean()
        std_dev = pivot_table.std()
        pos_perc = (pivot_table > 0).mean() * 100
        skewness = pivot_table.apply(lambda x: skew(x.dropna()), axis=0)
        kurt = pivot_table.apply(lambda x: kurtosis(x.dropna()), axis=0)

        # Kelly ratio and fraction
        kelly_ratios = pivot_table.apply(lambda x: self.calculate_kelly_ratio(x.dropna()), axis=0)
        avg_kelly_ratio = kelly_ratios.apply(lambda x: x[0])
        avg_kelly_fraction = kelly_ratios.apply(lambda x: x[1])

        # Create summary table
        summary_table = pd.DataFrame({
            'Avg Returns (%)': avg_returns,
            'StDev (%)': std_dev,
            'Pos %': pos_perc,
            'Skewness': skewness,
            'Kurtosis': kurt,
            'Avg Kelly Ratio': avg_kelly_ratio,
            'Avg Kelly Fraction': avg_kelly_fraction
        })

        return summary_table

    def visualize_monthly_seasonality(self, ticker):
        summary_table = self.analyze_monthly_seasonality(ticker)

        # Radar chart
        categories = list(summary_table.index)
        N = len(categories)
        angles = [n / float(N) * 2 * pi for n in range(N)]
        angles += angles[:1]

        fig = plt.figure(figsize=(8, 8))
        ax = fig.add_subplot(111, polar=True)

        colors = plt.cm.jet(np.linspace(0, 1, 7))
        metrics = ['Avg Returns (%)', 'StDev (%)', 'Pos %', 'Skewness', 'Kurtosis', 'Avg Kelly Ratio', 'Avg Kelly Fraction']
        for i, column in enumerate(metrics):
            values = summary_table[column].values.flatten().tolist()
            values += values[:1]
            ax.plot(angles, values, linewidth=2, linestyle='solid', label=column, color=colors[i])
            ax.fill(angles, values, alpha=0.25, color=colors[i])

        ax.set_theta_offset(pi / 2)
        ax.set_theta_direction(-1)
        plt.xticks(angles[:-1], categories, fontsize=10)
        ax.set_rlabel_position(0)
        plt.yticks(fontsize=8)
        ax.set_title(f'Monthly Behavior of Quantitative Statistics for {ticker}', fontsize=16)
        ax.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1), fontsize=8)

        plt.tight_layout()
        plt.show()

    def run_analysis(self):
        self.fetch_data()
        for ticker in self.tickers:
            print(f"Analyzing {ticker}")
            self.visualize_monthly_seasonality(ticker)
        # self.export_weekly_seasonality_data()  # Commented out as per instruction

triple_witching_weeks = [11, 24, 37, 38, 50]
analyzer = SeasonalityRadar(tickers, start_date="2010-01-01", end_date="2024-01-01", triple_witching_weeks=triple_witching_weeks)
analyzer.run_analysis()

"""