Advanced Slope Analysis: Risk Management and Signal Interpretation

               
               
class MultiTimeframeSlopeIndicator:
    def __init__(self, timeframes={'short': '1h', 'medium': '4h', 'long': '1d'},
                 windows={'short': 10, 'medium': 20, 'long': 30}):
        self.timeframes = timeframes
        self.windows = windows
        
    def _calculate_adaptive_slope(self, data, window):
        """
        Calculate the adaptive slope

        parameters:
        data: pd.Series, Price data
        window: int, Calculate window size
        """
        if len(data) < window:
            print(f"Warning: data length {len(data)} less than window size {window}")
            return pd.Series(np.nan, index=data.index)

        # Ensure that the data is continuous and there are no missing values
        data = data.ffill().bfill()

        # Calculate volatility using simple standard deviation
        volatility = data.rolling(window=window, min_periods=1).std()
        slopes = pd.Series(np.nan, index=data.index)

        # Calculate the slope using the vectorisation operation
        for i in range(window, len(data) + 1):
            y = data.iloc[i-window:i].values
            x = np.arange(window)
            if len(y) == window:
                slope, _ = np.polyfit(x, y, 1)
                vol = volatility.iloc[i-1]
                # Standardised slope
                slopes.iloc[i-1] = slope / vol if vol != 0 else slope

        return slopes

    def calculate_composite_slope(self, price_data):
        """
        Calculate the compound slope indicator
        """
        # Initialise the resulting DataFrame
        composite_slopes = pd.DataFrame(index=price_data.index)
        price_data = price_data.ffill().bfill()  # Ensuring continuity of price data

        # Calculate slopes for each time frame
        for tf_name, tf in self.timeframes.items():
            # Resampling data
            resampled = price_data.resample(tf).last()
            resampled = resampled.ffill().bfill()  # Ensure continuous resampling data

            window = self.windows[tf_name]
            if len(resampled) > window:
                # Calculate the slope
                slopes = self._calculate_adaptive_slope(resampled, window)

                # Alignment to original time frame
                aligned_slopes = slopes.reindex(price_data.index).ffill(limit=int(pd.Timedelta(tf) / pd.Timedelta('1H')))
                composite_slopes[tf_name] = aligned_slopes

        # Delete all NaN rows
        composite_slopes = composite_slopes.dropna(how='all')

        # If there is no valid data, return the NaN sequence
        if composite_slopes.empty:
            return pd.Series(np.nan, index=price_data.index)

        # Calculating dynamic weights
        weights = self._calculate_dynamic_weights(composite_slopes)
        composite = self._weighted_composite(composite_slopes, weights)

        return composite.reindex(price_data.index)


    def _calculate_dynamic_weights(self, slopes_data):
        """
        Dynamic adjustment of weights based on trend consistency

        parameters:
        slopes_data: DataFrame, Contains slope data for different time frames
        """
        try:
            # Using a new method for handling NaN values
            slopes_clean = slopes_data.ffill().bfill()

            # Calculate the correlation matrix
            correlations = slopes_clean.corr()

            # Calculate the average correlation for each time frame
            mean_corr = correlations.mean()

            # Ensure that the weights are positive and sum to 1
            weights = np.abs(mean_corr)
            weights_sum = weights.sum()

            if weights_sum > 0:
                weights = weights / weights_sum
            else:
                # If all weights are 0, use equal weights
                weights = pd.Series(1.0/len(slopes_data.columns), index=slopes_data.columns)

            print("\nCalculated weights:")
            for tf, weight in weights.items():
                print(f"{tf}: {weight:.3f}")

            return weights

        except Exception as e:
            print(f"Error calculating dynamic weights: {e}")
            # Return to equal weights
            return pd.Series(1.0/len(slopes_data.columns), index=slopes_data.columns)

    def _weighted_composite(self, slopes_data, weights):
        """
        Calculation of weighted composite indicators

        parameters:
        slopes_data: DataFrame, Contains slope data for different time frames
        weights: Series, Weighting of time frames
        """
        try:
            # Using a new method for handling NaN values
            slopes_clean = slopes_data.ffill().bfill()

            # Calculation of weighted sums
            weighted_sum = pd.Series(0, index=slopes_clean.index)
            for column in slopes_clean.columns:
                weighted_sum += slopes_clean[column] * weights[column]

            return weighted_sum

        except Exception as e:
            print(f"Error in calculating weighted composite indicator: {e}")
            return pd.Series(np.nan, index=slopes_data.index)


def visualize_results(price_data, composite_slopes, indicator, year=2024, month=9):
    """
    Visualisation of the results of the analysis, first calculating all the data and then displaying only the specified months
    """
    # First calculate the slope for all times
    slopes_data = pd.DataFrame(index=price_data.index)
    
    # Calculate the slope of each time frame
    for tf_name, tf in indicator.timeframes.items():
        resampled = price_data.resample(tf).last()
        resampled = resampled.ffill().bfill()
        
        window = indicator.windows[tf_name]
        if len(resampled) > window:
            slopes = indicator._calculate_adaptive_slope(resampled, window)
            aligned_slopes = slopes.reindex(price_data.index).ffill()
            slopes_data[tf_name] = aligned_slopes
    
    # After calculating all the data, select the data of the specified month for plotting.
    mask = (price_data.index.year == year) & (price_data.index.month == month)
    selected_price = price_data[mask]
    selected_slopes = slopes_data[mask]
    selected_composite = composite_slopes[mask] if isinstance(composite_slopes, pd.Series) else None
    
    # Creating Charts
    fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(15, 12), sharex=True)
    
    # Creating a Numerical Index
    data_points = list(range(len(selected_price)))
    
    # Plotting price data
    ax1.plot(data_points, selected_price.values, label='Price', color='pink')
    ax1.set_title(f'Price Data ({year}-{month:02d})')
    ax1.grid(True)
    ax1.legend()
    
    # Plotting the slope of each time frame
    colors = {'short': 'red', 'medium': 'blue', 'long': 'green'}
    for tf_name in slopes_data.columns:
        ax2.plot(data_points, selected_slopes[tf_name].values,
                label=f'{tf_name} Slope',
                color=colors[tf_name],
                linewidth=1)
    
    ax2.set_title(f'Slopes by Timeframe ({year}-{month:02d})')
    ax2.grid(True)
    ax2.legend()
    
    # Plotting compound slopes
    if selected_composite is not None:
        ax3.plot(data_points, selected_composite.values,
                label='Composite Slope', color='red', linewidth=1)
    
    ax3.set_title(f'Composite Slope ({year}-{month:02d})')
    ax3.grid(True)
    ax3.legend()
    
    # Set x-axis labels to date
    num_ticks = min(20, len(data_points))  # The number of scales displayed can be adjusted
    tick_indices = np.linspace(0, len(data_points)-1, num_ticks, dtype=int)
    tick_dates = selected_price.index[tick_indices].strftime('%Y-%m-%d')
    
    ax3.set_xticks(tick_indices)
    ax3.set_xticklabels(tick_dates, rotation=45)
    
    # Restructuring of the layout
    plt.tight_layout()
    plt.show()
    
    # Printing Statistics
    print(f"\n{year}年{month}Statistical information on monthly slopes:")
    print(selected_slopes.describe())
    print("\nNumber of NaNs for each time frame:")
    print(selected_slopes.isna().sum())
    
    
