Update app.py

app.py

@@ -1,523 +1,181 @@
-"""
-Professional Quantitative Finance Analysis Platform
-Hugging Face Gradio Application
-"""
-import gradio as gr
-import json
-import numpy as np
+import yfinance as yf
 import pandas as pd
-from datetime import datetime
-from typing import Dict, List
-import warnings
-warnings.filterwarnings('ignore')
-
-# Import custom modules
-from src.data_fetcher import DataFetcher
-from src.spectral_analyzer import SpectralAnalyzer
-from src.bayesian_engine import BayesianAnalyzer
-from src.monte_carlo import MonteCarloEngine
-from src.pattern_recognition import PatternRecognizer
-from src.ml_models import MLMomentumPredictor
-from src.visualization import Visualizer
-from src.pdf_report import PDFReportGenerator
-from src.config import config, TIMEFRAMES
-import plotly.graph_objects as go
-
-class QuantitativeAnalysisPlatform:
-    """Main analysis platform orchestrating all modules"""
+import numpy as np
+import mplfinance as mpf
+import talib # pip install ta-lib
+import gradio as gr
+from datetime import date
+
+# TALib formasyon fonksiyonlarını bir dictionary'de tutalım
+TALIB_PATTERNS = {
+    "CDLSHOOTINGSTAR": talib.CDLSHOOTINGSTAR,
+    "CDLHAMMER": talib.CDLHAMMER,
+    "CDLDOJI": talib.CDLDOJI,
+    "CDLINVERTEDHAMMER": talib.CDLINVERTEDHAMMER,
+    "CDLENGULFING": talib.CDLENGULFING,
+    "CDLHARAMI": talib.CDLHARAMI,
+    "CDLMORNINGSTAR": talib.CDLMORNINGSTAR,
+    "CDLEVENINGSTAR": talib.CDLEVENINGSTAR,
+    "CDL3WHITESOLDIERS": talib.CDL3WHITESOLDIERS,
+    "CDL3BLACKCROWS": talib.CDL3BLACKCROWS,
+    # İstediğiniz diğer formasyonları ekleyebilirsiniz
+}
+
+def find_candlestick_patterns(df, pattern_name):
+    """
+    Verilen DataFrame'de TALib kullanarak mum çubuğu formasyonlarını bulur ve
+    mplfinance için addplot listesi döndürür.
     
-    def __init__(self):
-        self.data_fetcher = DataFetcher()
-        self.spectral_analyzer = SpectralAnalyzer()
-        self.bayesian_analyzer = BayesianAnalyzer()
-        self.mc_engine = MonteCarloEngine()
-        self.pattern_recognizer = PatternRecognizer()
-        self.ml_predictor = MLMomentumPredictor(model_type='xgboost')
-        self.visualizer = Visualizer()
-        
-    def run_complete_analysis(
-        self,
-        symbol: str,
-        timeframe: str = '1d',
-        period: str = '2y'
-    ):
-        """
-        Execute comprehensive analysis pipeline
+    Args:
+        df (pd.DataFrame): Hisse senedi verisi (Open, High, Low, Close sütunları ile).
+        pattern_name (str): TALib'deki formasyon fonksiyonunun adı (örn. "CDLSHOOTINGSTAR").
         
