Update app.py

app.py

@@ -6,60 +6,54 @@ import plotly.graph_objects as go
 from scipy import optimize, stats
 from datetime import datetime
 import requests
-import yfinance as yf
 import warnings
-
 warnings.filterwarnings("ignore")
 
-# ================= CONFIGURAÇÃO DO BRAPI =================
-BRAPI_API_KEY = "dCDdw4V35VedwMPBQCLM71"  # Sua chave BRAPI
+# =====================
+# CONFIGURAÇÃO BRAPI
+# =====================
+BRAPI_API_KEY = "dCDdw4V35VedwMPBQCLM71"  # Coloque sua chave aqui
 BRAPI_HEADERS = {"Authorization": f"Bearer {BRAPI_API_KEY}"} if BRAPI_API_KEY else {}
 
-# ================= CLASSE DO SIMULADOR =================
+# =====================
+# CLASSE SIMULADOR
+# =====================
 class PortfolioSimulator:
     def __init__(self):
         self.available_stocks = {
-            'BBAS3.SA': 'Banco do Brasil',
-            'ITSA4.SA': 'Itaúsa',
-            'TAEE11.SA': 'Taesa',
-            'TTEN3.SA': '3tentos',
-            'BPAC11.SA': 'BTG Pactual',
-            'PETR4.SA': 'Petrobras',
-            'VALE3.SA': 'Vale',
-            'ITUB4.SA': 'Itaú Unibanco',
-            'BBDC4.SA': 'Bradesco',
-            'WEGE3.SA': 'WEG',
-            'MGLU3.SA': 'Magazine Luiza',
-            'B3SA3.SA': 'B3',
-            'RENT3.SA': 'Localiza',
-            'ABEV3.SA': 'Ambev',
-            '^BVSP': 'IBOVESPA'
+            'BBAS3': 'Banco do Brasil',
+            'ITSA4': 'Itaúsa',
+            'TAEE11': 'Taesa',
+            'TTEN3': '3tentos',
+            'BPAC11': 'BTG Pactual',
+            'PETR4': 'Petrobras',
+            'VALE3': 'Vale',
+            'ITUB4': 'Itaú Unibanco',
+            'BBDC4': 'Bradesco',
+            'WEGE3': 'WEG',
+            'MGLU3': 'Magazine Luiza',
+            'B3SA3': 'B3',
+            'RENT3': 'Localiza',
+            'ABEV3': 'Ambev',
+            'IBOV': 'IBOVESPA'
         }
 
-    def download_data(self, selected_stocks, start_date, end_date):
-        """Baixa dados históricos usando BRAPI (ou yfinance como fallback)"""
+    def download_data(self, tickers, start_date, end_date):
         df = pd.DataFrame()
-        for stock in selected_stocks:
-            ticker = stock.replace('.SA','')
+        for ticker in tickers:
             try:
-                if stock != '^BVSP':
-                    # BRAPI request
-                    url = f"https://brapi.dev/api/quote/{ticker}?range=5y&interval=1d"
-                    resp = requests.get(url, headers=BRAPI_HEADERS)
-                    resp.raise_for_status()
-                    data = pd.DataFrame(resp.json()['results'][0]['historical'])
-                    data['datetime'] = pd.to_datetime(data['datetime'])
-                    data.set_index('datetime', inplace=True)
-                    df[stock] = data['close']
-                    print(f"✓ {stock} baixado via BRAPI")
-                else:
-                    # yfinance fallback para IBOV
-                    data = yf.download(stock, start=start_date, end=end_date)['Close']
-                    df[stock] = data
-                    print(f"✓ {stock} baixado via yfinance")
+                url = f"https://brapi.dev/api/quote/{ticker}?range=5y&interval=1d"
+                r = requests.get(url, headers=BRAPI_HEADERS, timeout=10)
+                r.raise_for_status()
+                data = r.json().get('results', [])[0]['historical']
+                temp_df = pd.DataFrame(data)
+                temp_df['date'] = pd.to_datetime(temp_df['date'])
+                temp_df = temp_df.set_index('date')
+                df[ticker] = temp_df['close']
+                print(f"✓ {ticker} baixado via BRAPI")
             except Exception as e:
-                print(f"✗ Erro ao baixar {stock}: {e}")
-        df = df.sort_index().dropna()
+                print(f"✗ Erro ao baixar {ticker} via BRAPI: {e}")
+        df = df[start_date:end_date].dropna()
         return df
 
     def calculate_returns(self, prices_df):
@@ -88,111 +82,98 @@ class PortfolioSimulator:
         mean_returns = returns_df.mean()
         cov_matrix = returns_df.cov()
 