# operational test
if __name__ == "__main__":
	visualize_results(price_data, composite_slopes, indicator, year=2024, month=9)

       

               
def volume_weighted_slope(price_data, volume_data, window=30):
    """
    Calculate the volume-weighted slope
    
    parameters:
    price_data: pd.Series, Price data
    volume_data: pd.Series, Volume data
    window: int, Calculate window size
    """
    try:
        # Ensure data is aligned and there are no missing values
        price_data = price_data.ffill().bfill()
        volume_data = volume_data.ffill().bfill()
        
        # Standardised Volume
        normalized_volume = (volume_data - volume_data.rolling(window).mean()) / \
                           volume_data.rolling(window).std()
        normalized_volume = normalized_volume.fillna(0)  # NaN value at start of treatment
        
        # Initialising the result sequence
        slopes = pd.Series(index=price_data.index)
        slopes[:] = np.nan
        
        # Cycle through the slopes
        for i in range(window, len(price_data)):
            try:
                y = price_data.iloc[i-window:i].values
                x = np.arange(window)
                w = normalized_volume.iloc[i-window:i].values
                
                # Ensuring data validity
                if len(y) == window and len(w) == window and not np.any(np.isnan(y)) and not np.any(np.isnan(w)):
                    # Limit weights to a reasonable range
                    w = np.clip(w, -2, 2)
                    # Add small positive numbers to avoid zero weighting
                    w = np.abs(w) + 1e-8
                    
                    try:
                        # Weighted least squares with numpy
                        slope, _ = np.polyfit(x, y, 1, w=w)
                        slopes.iloc[i] = slope
                    except np.linalg.LinAlgError:
                        # If weighted regression fails, try unweighted regression
                        try:
                            slope, _ = np.polyfit(x, y, 1)
                            slopes.iloc[i] = slope
                        except:
                            continue
            except Exception as e:
                print(f"Error calculating the slope of the {i}th window: {str(e)}")
                continue
        
        return slopes
    
    except Exception as e:
        print(f"Error when calculating volume weighted slope: {str(e)}")
        return pd.Series(np.nan, index=price_data.index)

# usage example
def test_volume_weighted_slope():
    """
    Test Volume Weighted Slope Calculation
    """

    # Calculate the volume-weighted slope
    slopes = volume_weighted_slope(prices, volumes, window=30)
    
    # Merge data and delete invalid data
    valid_data = pd.concat([prices, volumes, slopes], axis=1)
    valid_data.columns = ['Price', 'Volume', 'Slope']
    valid_data = valid_data.dropna()
    
    # Creating a Numerical Index
    data_points = list(range(len(valid_data)))
    
    fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(15, 10), sharex=True)
    
    # Drawing prices
    ax1.plot(data_points, valid_data['Price'], 'r-', label='Price')
    ax1.set_title('Price Data')
    ax1.grid(True, linestyle='--', alpha=0.7)
    ax1.legend()
    
    # Plotting Volume
    ax2.plot(data_points, valid_data['Volume'], 'g-', label='Volume')
    ax2.set_title('Volume Data')
    ax2.grid(True, linestyle='--', alpha=0.7)
    ax2.legend()
    
    # Plotting the slope
    ax3.plot(data_points, valid_data['Slope'], 'r-', label='Volume-Weighted Slope')
    ax3.set_title('Volume-Weighted Slope')
    ax3.grid(True, linestyle='--', alpha=0.7)
    ax3.legend()
    
    # Set x-axis labels to date
    num_ticks = 10  # This number can be adjusted to control the number of scales displayed
    tick_indices = np.linspace(0, len(data_points)-1, num_ticks, dtype=int)
    tick_dates = valid_data.index[tick_indices].strftime('%Y-%m-%d')
    
    ax3.set_xticks(tick_indices)
    ax3.set_xticklabels(tick_dates, rotation=45)
    
    plt.tight_layout()
    plt.show()
    
    return valid_data['Slope']
    
    
# operational test
if __name__ == "__main__":
    test_volume_weighted_slope()
               
       

               