-        Returns:
-            Tuple of (html_charts, status_message, results_markdown, pdf_path)
-        """
-        try:
-            status_log = []
-            
-            # 1. Fetch Data
-            status_log.append(f"📊 Fetching {symbol} data ({timeframe} interval)...")
-            success, msg = self.data_fetcher.fetch_data(symbol, timeframe, period)
-            if not success:
-                return None, f"❌ {msg}", "", None
-            status_log.append(f"✅ {msg}")
-            
-            # 2. Spectral Analysis (Multi-Frequency)
-            status_log.append("🔬 Performing multi-frequency spectral analysis...")
-            prices = self.data_fetcher.get_clean_prices()
-            spectral_results = self.spectral_analyzer.analyze(prices)
-            status_log.append(f"✅ Analyzed {len(spectral_results)} frequency bands")
-            
-            # 3. Pattern Recognition
-            status_log.append("🎯 Detecting technical patterns...")
-            ohlc = self.data_fetcher.get_ohlcv()
-            candlestick_patterns = self.pattern_recognizer.detect_candlestick_patterns(ohlc)
-            chart_patterns = self.pattern_recognizer.detect_chart_patterns(
-                prices, self.data_fetcher.data.index
-            )
-            status_log.append(f"✅ Found {len(candlestick_patterns)} candlestick patterns, "
-                            f"{len(chart_patterns)} chart patterns")
-            
-            # 4. ML-Based Prediction (Self-Supervised)
-            status_log.append("🤖 Training ML models with self-supervised learning...")
-            X, y = self.ml_predictor.prepare_features(self.data_fetcher.data)
-            ml_metrics = self.ml_predictor.self_supervised_training(X, y, optimize_params=True)
-            status_log.append(f"✅ ML Model R²: {ml_metrics['final_r2']:.3f}")
-            
-            # 5. Monte Carlo Simulations
-            status_log.append("🎲 Running Monte Carlo simulations (10,000+ paths)...")
-            returns = self.data_fetcher.get_returns()
-            current_price = prices[-1]
-            mc_results = self.mc_engine.simulate_all_models(
-                current_price, returns, T=30, n_sims=10000
-            )
-            status_log.append(f"✅ Completed {len(mc_results)} Monte Carlo models")
-            
-            # 6. Bayesian Analysis
-            status_log.append("📈 Performing Bayesian inference...")
-            volatility = self.data_fetcher.calculate_volatility().iloc[-1]
-            adx_value = 25.0  # Simplified - would calculate actual ADX
-            regime_probs = self.bayesian_analyzer.estimate_regime_probabilities(
-                volatility, adx_value, returns[-50:]
-            )
-            status_log.append(f"✅ Estimated market regime probabilities")
-            
-            # 7. Calculate Multi-Band Momentum
-            status_log.append("⚡ Calculating multi-frequency momentum signals...")
-            momentum_signals = self.spectral_analyzer.get_multi_band_momentum(window_size=30)
-            composite_momentum = self.spectral_analyzer.get_composite_momentum(window_size=30)
-            status_log.append("✅ Generated momentum signals for all frequency bands")
-            
-            # 8. Generate Visualizations
-            status_log.append("📊 Creating interactive visualizations...")
-            mc_stats = {}
-            for model_name in ['gbm', 'jump_diffusion', 'garch', 'heston']:
-                if model_name in mc_results:
-                    mc_stats[model_name] = self.mc_engine.calculate_statistics(model_name)
-            
-            # Detect buy signals from momentum
-            buy_signals = self._detect_buy_signals_from_momentum(
-                composite_momentum, prices, self.data_fetcher.data.index
-            )
-            
-            # Generate all charts
-            charts = self.visualizer.create_comprehensive_dashboard(
-                dates=self.data_fetcher.data.index,
-                original_prices=prices,
-                spectral_results=spectral_results,
-                momentum_signals=momentum_signals,
-                mc_results=mc_results,
-                buy_signals=buy_signals,
-                current_price=current_price
-            )
-            
-            # Save to HTML
-            html_path = f"analysis_{symbol}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html"
-            self.visualizer.export_to_html(charts, html_path)
-            status_log.append(f"✅ Generated {len(charts)} interactive charts: {html_path}")
-            
-            # 9. Generate PDF Report
-            status_log.append("📄 Generating comprehensive PDF report...")
-            pdf_gen = PDFReportGenerator()
-            
-            pdf_gen.add_title_page(symbol, datetime.now().strftime('%Y-%m-%d'))
-            
-            pdf_gen.add_executive_summary({
-                'current_price': current_price,
-                'market_regime': self.data_fetcher.detect_market_regime(),
-                'volatility': volatility,
-                'momentum_status': 'Positive' if composite_momentum[-1] > 0 else 'Negative',
-                'ml_r2': ml_metrics['final_r2']
-            })
-            
-            pdf_gen.add_frequency_analysis(spectral_results)
-            pdf_gen.add_monte_carlo_results(mc_stats)
-            pdf_gen.add_bayesian_analysis({'regime_probabilities': regime_probs})
-            pdf_gen.add_pattern_detection(candlestick_patterns + chart_patterns)
-            
-            pdf_path = pdf_gen.generate()
-            status_log.append(f"✅ PDF report generated: {pdf_path}")
-            
-            # 10. Prepare Results Markdown
-            results_md = self._generate_results_markdown(
-                symbol,
-                spectral_results,
-                mc_stats,
-                regime_probs,
-                ml_metrics,
-                candlestick_patterns,
-                chart_patterns,
-                composite_momentum,
-                buy_signals
-            )
-            
-            status_message = "\n".join(status_log)
-            
-            # Return charts as HTML embeds for Gradio
-            charts_html = self._create_gradio_html(charts)
-            
-            return charts_html, status_message, results_md, pdf_path
-            
-        except Exception as e:
-            import traceback
-            error_detail = traceback.format_exc()
-            return None, f"❌ Analysis error: {str(e)}\n\n{error_detail}", "", None
+    Returns:
+        list: mpf.make_addplot objelerinin listesi veya boş liste.
+    """
+    if pattern_name not in TALIB_PATTERNS:
+        return [] # Boş liste döndür
+
+    pattern_func = TALIB_PATTERNS[pattern_name]
     
