app.py

import streamlit as st
import yfinance as yf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import scipy.optimize as sco

def get_stock_data(tickers, start, end):
    data = yf.download(tickers, start=start, end=end)
    
    if data.empty:
        st.error("Data saham tidak ditemukan. Periksa ticker atau rentang tanggal.")
        return None
    
    if 'Adj Close' in data.columns:
        return data['Adj Close']
    elif 'Close' in data.columns:
        st.warning("Menggunakan 'Close' karena 'Adj Close' tidak tersedia.")
        return data['Close']
    else:
        st.error("Data harga penutupan tidak ditemukan.")
        return None

def calculate_returns(data):
    log_returns = np.log(data / data.shift(1))  
    return log_returns.mean() * 252, log_returns.cov() * 252

def optimize_portfolio(returns, cov_matrix):
    num_assets = len(returns)
    
    def sharpe_ratio(weights):
        portfolio_return = np.dot(weights, returns)
        portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
        return -portfolio_return / portfolio_volatility  
    
    constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
    bounds = tuple((0, 1) for _ in range(num_assets))
    init_guess = num_assets * [1. / num_assets]
    
    result = sco.minimize(sharpe_ratio, init_guess, method='SLSQP', bounds=bounds, constraints=constraints)
    return result.x if result.success else None

def generate_efficient_frontier(returns, cov_matrix, num_portfolios=5000):
    num_assets = len(returns)
    results = np.zeros((3, num_portfolios))
    
    for i in range(num_portfolios):
        weights = np.random.dirichlet(np.ones(num_assets), size=1)[0]
        portfolio_return = np.dot(weights, returns)
        portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
        sharpe_ratio = portfolio_return / portfolio_volatility
        
        results[0, i] = portfolio_return
        results[1, i] = portfolio_volatility
        results[2, i] = sharpe_ratio
    
    return results

st.title("Analisis Portofolio Saham Optimal (Model Markowitz)")

st.markdown("""
### Teori Markowitz
Model Markowitz, atau Modern Portfolio Theory (MPT), digunakan untuk membangun portofolio investasi optimal dengan memaksimalkan return untuk tingkat risiko tertentu.

Portofolio yang optimal ditemukan dengan menghitung kombinasi terbaik dari aset yang tersedia untuk meminimalkan risiko dan memaksimalkan return.
""")

def get_recommended_stocks():
    return "KLBF.JK, SIDO.JK, KAEF.JK, TLKM.JK, UNVR.JK"

def validate_tickers(tickers):
    invalid_tickers = [t for t in tickers if yf.Ticker(t).history(period='1d').empty]
    if invalid_tickers:
        st.warning(f"Ticker tidak valid atau tidak memiliki data: {', '.join(invalid_tickers)}")
        return False
    return True

st.write("Rekomendasi Saham yang Bertahan Saat COVID-19:")
st.write(get_recommended_stocks())

tickers_list = st.text_input("Masukkan ticker saham", "KLBF.JK, SIDO.JK, KAEF.JK").split(", ")
start_date = st.date_input("Pilih tanggal mulai", pd.to_datetime("2020-01-01"))
end_date = st.date_input("Pilih tanggal akhir", pd.to_datetime("2023-12-31"))

if st.button("Analisis Portofolio"):
    if validate_tickers(tickers_list):
        stock_data = get_stock_data(tickers_list, start_date, end_date)
        if stock_data is not None:
            mean_returns, cov_matrix = calculate_returns(stock_data)
            optimal_weights = optimize_portfolio(mean_returns, cov_matrix)

            st.subheader("Statistik Saham")
            st.write(stock_data.describe())
            
            if optimal_weights is not None:
                st.subheader("Bobot Portofolio Optimal")
                portfolio_weights = {stock: weight for stock, weight in zip(stock_data.columns, optimal_weights)}
                st.write(portfolio_weights)
                
                # Pie Chart dengan filter saham dengan bobot signifikan
                filtered_weights = {k: v for k, v in portfolio_weights.items() if v > 0.01}
                fig, ax = plt.subplots()
                ax.pie(filtered_weights.values(), labels=filtered_weights.keys(), autopct='%1.1f%%', startangle=140)
                ax.axis('equal')
                st.pyplot(fig)
                
                # Efficient Frontier
                results = generate_efficient_frontier(mean_returns, cov_matrix)
                
                st.subheader("Efficient Frontier")
                fig, ax = plt.subplots()
                scatter = ax.scatter(results[1, :], results[0, :], c=results[2, :], cmap="viridis", marker='o')
                ax.set_xlabel("Risiko (Standar Deviasi)")
                ax.set_ylabel("Return Tahunan")
                ax.set_title("Efficient Frontier")
                fig.colorbar(scatter, label="Sharpe Ratio")
                st.pyplot(fig)
                
                st.markdown("""
                **Interpretasi:**
                - Bobot dalam portofolio menunjukkan proporsi investasi pada masing-masing saham.
                - Semakin besar bobot, semakin besar porsi dana yang dialokasikan ke saham tersebut.
                - Grafik Efficient Frontier menunjukkan hubungan antara risiko dan return dari berbagai kombinasi portofolio.
                - Portofolio yang berada di frontier efisien memberikan return terbaik untuk tingkat risiko tertentu.
                """)
            else:
                st.error("Optimasi portofolio gagal. Coba dengan saham yang berbeda.")