class ComprehensiveSlopeAnalyzer:
    def __init__(self):
        self.mtf_indicator = MultiTimeframeSlopeIndicator()
        self.markets = {}
        self.correlations = {}

    def add_market_data(self, market_name, price_data, volume_data=None):
        """ 
        Add market data 
        """
        self.markets[market_name] = {
            'price': price_data,
            'volume': volume_data,
            'slopes': {}
        }

    def analyze_market(self, market_name):
        """ 
        Analysing multi-dimensional slopes for individual markets 
        """
        market_data = self.markets[market_name]

        # Calculating Composite Slopes for Multiple Time Frames
        market_data['slopes']['composite'] = self.mtf_indicator.calculate_composite_slope(
            market_data['price']
        )

        # Calculate volume-weighted slope if volume data is available
        if market_data['volume'] is not None:
            market_data['slopes']['volume_weighted'] = volume_weighted_slope(
                market_data['price'],
                market_data['volume']
            )

    def _calculate_trend_strength(self, composite_slope):
        """ 
        Calculation of trend intensity 
        """
        # Assessing trend strength using absolute value and persistence of slope
        strength = pd.Series(index=composite_slope.index)
        window = 20

        for i in range(window, len(composite_slope)):
            current_slopes = composite_slope.iloc[i - window:i]

            # Calculate the consistency of the slope
            direction_consistency = np.sign(current_slopes).value_counts().max() / window
            # Calculate the average absolute value of the slope
            magnitude = np.abs(current_slopes).mean()

            strength.iloc[i] = direction_consistency * magnitude

        return strength

    def _check_volume_confirmation(self, market_name):
        """ 
        Check if volume confirms the trend 
        """
        market_data = self.markets[market_name]
        if 'volume_weighted' not in market_data['slopes']:
            return None

        composite = market_data['slopes']['composite']
        volume_weighted = market_data['slopes']['volume_weighted']

        # Calculate the consistency of the two slopes
        confirmation = np.sign(composite) == np.sign(volume_weighted)

        return confirmation

    def _calculate_trend_consistency(self, slopes):
        """ 
        Calculation of trend consistency indicators 
 
        parameters: 
        slopes: dict, Dictionary with different types of slopes 
 
        return: 
        float: Trend consistency score (0-1) 
        """
        try:
            # Combine all slope data into one DataFrame
            slope_data = pd.DataFrame(slopes)

            # Calculate whether all slopes have the same sign
            signs = np.sign(slope_data)

            # Calculate the consistency of the direction of the slope at each time point
            agreement = signs.apply(lambda x: abs(x.mean()), axis=1)

            # Calculating the overall consistency score
            consistency_score = agreement.mean()

            # Add some details
            details = {
                'mean_consistency': consistency_score,
                'max_consistency': agreement.max(),
                'min_consistency': agreement.min(),
                'periods_fully_aligned': (agreement == 1.0).sum()
            }

            return details

        except Exception as e:
            print(f"Error when calculating trend consistency: {str(e)}")
            return {
                'mean_consistency': 0,
                'max_consistency': 0,
                'min_consistency': 0,
                'periods_fully_aligned': 0
            }

    def generate_market_insights(self, market_name):
        """ 
        Generate Market Insight Reports 
 
        parameters: 
        market_name: str, Market Name 
 
        return: 
        dict: Dictionary with market insights 
        """
        market_data = self.markets[market_name]
        slopes = market_data['slopes']

        insights = {
            'trend_strength': self._calculate_trend_strength(slopes['composite']),
            'trend_consistency': self._calculate_trend_consistency(slopes),
            'volume_confirmation': self._check_volume_confirmation(market_name),
            'related_markets': self._find_related_markets(market_name)
        }

        # Add some explanatory text
        insights['summary'] = self._generate_insights_summary(insights)

        return insights

    def _generate_insights_summary(self, insights):
        """ 
        Generate summary text based on insights 
        """
        summary = []

        # Trend intensity analysis
        strength = insights['trend_strength']
        # If strength is Series，Take the average or latest value
        if isinstance(strength, pd.Series):
            strength = strength.iloc[-1]  # Take the latest value
            # or strength = strength.mean()  # average

        if strength > 0.7:
            summary.append("The current trend is very strong")
        elif strength > 0.3:
            summary.append("Current trend medium intensity")
        else:
            summary.append("Current trend is weak")

        # Trend consistency analysis
        consistency = insights['trend_consistency']['mean_consistency']
        if isinstance(consistency, pd.Series):
            consistency = consistency.iloc[-1]  # Take the latest value

        if consistency > 0.8:
            summary.append("High consistency of trends across time frames")
        elif consistency > 0.5:
            summary.append("Trends are partially consistent across time frames")
        else:
            summary.append("Trends diverge across time frames")

        # Volume Confirmation
        volume_conf = insights['volume_confirmation']
        if isinstance(volume_conf, pd.Series):
            volume_conf = volume_conf.iloc[-1]  # Take the latest value

        if volume_conf:
            summary.append("Volume supports the current trend")
        else:
            summary.append("Volume fails to confirm trend")

        return " | ".join(summary)

    def _find_related_markets(self, market_name):
        """ 
        Finding other markets related to the given market 
 
        parameters: 
        market_name: str, Current market name 
 
        return: 
        dict: Dictionary containing related markets and their correlations 
        """
        try:
            current_market = self.markets[market_name]
            related_markets = {}

            # Calculating correlations with other markets
            for other_name, other_market in self.markets.items():
                if other_name != market_name:
                    # Checking for the existence of data
                    if not isinstance(current_market.get('slopes', {}).get('composite'), (pd.Series, pd.DataFrame)):
                        continue
                    if not isinstance(other_market.get('slopes', {}).get('composite'), (pd.Series, pd.DataFrame)):
                        continue

                    current_slope = current_market['slopes']['composite']
                    other_slope = other_market['slopes']['composite']

                    # Ensure time index alignment
                    aligned_data = pd.DataFrame({
                        'current': current_slope,
                        'other': other_slope
                    }).dropna()

                    if len(aligned_data) > 0:  # Use len() instead of judging the DataFrame directly.
                        # Calculation of correlation coefficients
                        correlation = aligned_data['current'].corr(aligned_data['other'])

                        # Calculate lead/lag relationship
                        max_lag = 5  # Maximum inspection lag
                        lag_correlations = []
                        for lag in range(-max_lag, max_lag + 1):
                            if lag == 0:
                                lag_correlations.append(correlation)
                            else:
                                lag_corr = aligned_data['current'].corr(aligned_data['other'].shift(lag))
                                lag_correlations.append(lag_corr)

                        # Find the strongest correlations and their corresponding lags
                        max_corr_idx = np.argmax(np.abs(lag_correlations))
                        max_corr = lag_correlations[max_corr_idx]
                        lead_lag = max_corr_idx - max_lag

                        # If the correlation coefficient is a valid value, it is added to the result
                        if not np.isnan(correlation):
                            related_markets[other_name] = {
                                'correlation': correlation,
                                'max_correlation': max_corr,
                                'lead_lag': lead_lag,  # Positive values indicate a lead, negative values a lag
                                'significance': self._calculate_correlation_significance(correlation, len(aligned_data))
                            }

            # Sort by strength of relevance
            sorted_markets = dict(sorted(
                related_markets.items(),
                key=lambda x: abs(x[1]['correlation']),
                reverse=True
            ))

            return sorted_markets

        except Exception as e:
            print(f"Error in calculating the relevant market: {str(e)}")
            return {}

    def _calculate_correlation_significance(self, correlation, n_samples):
        """ 
        Calculate the statistical significance of the correlation coefficients 
 
        parameters: 
        correlation: float, correlation coefficient 
        n_samples: int, sample size 
 
        return: 
        float: significance level 
        """
        try:
            # Calculating t-statistics
            t = correlation * np.sqrt((n_samples - 2) / (1 - correlation ** 2))
            # Calculate p-value (two-tailed test)
            from scipy import stats
            p_value = 2 * (1 - stats.t.cdf(abs(t), n_samples - 2))

            return p_value
        except:
            return 1.0  # If the calculation fails, return 1 for not significant

    def analyze_cross_market_relationships(self):
        """ 
        Analysing cross-market relationships 
        """
        market_names = list(self.markets.keys())
        self.market_relationships = {}

        for i in range(len(market_names)):
            for j in range(i + 1, len(market_names)):
                market1 = market_names[i]
                market2 = market_names[j]

                # Access to price data
                market1_data = self.markets[market1]['price']
                market2_data = self.markets[market2]['price']

                # Calculating correlations and lead-lag relationships
                correlation, lead_lag = self._calculate_market_correlation(
                    market1_data, market2_data
                )

                # Storing analysis results
                relationship_key = f"{market1}_{market2}"
                if not correlation.empty and not lead_lag.empty:
                    self.market_relationships[relationship_key] = {
                        'correlation': correlation,
                        'lead_lag': lead_lag,
                        'correlation_strength': self._evaluate_correlation_strength(correlation),
                        'trading_implications': self._generate_trading_implications(correlation, lead_lag)
                    }

        return self.market_relationships

    def _evaluate_correlation_strength(self, correlation):
        """ 
        Assessing the strength of relevance 
 
        parameters: 
        correlation: pd.Series, Correlation coefficient series 
 
        return: 
        str: Description of correlation strength 
        """
        try:
            # Use the latest correlation coefficient value or average
            if isinstance(correlation, pd.Series):
                # Use the latest non-NaN values
                corr_value = correlation.iloc[-1]
                # Or use the average
                # corr_value = correlation.mean()
            else:
                corr_value = correlation

            # Assessed in absolute terms
            corr_value = abs(corr_value)

            if corr_value > 0.8:
                return "Very Strong"
            elif corr_value > 0.6:
                return "Strong"
            elif corr_value > 0.4:
                return "Moderate"
            elif corr_value > 0.2:
                return "Weak"
            else:
                return "Very Weak"

        except Exception as e:
            print(f"Error when evaluating correlation strength: {str(e)}")
            return "Unknown"

    def _calculate_market_correlation(self, market1_data, market2_data):
        """ 
        Calculation of correlation and lead-lag relationship between two markets 
        """
        try:
            # Ensure data alignment
            df = pd.DataFrame({
                'market1': market1_data,
                'market2': market2_data
            }).dropna()

            if len(df) < 2:
                print("Insufficient data points")
                return pd.Series([0]), pd.Series([0])

            # Printing debugging information
            print(f"\ndata statistics:")
            print(f"Number of data points: {len(df)}")
            print(f"Market 1 Scope: {df['market1'].min():.4f} to {df['market1'].max():.4f}")
            print(f"Market 2 Scope: {df['market2'].min():.4f} to {df['market2'].max():.4f}")

            # Calculation of the base correlation coefficient
            correlation = df['market1'].rolling(window=20).corr(df['market2'])
            print(f"\nCorrelation coefficient statistics:")
            print(f"Average correlation coefficient: {correlation.mean():.4f}")
            print(f"Range of correlation coefficients: {correlation.min():.4f} to {correlation.max():.4f}")

            # Calculate the lead-lag relationship
            max_lag = 5
            lag_correlations = pd.Series(index=range(-max_lag, max_lag + 1))

            for lag in range(-max_lag, max_lag + 1):
                if lag == 0:
                    lag_correlations[lag] = correlation.iloc[-1]
                else:
                    lagged_correlation = df['market1'].corr(df['market2'].shift(lag))
                    lag_correlations[lag] = lagged_correlation

            print("\nLead-lag correlation:")
            for lag, corr in lag_correlations.items():
                print(f"Lag {lag}: {corr:.4f}")

            return correlation, lag_correlations

        except Exception as e:
            print(f"Error in calculating market correlation: {str(e)}")
            return pd.Series([0]), pd.Series([0])

    def _generate_trading_implications(self, correlation, lead_lag):
        """ 
        Generate trading strategy recommendations and lower thresholds to capture more trading opportunities 
        """
        implications = []

        try:
            # Get the value of the correlation coefficient
            if isinstance(correlation, pd.Series):
                corr_value = correlation.iloc[-1]
            else:
                corr_value = correlation

            # Lowering the correlation threshold
            if abs(corr_value) > 0.5:  # Reduction from 0.7 to 0.5
                implications.append(f"Correlation strength: {corr_value:.4f}")
                if corr_value > 0:
                    implications.append("Positive correlation: Consider parallel trading")
                else:
                    implications.append("Negative correlation: Consider hedge opportunities")

            # Analysing the lead-lag relationship
            if isinstance(lead_lag, pd.Series):
                max_lag_idx = lead_lag.abs().idxmax()
                max_lag_value = lead_lag[max_lag_idx]

                if abs(max_lag_value) > 0.4:  # Reduction from 0.6 to 0.4
                    if max_lag_idx > 0:
                        implications.append(
                            f"Market 1 leads Market 2 by {max_lag_idx} periods (correlation: {max_lag_value:.4f})")
                    elif max_lag_idx < 0:
                        implications.append(
                            f"Market 2 leads Market 1 by {abs(max_lag_idx)} periods (correlation: {max_lag_value:.4f})")

            return implications

        except Exception as e:
            print(f"Error generating transaction meaning: {str(e)}")
            return ["Unable to generate implications"]

    def get_market_insights(self, market_name):
        """ 
        Access to comprehensive market-specific analyses 
        """
        insights = self.generate_market_insights(market_name)

        # Add analysis of cross-market relationships
        cross_market_insights = {}
        for rel_key, rel_data in self.market_relationships.items():
            if market_name in rel_key:
                other_market = rel_key.replace(market_name + '_', '').replace('_' + market_name, '')
                cross_market_insights[other_market] = {
                    'correlation_strength': rel_data['correlation_strength'],
                    'trading_implications': rel_data['trading_implications']
                }

        insights['cross_market_analysis'] = cross_market_insights
        return insights

    def generate_trading_signals(self, market_name):
        """ 
        Generate trading signals based on comprehensive analysis 
        """
        insights = self.get_market_insights(market_name)
        signals = []

        # Generate trading signals using cross-market relationships
        for other_market, analysis in insights['cross_market_analysis'].items():
            if analysis['correlation_strength'] in ['Very Strong', 'Strong']:
                # Examining the lead-lag relationship
                rel_key = f"{market_name}_{other_market}"
                if rel_key not in self.market_relationships:
                    rel_key = f"{other_market}_{market_name}"

                if rel_key in self.market_relationships:
                    lead_lag = self.market_relationships[rel_key]['lead_lag']
                    if abs(lead_lag.max()) > 0.6:
                        signals.append({
                            'type': 'cross_market',
                            'reference_market': other_market,
                            'strength': analysis['correlation_strength'],
                            'implication': analysis['trading_implications']
                        })

        return signals