-    def _detect_buy_signals_from_momentum(
-        self,
-        composite_momentum: np.ndarray,
-        prices: np.ndarray,
-        dates: pd.DatetimeIndex
-    ) -> List[Dict]:
-        """Detect buy signals from momentum crossovers"""
-        signals = []
-        threshold = -0.3
-        
-        for i in range(1, len(composite_momentum)-1):
-            # Momentum turning up from oversold
-            if (composite_momentum[i-1] < threshold and 
-                composite_momentum[i] > composite_momentum[i-1] and
-                composite_momentum[i+1] > composite_momentum[i]):
-                
-                signals.append({
-                    'date': dates[i].strftime('%Y-%m-%d'),
-                    'price': float(prices[i]),
-                    'momentum': float(composite_momentum[i])
-                })
-        
-        return signals
+    # TALib'e özel olarak sütun isimleri küçük harf olmalı
+    df_talib = df.rename(columns={
+        'Open': 'open', 
+        'High': 'high', 
+        'Low': 'low', 
+        'Close': 'close', 
+        'Volume': 'volume'
+    })
+
+    pattern_result = pattern_func(df_talib['open'], df_talib['high'], 
+                                   df_talib['low'], df_talib['close'])
     
-    def _create_gradio_html(self, charts: Dict[str, go.Figure]) -> str:
-        """Convert charts to HTML for Gradio display"""
-        html_parts = ["""
-        <div style='background: white; padding: 20px;'>
-        <h1 style='text-align: center; color: #333;'>📊 Interactive Analysis Charts</h1>
-        """]
-        
-        for chart_name, fig in charts.items():
-            title = chart_name.replace('_', ' ').title()
-            html_parts.append(f"<h2 style='color: #666; margin-top: 40px;'>{title}</h2>")
-            html_parts.append(fig.to_html(include_plotlyjs='cdn', div_id=chart_name))
-        
-        html_parts.append("</div>")
-        return "\n".join(html_parts)
+    apds = []
     