-        def neg_sharpe(weights):
+        def negative_sharpe(weights):
             port_return = np.sum(weights * mean_returns)
             port_vol = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
             return -port_return / port_vol if port_vol > 0 else 0
 
-        constraints = {'type': 'eq', 'fun': lambda x: np.sum(x) - 1}
-        bounds = tuple((0,1) for _ in range(n_assets))
-        init_guess = [1/n_assets]*n_assets
-        result = optimize.minimize(neg_sharpe, init_guess, method='SLSQP', bounds=bounds, constraints=constraints)
+        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
+        bounds = tuple((0, 1) for _ in range(n_assets))
+        initial_guess = [1/n_assets] * n_assets
+
+        result = optimize.minimize(
+            negative_sharpe, 
+            initial_guess, 
+            method='SLSQP', 
+            bounds=bounds, 
+            constraints=constraints
+        )
         return result.x
 
     def simulate_portfolio(self, prices_df, weights, initial_investment=35000):
         norm_prices = prices_df / prices_df.iloc[0]
-        portfolio = norm_prices * weights * initial_investment
-        portfolio['Total'] = portfolio.sum(axis=1)
-        portfolio['Daily_Return'] = portfolio['Total'].pct_change()
-        return portfolio
+        portfolio_value = (norm_prices * weights * initial_investment).sum(axis=1)
+        portfolio_return = portfolio_value.pct_change().dropna()
+        return portfolio_value, portfolio_return
 
-# ================= FUNÇÃO DE ANÁLISE =================
+# =====================
+# FUNÇÃO PRINCIPAL
+# =====================
 def run_analysis(selected_stocks, num_simulations, initial_investment, start_date_str, end_date_str):
+    simulator = PortfolioSimulator()
     try:
         start_date = pd.to_datetime(start_date_str)
         end_date = pd.to_datetime(end_date_str)
-
         if not isinstance(selected_stocks, list):
             selected_stocks = [selected_stocks]
-        if '^BVSP' not in selected_stocks:
-            selected_stocks.append('^BVSP')
+        prices_df = simulator.download_data(selected_stocks, start_date, end_date)
+        returns_df = simulator.calculate_returns(prices_df)
 
-        sim = PortfolioSimulator()
-        prices = sim.download_data(selected_stocks, start_date, end_date)
-        returns = sim.calculate_returns(prices)
-        weights_mc, ret_arr, vol_arr, sharpe_arr = sim.monte_carlo_simulation(returns, int(num_simulations))
+        weights_mc, ret_arr, vol_arr, sharpe_arr = simulator.monte_carlo_simulation(returns_df, num_simulations)
         max_idx = np.argmax(sharpe_arr)
         optimal_weights = weights_mc[max_idx]
 
-        portfolio = sim.simulate_portfolio(prices, optimal_weights, float(initial_investment))
-
-        # Gráfico 1: Composição da Carteira
-        fig1 = px.pie(
-            names=selected_stocks,
-            values=optimal_weights,
-            title="Composição da Carteira Ótima"
-        )
-
-        # Gráfico 2: Evolução do Patrimônio
-        fig2 = px.line(
-            portfolio,
-            y="Total",
-            title="Evolução do Patrimônio",
-            labels={"Total":"Valor (R$)", "index":"Data"}
-        )
-
-        # Gráfico 3: Fronteira Eficiente
-        fig3 = go.Figure()
-        fig3.add_trace(go.Scatter(x=vol_arr, y=ret_arr, mode='markers',
-                                  marker=dict(color=sharpe_arr, colorscale='Viridis', showscale=True),
-                                  name='Portfólios Simulados'))
-        fig3.add_trace(go.Scatter(x=[vol_arr[max_idx]], y=[ret_arr[max_idx]], mode='markers',
-                                  marker=dict(color='red', size=15, symbol='star'), name='Máx Sharpe'))
-        fig3.update_layout(title="Fronteira Eficiente", xaxis_title="Volatilidade", yaxis_title="Retorno")
-
-        # Gráfico 4: Preços Normalizados
-        norm_prices = prices / prices.iloc[0]
-        fig4 = px.line(norm_prices, title="Preços Normalizados das Ações")
+        math_weights = simulator.optimize_portfolio(returns_df)
+        portfolio_value, portfolio_return = simulator.simulate_portfolio(prices_df, optimal_weights, initial_investment)
+
+        # ==== GRÁFICOS INTERATIVOS PLOTLY ====
+        fig_weights = px.pie(names=selected_stocks, values=optimal_weights, title="Composição da Carteira Ótima")
+        fig_evolution = go.Figure()
+        fig_evolution.add_trace(go.Scatter(x=portfolio_value.index, y=portfolio_value.values, mode='lines', name='Patrimônio'))
+        fig_evolution.update_layout(title='Evolução do Patrimônio', yaxis_title='Valor (R$)')
+        fig_frontier = go.Figure()
+        fig_frontier.add_trace(go.Scatter(x=vol_arr, y=ret_arr, mode='markers', marker=dict(color=sharpe_arr, colorscale='Viridis', showscale=True), name='Carteiras Simuladas'))
+        fig_frontier.add_trace(go.Scatter(x=[vol_arr[max_idx]], y=[ret_arr[max_idx]], mode='markers', marker=dict(color='red', size=15, symbol='star'), name='Carteira Ótima'))
+        fig_frontier.update_layout(title='Fronteira Eficiente', xaxis_title='Volatilidade', yaxis_title='Retorno')
+        fig_prices = go.Figure()
+        for stock in selected_stocks:
+            fig_prices.add_trace(go.Scatter(x=prices_df.index, y=prices_df[stock], mode='lines', name=stock))
+        fig_prices.update_layout(title='Preços das Ações', yaxis_title='Preço')
 