# usage example
analyzer = ComprehensiveSlopeAnalyzer()

# Add market data
analyzer.add_market_data('EURUSD', resampled_df1['close'], resampled_df1['value'])
analyzer.add_market_data('GOLD', resampled_df2['close'], resampled_df2['value'])
analyzer.add_market_data('GBPUSD', resampled_df3['close'], resampled_df3['value'])

# analyse
analyzer.analyze_market('EURUSD')
analyzer.analyze_market('GOLD')
analyzer.analyze_market('GBPUSD')

# Analysing cross-market relationships
relationships = analyzer.analyze_cross_market_relationships()

# Access to market-specific analyses
eurusd_insights = analyzer.get_market_insights('EURUSD')

# Generate trading signals
signals = analyzer.generate_trading_signals('EURUSD')

               
       

               
               
from matplotlib.gridspec import GridSpec

class EnhancedSlopeSignalInterpreter:
    def __init__(self):
        self.correlation_thresholds = {
            'strong': 0.7,
            'medium': 0.4,
            'weak': 0.2
        }
        self.signal_thresholds = {
            'strong_trend': 0.8,
            'moderate_trend': 0.5,
            'weak_trend': 0.3,
            'trend_reversal': -0.2
        }

    def _analyze_weights(self, slopes_data):
        """ 
        Analysing the distribution of weights for different time frames 
        """
        return {
            'short_term': self._calculate_weight_significance(slopes_data['short']),
            'medium_term': self._calculate_weight_significance(slopes_data['medium']),
            'long_term': self._calculate_weight_significance(slopes_data['long'])
        }

    def _analyze_slopes(self, slopes_data):
        """ 
        Analysing slope data 
 
        parameters: 
        slopes_data: dict, Contains slope data for different time frames 
 
        return: 
        dict: Slope analysis results 
        """
        try:
            analysis = {
                'trend_direction': {},
                'trend_strength': {},
                'trend_consistency': {}
            }

            # Analyse the direction and strength of trends for each time frame
            for timeframe, slope in slopes_data.items():
                # Get the latest slope value
                current_slope = slope.iloc[-1] if isinstance(slope, pd.Series) else slope

                # Judging the direction of trends
                analysis['trend_direction'][timeframe] = (
                    'uptrend' if current_slope > 0
                    else 'downtrend' if current_slope < 0
                    else 'neutral'
                )

                # Calculation of trend intensity
                strength = abs(current_slope)
                analysis['trend_strength'][timeframe] = (
                    'strong' if strength > self.signal_thresholds['strong_trend']
                    else 'moderate' if strength > self.signal_thresholds['moderate_trend']
                    else 'weak'
                )

                # Calculate trend consistency
                if isinstance(slope, pd.Series):
                    recent_slopes = slope.tail(20)  # Using the last 20 data points
                    direction_changes = np.diff(np.signbit(recent_slopes)).sum()
                    consistency = 1 - (direction_changes / len(recent_slopes))
                    analysis['trend_consistency'][timeframe] = consistency

            # Calculating the overall trend score
            analysis['overall_trend_score'] = self._calculate_trend_score(slopes_data)

            return analysis

        except Exception as e:
            print(f"Error when analysing slope: {str(e)}")
            return {
                'trend_direction': {},
                'trend_strength': {},
                'trend_consistency': {},
                'overall_trend_score': 0
            }

    def _analyze_correlations(self, correlation_data):
        """ 
        Analysing correlation data 
 
        parameters: 
        correlation_data: dict, Inter-market correlation data 
 
        return: 
        dict: Correlation analysis results 
        """
        analysis = {}

        for market_pair, data in correlation_data.items():
            analysis[market_pair] = {
                'strength': self._classify_correlation(data['correlation']),
                'lead_lag': self._analyze_lead_lag(data['lag_correlations']),
                'stability': self._assess_correlation_stability(data['history'])
            }

        return analysis

    def _calculate_trend_score(self, slopes_data):
        """ 
        Calculating the overall trend score 
        """
        try:
            weights = {
                'short': 0.3,
                'medium': 0.4,
                'long': 0.3
            }

            score = 0
            for timeframe, slope in slopes_data.items():
                if timeframe in weights:
                    current_slope = slope.iloc[-1] if isinstance(slope, pd.Series) else slope
                    score += abs(current_slope) * weights[timeframe]

            return score

        except Exception as e:
            print(f"Error calculating trend score: {str(e)}")
            return 0

    def _classify_correlation(self, correlation):
        """ 
        Classification of correlation coefficients 
        """
        abs_corr = abs(correlation)
        if abs_corr > self.correlation_thresholds['strong']:
            return 'strong'
        elif abs_corr > self.correlation_thresholds['medium']:
            return 'medium'
        else:
            return 'weak'

    def _analyze_lead_lag(self, lag_correlations):
        """ 
        Analysing the lead-lag relationship 
        """
        try:
            # Find the strongest correlations and their corresponding lags
            max_abs_corr = max(lag_correlations.items(), key=lambda x: abs(x[1]))
            lead_lag = max_abs_corr[0]
            correlation = max_abs_corr[1]

            return {
                'lead_lag_periods': lead_lag,
                'correlation_at_lag': correlation,
                'significance': 'significant' if abs(correlation) > self.correlation_thresholds[
                    'medium'] else 'not significant'
            }

        except Exception as e:
            print(f"Error when analysing lead-lag relationship: {str(e)}")
            return {
                'lead_lag_periods': 0,
                'correlation_at_lag': 0,
                'significance': 'not significant'
            }

    def _assess_correlation_stability(self, history):
        """ 
        Assessing the stability of the correlation 
        """
        try:
            if isinstance(history, pd.Series):
                std_dev = history.std()
                stability = 1 - min(std_dev, 1)  # Converting standard deviation to stability score

                return {
                    'stability_score': stability,
                    'volatility': std_dev,
                    'is_stable': stability > 0.7
                }
            else:
                return {
                    'stability_score': 0,
                    'volatility': 1,
                    'is_stable': False
                }

        except Exception as e:
            print(f"Error when assessing correlation stability: {str(e)}")
            return {
                'stability_score': 0,
                'volatility': 1,
                'is_stable': False
            }

    def _assess_risks(self, slopes_data, correlation_data):
        """ 
        Assessing potential risks 
        """
        risks = {
            'correlation_breakdown_risk': False,
            'trend_consistency_risk': False,
            'market_regime_change_risk': False
        }

        # Assessing the risk of correlation breaks
        for market_pair, data in correlation_data.items():
            stability = self._assess_correlation_stability(data['history'])
            if not stability['is_stable']:
                risks['correlation_breakdown_risk'] = True

        # Assessing trend consistency risk
        slope_analysis = self._analyze_slopes(slopes_data)
        if min(slope_analysis['trend_consistency'].values()) < 0.6:
            risks['trend_consistency_risk'] = True

        # Market state change risk
        if slope_analysis['overall_trend_score'] < 0.3:
            risks['market_regime_change_risk'] = True

        return risks

    def _calculate_confidence(self, slopes_data, correlation_data):
        """ 
        Calculate the overall confidence score 
        """
        try:
            # Calculate the slope confidence level
            slope_analysis = self._analyze_slopes(slopes_data)
            slope_confidence = np.mean(list(slope_analysis['trend_consistency'].values()))

            # Calculate the correlation confidence level
            correlation_stabilities = []
            for data in correlation_data.values():
                stability = self._assess_correlation_stability(data['history'])
                correlation_stabilities.append(stability['stability_score'])
            correlation_confidence = np.mean(correlation_stabilities)

            # Composite Confidence Score
            overall_confidence = 0.6 * slope_confidence + 0.4 * correlation_confidence

            return {
                'overall_confidence': overall_confidence,
                'slope_confidence': slope_confidence,
                'correlation_confidence': correlation_confidence
            }

        except Exception as e:
            print(f"Error calculating confidence score: {str(e)}")
            return {
                'overall_confidence': 0,
                'slope_confidence': 0,
                'correlation_confidence': 0
            }

    def interpret_composite_signal(self, slopes_data, correlation_data, market_context=None):
        """ 
        Interpreting compound slope signals and correlation data 
        """
        return {
            'slope_analysis': self._analyze_slopes(slopes_data),
            'correlation_analysis': self._analyze_correlations(correlation_data),
            # 'weight_analysis': self._analyze_weights(slopes_data),
            'risk_assessment': self._assess_risks(slopes_data, correlation_data),
            'confidence_score': self._calculate_confidence(slopes_data, correlation_data)
        }

    def visualize_analysis(self, slopes_data, correlation_data):
        """ 
        Create enhanced visual analyses 
        """
        try:
            # Creating shapes and grids
            fig = plt.figure(figsize=(15, 12))
            gs = GridSpec(3, 2, figure=fig)

            # Slope Analysis Chart
            ax1 = fig.add_subplot(gs[0, :])
            self._plot_slopes_analysis(ax1, slopes_data)

            # correlation heat map
            ax2 = fig.add_subplot(gs[1, 0])
            self._plot_correlation_heatmap(ax2, correlation_data)

            # weighting chart
            ax3 = fig.add_subplot(gs[1, 1])
            self._plot_weight_distribution(ax3, slopes_data)

            # Risk indicator charts
            ax4 = fig.add_subplot(gs[2, :])
            self._plot_risk_indicators(ax4, slopes_data, correlation_data)

            plt.tight_layout()
            return fig

        except Exception as e:
            print(f"Error while creating visualisation analysis: {str(e)}")
            # Creating a Simple Error Tip Chart
            fig, ax = plt.subplots(1, 1, figsize=(8, 6))
            ax.text(0.5, 0.5, f'Visualising Generation Errors: {str(e)}',
                    ha='center', va='center')
            return fig

    def _plot_slopes_analysis(self, ax, slopes_data):
        """ 
        Plotting slope analysis 
        """
        try:
            # Make sure all data is of type Series
            for timeframe, slope in slopes_data.items():
                if isinstance(slope, pd.Series):
                    ax.plot(slope.index, slope, label=f'{timeframe} slope')

            ax.set_title('Multi-timeframe Slope Analysis')
            ax.set_xlabel('Time')
            ax.set_ylabel('Slope Value')
            ax.legend()
            ax.grid(True)

        except Exception as e:
            print(f"Error when plotting slope analysis: {str(e)}")
            ax.text(0.5, 0.5, 'Slope analysis plot error',
                    ha='center', va='center')

    def _plot_correlation_heatmap(self, ax, correlation_data):
        """ 
        Heat mapping of correlations 
        """
        try:
            # Creating a correlation matrix
            markets = set()
            for pair in correlation_data.keys():
                markets.update(pair.split('_'))
            markets = sorted(list(markets))

            corr_matrix = np.zeros((len(markets), len(markets)))
            for i, m1 in enumerate(markets):
                for j, m2 in enumerate(markets):
                    if i != j:
                        pair = f"{m1}_{m2}"
                        rev_pair = f"{m2}_{m1}"
                        if pair in correlation_data:
                            corr_matrix[i, j] = correlation_data[pair]['correlation']
                        elif rev_pair in correlation_data:
                            corr_matrix[i, j] = correlation_data[rev_pair]['correlation']

            # Drawing heat maps
            im = ax.imshow(corr_matrix, cmap='RdYlBu', aspect='auto')
            plt.colorbar(im, ax=ax)

            # Setting up labels
            ax.set_xticks(range(len(markets)))
            ax.set_yticks(range(len(markets)))
            ax.set_xticklabels(markets, rotation=45)
            ax.set_yticklabels(markets)

            ax.set_title('Cross-market Correlations')

            # Add text of correlation coefficients
            for i in range(len(markets)):
                for j in range(len(markets)):
                    if i != j:
                        text = ax.text(j, i, f'{corr_matrix[i, j]:.2f}',
                                       ha="center", va="center",
                                       color="black" if abs(corr_matrix[i, j]) < 0.5 else "white")

        except Exception as e:
            print(f"Error when plotting correlation heat map: {str(e)}")
            ax.text(0.5, 0.5, 'Correlation heatmap error',
                    ha='center', va='center')

    def _plot_weight_distribution(self, ax, slopes_data):
        """ 
        Mapping of weight distribution 
        """
        try:
            # Calculation of weights for each time frame
            weights = {}
            total_abs_slope = sum(abs(slope.iloc[-1]) for slope in slopes_data.values())

            if total_abs_slope > 0:
                for timeframe, slope in slopes_data.items():
                    weights[timeframe] = abs(slope.iloc[-1]) / total_abs_slope

            # Plotting pie charts
            wedges, texts, autotexts = ax.pie(weights.values(),
                                              labels=weights.keys(),
                                              autopct='%1.1f%%',
                                              colors=plt.cm.Set3(np.linspace(0, 1, len(weights))))

            ax.set_title('Timeframe Weight Distribution')

        except Exception as e:
            print(f"Error when plotting weight distribution: {str(e)}")
            ax.text(0.5, 0.5, 'Weight distribution plot error',
                    ha='center', va='center')

    def _plot_risk_indicators(self, ax, slopes_data, correlation_data):
        """ 
        Mapping of risk indicators 
        """
        try:
            # Calculation of risk indicators
            risks = self._assess_risks(slopes_data, correlation_data)
            confidence = self._calculate_confidence(slopes_data, correlation_data)

            # Creating risk indicator bar charts
            indicators = {
                'Correlation Breakdown Risk': float(risks['correlation_breakdown_risk']),
                'Trend Consistency Risk': float(risks['trend_consistency_risk']),
                'Market Regime Change Risk': float(risks['market_regime_change_risk']),
                'Overall Confidence': confidence['overall_confidence'],
                'Slope Confidence': confidence['slope_confidence'],
                'Correlation Confidence': confidence['correlation_confidence']
            }

            # plot
            bars = ax.bar(range(len(indicators)), indicators.values())

            # Setting up labels
            ax.set_xticks(range(len(indicators)))
            ax.set_xticklabels(indicators.keys(), rotation=45)

            # Adding value tags
            for bar in bars:
                height = bar.get_height()
                ax.text(bar.get_x() + bar.get_width() / 2., height,
                        f'{height:.2f}',
                        ha='center', va='bottom')

            ax.set_title('Risk and Confidence Indicators')
            ax.set_ylim(0, 1.2)
            ax.grid(True, axis='y')

        except Exception as e:
            print(f"Errors in charting risk indicators: {str(e)}")
            ax.text(0.5, 0.5, 'Risk indicators plot error',
                    ha='center', va='center')

    def generate_trading_recommendations(self, analysis_results):
        """ 
        Generate trade recommendations based on analysis results 
        """
        return {
            'primary_signals': self._extract_primary_signals(analysis_results),
            'confirmation_signals': self._identify_confirmations(analysis_results),
            'risk_warnings': self._compile_risk_warnings(analysis_results),
            'suggested_actions': self._suggest_trading_actions(analysis_results)
        }

    def _extract_primary_signals(self, analysis_results):
        """ 
        Extracting key trading signals 
        """
        try:
            signals = []

            # Extracting signals from slope analysis
            slope_analysis = analysis_results['slope_analysis']

            # Checking for consistency in trend direction
            trend_directions = slope_analysis['trend_direction']
            if len(set(trend_directions.values())) == 1:
                # All time frames trend in the same direction
                direction = next(iter(trend_directions.values()))
                strength = slope_analysis['overall_trend_score']

                if strength > self.signal_thresholds['strong_trend']:
                    signals.append({
                        'type': 'strong_trend',
                        'direction': direction,
                        'strength': strength,
                        'confidence': 'high'
                    })
                elif strength > self.signal_thresholds['moderate_trend']:
                    signals.append({
                        'type': 'moderate_trend',
                        'direction': direction,
                        'strength': strength,
                        'confidence': 'medium'
                    })

            # Extracting signals from correlation analysis
            corr_analysis = analysis_results['correlation_analysis']
            for market_pair, data in corr_analysis.items():
                if data['strength'] == 'strong':
                    signals.append({
                        'type': 'correlation_signal',
                        'market_pair': market_pair,
                        'strength': data['strength'],
                        'lead_lag': data['lead_lag']
                    })

            return signals

        except Exception as e:
            print(f"Error extracting primary signal: {str(e)}")
            return []

    def _identify_confirmations(self, analysis_results):
        """ 
        Recognition of confirmation signals 
        """
        try:
            confirmations = []

            # Checking trend consistency
            slope_analysis = analysis_results['slope_analysis']
            trend_consistency = slope_analysis.get('trend_consistency', {})

            if trend_consistency:
                avg_consistency = np.mean(list(trend_consistency.values()))
                if avg_consistency > 0.7:
                    confirmations.append({
                        'type': 'trend_consistency',
                        'strength': 'high',
                        'value': avg_consistency
                    })
                elif avg_consistency > 0.5:
                    confirmations.append({
                        'type': 'trend_consistency',
                        'strength': 'medium',
                        'value': avg_consistency
                    })

            # Check relevance confirmation
            confidence = analysis_results['confidence_score']
            if confidence['correlation_confidence'] > 0.7:
                confirmations.append({
                    'type': 'correlation_stability',
                    'strength': 'high',
                    'value': confidence['correlation_confidence']
                })

            return confirmations

        except Exception as e:
            print(f"Error in recognising confirmation signal: {str(e)}")
            return []

    def _compile_risk_warnings(self, analysis_results):
        """ 
        Aggregate Risk Warning 
        """
        try:
            warnings = []
            risks = analysis_results['risk_assessment']

            # Inspection of all types of risks
            if risks['correlation_breakdown_risk']:
                warnings.append({
                    'type': 'correlation_breakdown',
                    'severity': 'high',
                    'description': 'Significant risk of correlation breakdown detected'
                })

            if risks['trend_consistency_risk']:
                warnings.append({
                    'type': 'trend_consistency',
                    'severity': 'medium',
                    'description': 'Potential trend consistency issues detected'
                })

            if risks['market_regime_change_risk']:
                warnings.append({
                    'type': 'regime_change',
                    'severity': 'high',
                    'description': 'Market regime change risk detected'
                })

            # Checking the confidence level
            confidence = analysis_results['confidence_score']
            if confidence['overall_confidence'] < 0.5:
                warnings.append({
                    'type': 'low_confidence',
                    'severity': 'medium',
                    'description': 'Overall signal confidence is low'
                })

            return warnings

        except Exception as e:
            print(f"Error compiling risk warning: {str(e)}")
            return []

    def _suggest_trading_actions(self, analysis_results):
        """ 
        Recommendations for specific trading actions 
        """
        try:
            actions = []
            primary_signals = self._extract_primary_signals(analysis_results)
            confirmations = self._identify_confirmations(analysis_results)
            warnings = self._compile_risk_warnings(analysis_results)

            # Recommendations based on signal strength and confirmation
            for signal in primary_signals:
                if signal['type'] in ['strong_trend', 'moderate_trend']:
                    # Check that there is sufficient confirmation
                    has_confirmation = any(conf['strength'] == 'high' for conf in confirmations)
                    # Check for serious risk warnings
                    has_high_risk = any(warn['severity'] == 'high' for warn in warnings)

                    if has_confirmation and not has_high_risk:
                        actions.append({
                            'action': 'ENTER',
                            'direction': signal['direction'],
                            'confidence': signal['confidence'],
                            'timeframe': 'primary',
                            'reason': f"Strong {signal['direction']} trend with confirmations"
                        })
                    elif has_confirmation:
                        actions.append({
                            'action': 'MONITOR',
                            'direction': signal['direction'],
                            'confidence': 'medium',
                            'timeframe': 'primary',
                            'reason': "Wait for risk reduction"
                        })

                elif signal['type'] == 'correlation_signal':
                    actions.append({
                        'action': 'HEDGE',
                        'market_pair': signal['market_pair'],
                        'confidence': 'high' if signal['strength'] == 'strong' else 'medium',
                        'reason': f"Strong correlation in {signal['market_pair']}"
                    })

            # If there is no clear signal but there is a risk warning
            if not actions and warnings:
                actions.append({
                    'action': 'REDUCE_EXPOSURE',
                    'confidence': 'high',
                    'reason': "Multiple risk factors present"
                })

            return actions

        except Exception as e:
            print(f"Error when generating trade recommendations: {str(e)}")
            return []