-    def _generate_results_markdown(
-        self,
-        symbol,
-        spectral_results,
-        mc_stats,
-        regime_probs,
-        ml_metrics,
-        candlestick_patterns,
-        chart_patterns,
-        composite_momentum,
-        buy_signals
-    ):
-        """Generate detailed results in markdown format"""
-        
-        md = f"""
-# 📊 Professional Quantitative Analysis Report: {symbol}
-
-## 🎯 Executive Summary
-
-**Analysis Date:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
-**Current Market Assessment:**
-- **Composite Momentum:** {composite_momentum[-1]:.4f}
-- **Momentum Direction:** {'📈 Bullish' if composite_momentum[-1] > 0 else '📉 Bearish'}
-- **ML Model Performance:** R² = {ml_metrics['final_r2']:.3f}
-
----
-
-## 🔬 Multi-Frequency Spectral Analysis
-
-Analysis across Low, Mid, and High frequency bands reveals dominant market cycles:
-
-"""
-        
-        for band_name, result in spectral_results.items():
-            band_config = result['band_config']
-            dominant_freqs = result['dominant_frequencies']
-            
-            md += f"""
-### {band_config.name}
-
-**Period Range:** {band_config.min_period:.0f} - {band_config.max_period:.0f} days
-
-**Dominant Cycles:**
-
-"""
-            for i, freq in enumerate(dominant_freqs[:3], 1):
-                md += f"""
-{i}. **Period: {freq['period_days']:.1f} days**
-   - Frequency: {freq['frequency']:.4f} cycles/day
-   - Amplitude: {freq['amplitude']:.0f}
-   - Statistical Significance: {freq['significance']:.1%}
-   - Z-Score: {freq['z_score']:.2f}
-
-"""
-        
-        md += f"""
----
-
-## 🎲 Monte Carlo Simulation Results ({config.MC_SIMULATIONS:,} simulations)
-
-Probabilistic price forecasts over {config.MC_TIME_HORIZON} days:
-
-"""
-        
-        for model_name, stats in mc_stats.items():
-            md += f"""
-### {model_name.upper().replace('_', ' ')} Model
-
-- **Expected Price:** ${stats['mean_final_price']:.2f}
-- **Median Price:** ${stats['median_final_price']:.2f}
-- **95% Confidence Interval:** ${stats['percentile_5']:.2f} - ${stats['percentile_95']:.2f}
-- **Probability of Profit:** {stats['prob_profit']:.1%}
-- **Expected Return:** {stats['expected_return']:.2%}
-- **Value at Risk (95%):** ${stats['var_95']:.2f}
-- **Conditional VaR (95%):** ${stats['cvar_95']:.2f}
-
-"""
-        
-        md += f"""
----
-
-## 📈 Bayesian Market Regime Analysis
-
-**Estimated Regime Probabilities:**
-
-- **Range-Bound Market:** {regime_probs.get('range_bound', 0):.1%}
-- **Trending Market:** {regime_probs.get('trending', 0):.1%}
-- **High Volatility Regime:** {regime_probs.get('high_volatility', 0):.1%}
-
----
-
-## 🤖 Machine Learning Performance
-
-**Self-Supervised Learning Results:**
-
-- **Average MSE (Cross-Validation):** {ml_metrics['avg_mse']:.6f}
-- **Average MAE:** {ml_metrics['avg_mae']:.6f}
-- **Average R² Score:** {ml_metrics['avg_r2']:.3f}
-- **Final R² Score:** {ml_metrics['final_r2']:.3f}
-
-Model continuously learns from past predictions to improve accuracy.
-
----
-
-## 🎯 Pattern Recognition Results
-
-"""
-        
-        if candlestick_patterns:
-            md += f"""
-### Candlestick Patterns ({len(candlestick_patterns)} detected)
-
-Recent patterns:
-
-"""
-            for pattern in candlestick_patterns[-5:]:
-                md += f"- **{pattern['pattern']}** on {pattern['date']} - Signal: {pattern['signal']}\n"
-        else:
-            md += "\n### Candlestick Patterns\n\nNo significant candlestick patterns detected.\n"
-        
-        if chart_patterns:
-            md += f"""
-
-### Chart Patterns ({len(chart_patterns)} detected)
-
-"""
-            for pattern in chart_patterns:
-                md += f"- **{pattern['pattern']}** - Signal: {pattern['signal']}\n"
-        else:
-            md += "\n### Chart Patterns\n\nNo chart patterns detected.\n"
+    # Boğa (bullish) formasyonları için
+    bullish_signals = pattern_result[pattern_result == 100]
+    if not bullish_signals.empty:
+        bullish_plot_data = pd.Series(np.nan, index=df.index)
+        for idx in bullish_signals.index:
+            bullish_plot_data[idx] = df.loc[idx, 'Low'] * 0.98 # Mumun biraz altına
+        apds.append(
+            mpf.make_addplot(bullish_plot_data, 
+                             type='scatter', 
+                             marker='^', # Yukarı üçgen
+                             markersize=100, 
+                             color='green',
+                             panel=0,
+                             alpha=0.7)
+        )
         