-        return "✅ Simulação concluída com sucesso!", fig1, fig2, fig3, fig4
+        result_text = f"""
+        ## 📊 Resultados
+        **Investimento Inicial:** R$ {initial_investment:,.2f}
+        **Valor Final:** R$ {portfolio_value.iloc[-1]:,.2f}
+        **Retorno Total:** {(portfolio_value.iloc[-1]/initial_investment - 1)*100:.2f}%
+        """
 
+        return result_text, fig_weights, fig_evolution, fig_frontier, fig_prices
     except Exception as e:
-        return f"❌ Erro na simulação: {str(e)}", None, None, None, None
-
-# ================= INTERFACE GRADIO =================
-sim = PortfolioSimulator()
-
-with gr.Blocks(title="Simulador de Portfólio Interativo") as demo:
-    gr.Markdown("# 🎯 Simulador de Portfólio Interativo")
-    gr.Markdown("Monte Carlo + Fronteira Eficiente + Plotly interativo")
-
+        return f"❌ Erro na simulação: {e}", None, None, None, None
+
+# =====================
+# INTERFACE GRADIO
+# =====================
+simulator = PortfolioSimulator()
+with gr.Blocks(title="Simulador de Portfólio - BRAPI") as demo:
+    gr.Markdown("# 🎯 Simulador de Portfólio - BRAPI")
     with gr.Row():
         with gr.Column():
-            selected_stocks = gr.CheckboxGroup(
-                choices=list(sim.available_stocks.keys()),
-                label="Selecione Ações",
-                value=['BBAS3.SA', 'ITSA4.SA', 'TAEE11.SA', '^BVSP']
-            )
-            num_simulations = gr.Slider(1000,200000,value=50000,step=1000,label="Número de Simulações")
-            initial_investment = gr.Number(value=35000,label="Investimento Inicial (R$)")
-            start_date = gr.Textbox("2020-01-01", label="Data Inicial (YYYY-MM-DD)")
-            end_date = gr.Textbox("2024-01-01", label="Data Final (YYYY-MM-DD)")
+            selected_stocks = gr.CheckboxGroup(label="Selecione as Ações", choices=list(simulator.available_stocks.keys()), value=['BBAS3','ITSA4','TAEE11'])
+            num_simulations = gr.Slider(label="Número de Simulações", minimum=1000, maximum=200000, value=50000, step=1000)
+            initial_investment = gr.Number(label="Investimento Inicial (R$)", value=35000)
+            start_date = gr.Textbox(label="Data Inicial (YYYY-MM-DD)", value="2018-01-01")
+            end_date = gr.Textbox(label="Data Final (YYYY-MM-DD)", value="2024-01-01")
             run_btn = gr.Button("🚀 Executar Simulação", variant="primary")
-
         with gr.Column():
-            result_text = gr.Markdown()
-
+            results_text = gr.Markdown()
     with gr.Row():
         pie_chart = gr.Plot(label="Composição da Carteira")
         evolution_plot = gr.Plot(label="Evolução do Patrimônio")
         efficient_frontier = gr.Plot(label="Fronteira Eficiente")
-        prices_plot = gr.Plot(label="Preços Normalizados")
-
-    run_btn.click(
-        fn=run_analysis,
-        inputs=[selected_stocks,num_simulations,initial_investment,start_date,end_date],
-        outputs=[result_text,pie_chart,evolution_plot,efficient_frontier,prices_plot]
-    )
+        prices_plot = gr.Plot(label="Preços das Ações")
+    run_btn.click(fn=run_analysis, inputs=[selected_stocks, num_simulations, initial_investment, start_date, end_date],
+                  outputs=[results_text, pie_chart, evolution_plot, efficient_frontier, prices_plot])
 
 if __name__ == "__main__":
     demo.launch(share=True)