def create_sample_data(analyzer):
    """ 
    Creating example data using ComprehensiveSlopeAnalyzer's analysis results 
 
    parameters: 
    analyzer: ComprehensiveSlopeAnalyzer Example, market analysis completed 
 
    return: 
    tuple: (slopes_data, correlation_data) 
    """
    # Get market data and analyses for EURUSD
    eurusd_market = analyzer.markets['EURUSD']

    # Creating Slope Data
    slopes_data = {
        'short': eurusd_market['slopes']['composite'].rolling(window=10).mean(),  # Short-term slope
        'medium': eurusd_market['slopes']['composite'].rolling(window=20).mean(),  # Medium-term slope
        'long': eurusd_market['slopes']['composite'].rolling(window=40).mean()  # Long-term slope
    }

    # Access to correlation data
    correlation_data = {}

    # EURUSD vs GBPUSD
    eurusd_gbpusd_key = next(key for key in analyzer.market_relationships.keys()
                             if 'EURUSD' in key and 'GBPUSD' in key)
    eurusd_gbpusd_rel = analyzer.market_relationships[eurusd_gbpusd_key]

    correlation_data['EURUSD_GBPUSD'] = {
        'correlation': eurusd_gbpusd_rel['correlation'].iloc[-1],
        'lag_correlations': dict(enumerate(
            eurusd_gbpusd_rel['lead_lag'].values,
            start=-len(eurusd_gbpusd_rel['lead_lag']) // 2
        )),
        'history': eurusd_gbpusd_rel['correlation']
    }

    # EURUSD vs GOLD
    eurusd_gold_key = next(key for key in analyzer.market_relationships.keys()
                           if 'EURUSD' in key and 'GOLD' in key)
    eurusd_gold_rel = analyzer.market_relationships[eurusd_gold_key]

    correlation_data['EURUSD_GOLD'] = {
        'correlation': eurusd_gold_rel['correlation'].iloc[-1],
        'lag_correlations': dict(enumerate(
            eurusd_gold_rel['lead_lag'].values,
            start=-len(eurusd_gold_rel['lead_lag']) // 2
        )),
        'history': eurusd_gold_rel['correlation']
    }

    # Add data for GOLD vs GBPUSD
    gold_gbpusd_key = next(key for key in analyzer.market_relationships.keys()
                           if 'GOLD' in key and 'GBPUSD' in key)
    gold_gbpusd_rel = analyzer.market_relationships[gold_gbpusd_key]

    correlation_data['GOLD_GBPUSD'] = {
        'correlation': gold_gbpusd_rel['correlation'].iloc[-1],
        'lag_correlations': dict(enumerate(
            gold_gbpusd_rel['lead_lag'].values,
            start=-len(gold_gbpusd_rel['lead_lag']) // 2
        )),
        'history': gold_gbpusd_rel['correlation']
    }

    return slopes_data, correlation_data