-        md += """
-
----
-
-## ⚠️ Risk Disclosure
-
-This analysis is for **educational and informational purposes only**. It does NOT constitute:
-- Financial advice
-- Investment recommendations
-- An offer to buy or sell securities
-
-**Key Limitations:**
-- Models are based on historical data and assumptions
-- Past performance does not guarantee future results
-- All investments carry risk, including potential loss of principal
-- Market conditions can change rapidly and unexpectedly
-
-**Always consult with a qualified financial advisor before making investment decisions.**
-
----
-
-## 🔧 Technical Details
-
-**Analysis Configuration:**
-- Bayesian MCMC Draws: {config.BAYESIAN_DRAWS:,}
-- Monte Carlo Simulations: {config.MC_SIMULATIONS:,}
-- ML Cross-Validation Splits: {config.ML_VALIDATION_SPLITS}
-- Frequency Bands Analyzed: {len(config.FREQUENCY_BANDS)}
-
-**Powered by:**
-- PyMC (Bayesian Inference)
-- XGBoost/LightGBM (Machine Learning)
-- SciPy (Signal Processing)
-- Plotly (Interactive Visualizations)
-"""
+    # Ayı (bearish) formasyonları için
+    bearish_signals = pattern_result[pattern_result == -100]
+    if not bearish_signals.empty:
+        bearish_plot_data = pd.Series(np.nan, index=df.index)
+        for idx in bearish_signals.index:
+            bearish_plot_data[idx] = df.loc[idx, 'High'] * 1.02 # Mumun biraz üstüne
+        apds.append(
+            mpf.make_addplot(bearish_plot_data, 
+                             type='scatter', 
+                             marker='v', # Aşağı üçgen
+                             markersize=100, 
+                             color='red',
+                             panel=0,
+                             alpha=0.7)
+        )
         
-        return md
-
+    return apds
 
-def create_gradio_interface():
-    """Create Gradio UI"""
+def plot_stock_with_patterns(ticker_symbol, start_date, end_date, selected_patterns):
+    """
+    Belirtilen hisse senedi için grafik çizer ve seçilen formasyonları işaretler.
     
-    platform = QuantitativeAnalysisPlatform()
+    Args:
+        ticker_symbol (str): Hisse senedi kodu (örn. "MSFT").
+        start_date (str): Başlangıç tarihi (YYYY-MM-DD).
+        end_date (str): Bitiş tarihi (YYYY-MM-DD).
+        selected_patterns (list): Kullanıcının seçtiği formasyonların listesi.
+        
+    Returns:
+        tuple: (str: Oluşturulan grafiğin dosya yolu, str: Durum mesajı)
+    """
     
-    def analyze_wrapper(symbol, timeframe, period):
-        """Wrapper for Gradio"""
-        html, status, results, pdf = platform.run_complete_analysis(symbol, timeframe, period)
-        return html, status, results, pdf
+    # Tarih formatlarını kontrol edelim
+    try:
+        start = pd.to_datetime(start_date)
+        end = pd.to_datetime(end_date)
+        if start >= end:
+            return None, "Start date must be before end date."
+    except ValueError:
+        return None, "Invalid date format. Please use YYYY-MM-DD."
+
+    try:
+        # yfinance'tan veri çek
+        df = yf.download(ticker_symbol, start=start_date, end=end_date)
+        if df.empty:
+            return None, f"Could not download data for {ticker_symbol}. Please check the ticker symbol and date range."
+    except Exception as e:
+        return None, f"An error occurred while downloading data: {e}"
+
+    # mplfinance'ın beklediği sütun isimlerini kontrol edelim
+    # yfinance zaten 'Open', 'High', 'Low', 'Close', 'Volume' döndürüyor.
+    # Eğer küçük harf olsaydı df.columns = [col.capitalize() for col in df.columns] kullanırdık.
     
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        title="Professional Quantitative Finance Platform",
-        css="""
-        .main-header {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            padding: 30px;
-            border-radius: 10px;
-            text-align: center;
-            margin-bottom: 30px;
-            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
-        }
-        .feature-box {
-            background: #f8f9fa;
-            padding: 20px;
-            border-radius: 8px;
-            border-left: 4px solid #667eea;
-            margin: 10px 0;
-        }
-        """
-    ) as demo:
-        
-        gr.HTML("""
-        <div class="main-header">
-            <h1>🚀 Professional Quantitative Finance Analysis Platform</h1>
-            <p style="font-size: 18px; margin-top: 10px;">
-                Multi-Frequency Spectral Analysis • Bayesian Inference • Monte Carlo Simulation<br/>
-                Machine Learning • Pattern Recognition • Comprehensive Reporting
-            </p>
-        </div>
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.HTML("<h3>⚙️ Analysis Configuration</h3>")
-                
-                symbol_input = gr.Textbox(
-                    label="Stock Symbol",
-                    placeholder="AAPL, MSFT, GOOGL, TSLA...",
-                    value="AAPL"
-                )
-                
-                timeframe_input = gr.Dropdown(
-                    label="Time Interval",
-                    choices=['1d', '1h', '15m', '5m'],
-                    value='1d',
-                    info="Select data granularity"
-                )
-                
-                period_input = gr.Dropdown(
-                    label="Historical Period",
-                    choices=['1mo', '3mo', '6mo', '1y', '2y', '5y'],
-                    value='2y',
-                    info="Amount of historical data to analyze"
-                )
-                
-                analyze_btn = gr.Button(
-                    "🚀 START COMPREHENSIVE ANALYSIS",
-                    variant="primary",
-                    size="lg"
-                )
-                
-                status_output = gr.Textbox(
-                    label="Analysis Status",
-                    lines=15,
-                    interactive=False
-                )
-        
-            with gr.Column(scale=2):
-                gr.HTML("<h3>📊 Interactive Visualizations</h3>")
-                charts_output = gr.HTML(
-                    value="<div style='text-align: center; padding: 50px; color: #666;'>"
-                          "Interactive charts will appear here after analysis</div>"
-                )
-        
-        gr.HTML("<hr style='margin: 30px 0;'>")
-        
-        with gr.Row():
-            with gr.Column():
-                results_output = gr.Markdown(
-                    value="Detailed analysis results will appear here..."
-                )
-        
-        gr.HTML("<hr style='margin: 30px 0;'>")
-        
-        with gr.Row():
-            pdf_output = gr.File(
-                label="📄 Download Comprehensive PDF Report",
-                interactive=False
-            )
-        
-        gr.HTML("""
-        <div class="feature-box">
-            <h3>🎯 Advanced Features</h3>
-            <ul>
-                <li><strong>Multi-Frequency Decomposition:</strong> Separate analysis of low, mid, and high frequency components</li>
-                <li><strong>Self-Supervised Learning:</strong> ML models that learn from past predictions</li>
-                <li><strong>Bayesian Inference:</strong> Probabilistic market regime detection and parameter optimization</li>
-                <li><strong>Monte Carlo Simulation:</strong> Multiple stochastic models (GBM, Jump Diffusion, GARCH, Heston)</li>
-                <li><strong>Pattern Recognition:</strong> Technical patterns + ML-based clustering with DTW</li>
-                <li><strong>Professional Reporting:</strong> Interactive HTML dashboards + comprehensive PDF reports</li>
-            </ul>
-        </div>
-        """)
-        
-        analyze_btn.click(
-            fn=analyze_wrapper,
-            inputs=[symbol_input, timeframe_input, period_input],
-            outputs=[charts_output, status_output, results_output, pdf_output]
-        )
+    # Addplot listesini oluştur
+    all_apds = []
+    if selected_patterns: # Eğer hiç formasyon seçilmemişse boş kalır
+        for pattern_name in selected_patterns:
+            pattern_apds = find_candlestick_patterns(df, pattern_name)
+            all_apds.extend(pattern_apds)
+
+    # Grafiği oluştur ve bir dosyaya kaydet
+    # Geçici bir dosya adı kullanalım
+    fig_path = f"/tmp/stock_chart_{ticker_symbol}_{date.today().strftime('%Y%m%d%H%M%S')}.png"
     
-    return demo
-
+    # mplfinance style ayarları
+    s = mpf.make_mpf_style(base_mpf_style='yahoo', mavcolors=['#1f77b4', '#ff7f0e', '#2ca02c']) # Moving Average renkleri
+    
+    try:
+        fig, axlist = mpf.plot(
+            df, 
+            type='candle', 
+            volume=True, 
+            addplot=all_apds if all_apds else None, # Eğer addplot boşsa None geç
+            style=s, 
+            title=f"{ticker_symbol} Candlestick Chart with Selected Patterns",
+            ylabel='Price', 
+            ylabel_lower='Volume',
+            returnfig=True,
+            figscale=1.5 # Grafik boyutunu ayarla
+        )
+        fig.savefig(fig_path)
+        return fig_path, "Chart generated successfully!"
+    except Exception as e:
+        return None, f"An error occurred while plotting the chart: {e}"
+
+# Gradio arayüzü
+iface = gr.Interface(
+    fn=plot_stock_with_patterns,
+    inputs=[
+        gr.Textbox(label="Ticker Symbol (e.g., MSFT, AAPL, ^GSPC for S&P 500)", value="MSFT"),
+        gr.Textbox(label="Start Date (YYYY-MM-DD)", value="2023-01-01"),
+        gr.Textbox(label="End Date (YYYY-MM-DD)", value=date.today().strftime("%Y-%m-%d")),
+        gr.CheckboxGroup(
+            label="Select Candlestick Patterns",
+            choices=list(TALIB_PATTERNS.keys()),
+            value=["CDLSHOOTINGSTAR", "CDLHAMMER"] # Varsayılan olarak seçili gelenler
+        )
+    ],
+    outputs=[
+        gr.Image(type="filepath", label="Stock Chart"),
+        gr.Textbox(label="Status")
+    ],
+    title="Interactive Stock Candlestick Chart with Technical Patterns",
+    description="Enter a stock ticker, date range, and select candlestick patterns to visualize them on the chart. "
+                "Patterns are marked with green (bullish) or red (bearish) triangles on the chart."
+                "\n\n**Note:** Some TALib patterns are for specific market conditions or require more data points to detect. "
+                "If a pattern is not found, no marker will appear for that pattern."
+)
 
 if __name__ == "__main__":
-    demo = create_gradio_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        show_error=True
-    )
+    iface.launch()