# Using an existing instance of ComprehensiveSlopeAnalyzer
def demonstrate_interpreter_usage(analyzer):
    """ 
    Demonstrate the use of the interpreter 
 
    parameters: 
    analyzer: ComprehensiveSlopeAnalyzer Example, market analysis completed 
    """
    # Creating an Interpreter Instance
    interpreter = EnhancedSlopeSignalInterpreter()

    # Getting example data with analyzer
    slopes_data, correlation_data = create_sample_data(analyzer)

    # Get the full analysis
    analysis_results = interpreter.interpret_composite_signal(
        slopes_data=slopes_data,
        correlation_data=correlation_data,
        market_context={'volatility': 'moderate', 'trading_session': 'london'}
    )

    # Generating Visualisations
    fig = interpreter.visualize_analysis(slopes_data, correlation_data)

    # Get Trading Advice
    recommendations = interpreter.generate_trading_recommendations(analysis_results)

    return analysis_results, fig, recommendations


# main function
def main():
    # Using an existing analyzer instance
    analyzer = ComprehensiveSlopeAnalyzer()

    # Add market data
    analyzer.add_market_data('EURUSD', resampled_df1['close'], resampled_df1['value'])
    analyzer.add_market_data('GOLD', resampled_df2['close'], resampled_df2['value'])
    analyzer.add_market_data('GBPUSD', resampled_df3['close'], resampled_df3['value'])

    # analyse
    analyzer.analyze_market('EURUSD')
    analyzer.analyze_market('GOLD')
    analyzer.analyze_market('GBPUSD')

    # Analysing cross-market relationships
    analyzer.analyze_cross_market_relationships()

    # Use of analyses
    analysis_results, fig, recommendations = demonstrate_interpreter_usage(analyzer)

    # Print analysis results
    print("\n=== analysis results ===")
    print("\n1. Slope analysis:")
    print(analysis_results['slope_analysis'])

    print("\n2. relevance analysis:")
    print(analysis_results['correlation_analysis'])

    # print("\n3. weighting analysis:")
    # print(analysis_results['weight_analysis'])

    print("\n4. risk assessment:")
    print(analysis_results['risk_assessment'])

    print("\n5. confidence score:")
    print(analysis_results['confidence_score'])

    # Print Trading Recommendations
    print("\n=== Trading Recommendations ===")
    print("\n1. Main signals:")
    print(recommendations['primary_signals'])

    print("\n2. acknowledgement:")
    print(recommendations['confirmation_signals'])

    print("\n3. risk warning:")
    print(recommendations['risk_warnings'])

    print("\n4. Recommended Operation:")
    print(recommendations['suggested_actions'])

    # plot
    plt.show()


if __name__ == "__main__":
    main()