updating app.py files

Balance_sheet.py

@@ -0,0 +1,121 @@
+import streamlit as st
+import pandas as pd
+import yfinance as yf
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+def load_and_display_BS(ticker1, ticker2):
+    try:
+        # Fetch P&L data
+        ticker1_data = yf.Ticker(ticker1).balance_sheet
+        ticker2_data = yf.Ticker(ticker2).balance_sheet
+
+        # Transpose for better visualization
+        ticker1_df = ticker1_data.transpose()
+        ticker2_df = ticker2_data.transpose()
+
+        # Basic data cleaning (adjust as needed)
+        ticker1_df = ticker1_df.fillna(0)  # Fill missing values with 0
+        ticker2_df = ticker2_df.fillna(0)
+
+        
+        #MARGINS & Ratios
+        #ticker one
+        ticker1_df['Debt-to-Equity Ratio'] = (ticker1_df['Total Debt'] /ticker1_df['Common Stock Equity'])
+        ticker1_df['Debt-to-Assets Ratio'] = (ticker1_df['Total Debt'] /ticker1_df['Total Assets'])
+        ticker1_df['Current Ratio'] = (ticker1_df['Current Assets'] / ticker1_df['Current Liabilities'])
+        #ticker1_df['Quick Ratio'] = (ticker1_df['Current Assets'] - ticker1_df['Inventory'] /ticker1_df['Current Liabilities'])
+        ticker1_df['Working Capital Ratio'] = ticker1_df['Working Capital'] / ticker1_df['Total Assets']
+        ticker1_df['Cash Ratio'] = ticker1_df['Cash Cash Equivalents And Short Term Investments'] / ticker1_df['Current Liabilities']
+
+        ticker2_df['Debt-to-Equity Ratio'] = (ticker2_df['Total Debt'] /ticker2_df['Common Stock Equity'])
+        ticker2_df['Debt-to-Assets Ratio'] = (ticker2_df['Total Debt'] /ticker2_df['Total Assets'])
+        ticker2_df['Current Ratio'] = (ticker2_df['Current Assets'] / ticker2_df['Current Liabilities'])
+        #ticker2_df['Quick Ratio'] = (ticker2_df['Current Assets'] -ticker2_df['Inventory'] /ticker2_df['Current Liabilities'])
+        ticker2_df['Working Capital Ratio'] = ticker2_df['Working Capital'] / ticker2_df['Total Assets']
+        ticker2_df['Cash Ratio'] = ticker2_df['Cash Cash Equivalents And Short Term Investments'] / ticker2_df['Current Liabilities']
+
+
+        Solvency_Ratios_1 = ticker1_df[['Debt-to-Equity Ratio', 'Debt-to-Assets Ratio', 'Current Ratio' ]]
+        Solvency_Ratios_2 = ticker2_df[['Debt-to-Equity Ratio', 'Debt-to-Assets Ratio', 'Current Ratio' ]]
+
+        cash_and_working_captial_1 = ticker1_df[['Working Capital Ratio', 'Cash Ratio']]
+        cash_and_working_captial_2 = ticker2_df[['Working Capital Ratio', 'Cash Ratio']]
+
+
+        assets_1 = ticker1_df[['Total Assets', 'Current Assets', 'Cash Cash Equivalents And Short Term Investments',  'Inventory','Gross PPE', 'Properties', 'Land And Improvements', 'Accumulated Depreciation', 'Goodwill And Other Intangible Assets',  'Invested Capital', 'Net Tangible Assets']]
+        Debt_1 = ticker1_df[['Total Liabilities Net Minority Interest', 'Total Debt', 'Current Liabilities', 'Current Provisions', 'Other Current Liabilities', 'Total Non Current Liabilities Net Minority Interest', 'Long Term Debt', 'Long Term Debt And Capital Lease Obligation',  'Long Term Provisions', 'Stockholders Equity']]
+
+
+        assets_2 = ticker2_df[['Total Assets', 'Current Assets', 'Cash Cash Equivalents And Short Term Investments', 'Inventory', 'Gross PPE','Properties', 'Land And Improvements', 'Accumulated Depreciation', 'Goodwill And Other Intangible Assets', 'Invested Capital', 'Net Tangible Assets']]
+        Debt_2 = ticker2_df[[ 'Total Liabilities Net Minority Interest', 'Total Debt', 'Current Liabilities', 'Current Provisions', 'Other Current Liabilities', 'Total Non Current Liabilities Net Minority Interest', 'Long Term Debt', 'Long Term Debt And Capital Lease Obligation', 'Long Term Provisions' ,'Stockholders Equity']]
+
+        #calculate the vertical analysis 
+        assets_1_vertical = assets_1.T.div(assets_1['Total Assets'], axis=1).round(2) * 100
+        Debt_1_vertical = Debt_1.T.div(Debt_1['Total Liabilities Net Minority Interest'], axis=1).round(2) * 100
+
+        #calculate the vertical analysis 
+        assets_2_vertical = assets_2.T.div(assets_2['Total Assets'], axis=1).round(2) * 100
+        Debt_2_vertical = Debt_2.T.div(Debt_2['Total Liabilities Net Minority Interest'], axis=1).round(2) * 100
+
+        # Calculate and visualize horizontal analysis
+        ticker1_asset_1_pct_change = assets_1.pct_change(axis=1) * 100
+        ticker2_asset_2_pct_change = assets_2.pct_change(axis=1) * 100
+
+
+
+
+
+        # Display side-by-side
+        
+        col1, col2 = st.columns(2)
+        with col1:
+
+            
+            st.title(f"{ticker1}:Ratios")
+            st.line_chart(Solvency_Ratios_1)
+            
+
+            plt.title(f"{ticker1}:Ratios")
+            st.dataframe(cash_and_working_captial_1)
+            # sns.heatmap(cash_and_working_captial_1, annot=True, fmt='.2f', cmap='coolwarm', ax=ax)
+            st.subheader(f"Vertical Analysis of Assets in % : {ticker1}")
+            st.dataframe(assets_1_vertical)
+            st.subheader(f"Vertical Analysis of Debts in % : {ticker1}")
+            
+            fig, ax =plt.subplots()
+            plt.title(f"Vertical Analysis of Debts in %: {ticker1}")
+            sns.heatmap(Debt_1_vertical, annot=True, fmt='.2f', cmap='coolwarm', ax=ax)
+            st.pyplot(fig)
+            st.dataframe(ticker1_asset_1_pct_change)
+
+            
+            
+
+
+
+        with col2:
+            
+            st.title(f"{ticker2}:Ratios")
+            st.line_chart(Solvency_Ratios_2)
+            
+
+            plt.title(f"Cash and Equaivalents & working captial Ratios : {ticker2}")
+            st.dataframe(cash_and_working_captial_2)
+            # sns.heatmap(cash_and_working_captial_2, annot=True, fmt='.2f', cmap='coolwarm', ax=ax)
+            st.subheader(f"Vertical Analysis of Assets in % : {ticker2}")
+            st.dataframe(assets_2_vertical)
+            st.subheader(f"Vertical Analysis of Debts in % : {ticker2}")
+            
+            fig, ax =plt.subplots()
+            plt.title(f"Vertical Analysis of Debts in % : {ticker2}")
+            sns.heatmap(Debt_2_vertical, annot=True, fmt='.2f', cmap='coolwarm', ax=ax)
+            st.pyplot(fig)
+            st.dataframe(ticker2_asset_2_pct_change)
+
+            
+
+    except Exception as e:
+        st.error(f"An error occurred: {e}")
+    return load_and_display_BS
+

Cashflows.py

@@ -0,0 +1,69 @@
+import streamlit as st
+import pandas as pd
+import yfinance as yf
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+def load_and_display_cashflows(ticker1, ticker2):
+    try:
+        # Fetch P&L data
+        ticker1_data = yf.Ticker(ticker1).cashflow
+        ticker2_data = yf.Ticker(ticker2).cashflow
+
+        # Transpose for better visualization
+        ticker1_df = ticker1_data.transpose()
+        ticker2_df = ticker2_data.transpose()
+
+        # Basic data cleaning (adjust as needed)
+        ticker1_df = ticker1_df.fillna(0)  # Fill missing values with 0
+        ticker2_df = ticker2_df.fillna(0)
+
+        
+        #MARGINS & Ratios
+        #ticker one
+        ticker1_df['CFO_to_Revenue'] = (ticker1_df['Operating Cash Flow'] /ticker1_df['Net Income From Continuing Operations'])
+        ticker1_df['FCF_to_Revenue'] = (ticker1_df['Free Cash Flow'] /ticker1_df['Net Income From Continuing Operations'])
+
+        ticker2_df['CFO_to_Revenue'] = (ticker2_df['Operating Cash Flow'] /ticker2_df['Net Income From Continuing Operations'])
+        ticker2_df['FCF_to_Revenue'] = (ticker2_df['Free Cash Flow'] /ticker2_df['Net Income From Continuing Operations'])
+
+
+        cash_flow_ratios_1 = ticker1_df[['CFO_to_Revenue', 'FCF_to_Revenue']]
+        cash_flow_ratios_2 = ticker2_df[['CFO_to_Revenue', 'FCF_to_Revenue']]
+
+
+
+
+
+        # Display side-by-side
+        
+        col1, col2 = st.columns(2)
+        with col1:
+
+            
+            st.title(f"{ticker1}:Ratios")
+            st.line_chart(cash_flow_ratios_1)
+            
+
+            plt.title(f"{ticker1}:Ratios")
+            st.dataframe(cash_flow_ratios_1)
+            # sns.heatmap(cash_and_working_captial_1, annot=True, fmt='.2f', cmap='coolwarm', ax=ax)
+            
+            
+
+
+
+        with col2:
+            
+            st.title(f"{ticker2}:Ratios")
+            st.line_chart(cash_flow_ratios_2)
+            
+            plt.title(f"Cash and Equaivalents & working captial Ratios : {ticker2}")
+            st.dataframe(cash_flow_ratios_2)
+            # sns.heatmap(cash_and_working_captial_2, annot=True, fmt='.2f', cmap='coolwarm', ax=ax)
+            
+
+    except Exception as e:
+        st.error(f"An error occurred: {e}")
+    return load_and_display_cashflows
+

PL.py

@@ -0,0 +1,126 @@
+import streamlit as st
+import pandas as pd
+import yfinance as yf
+import seaborn as sns
+import matplotlib.pyplot as plt
+# import openai
+
+
+def load_and_display_pl(ticker1, ticker2):
+    try:
+        # Fetch P&L data
+        ticker1_data = yf.Ticker(ticker1).financials
+        ticker2_data = yf.Ticker(ticker2).financials
+
+        # Transpose for better visualization
+        ticker1_df = ticker1_data.transpose()
+        ticker2_df = ticker2_data.transpose()
+
+        # Basic data cleaning (adjust as needed)
+        ticker1_df = ticker1_df.fillna(0)  # Fill missing values with 0
+        ticker2_df = ticker2_df.fillna(0)
+
+        ticker1_df = ticker1_df[['Total Revenue', 'Cost Of Revenue', 'Gross Profit', 'Operating Income', 'Operating Expense', 'EBIT', 'EBITDA', 'Pretax Income','Tax Provision','Net Interest Income','Net Income', 'Basic EPS']]
+        ticker2_df = ticker2_df[['Total Revenue', 'Cost Of Revenue', 'Gross Profit', 'Operating Income', 'Operating Expense', 'EBIT', 'EBITDA', 'Pretax Income','Tax Provision','Net Interest Income','Net Income', 'Basic EPS']]
+
+        # Calculate and visualize horizontal analysis
+        ticker1_pct_change = ticker1_df.pct_change(axis=1) * 100
+        ticker2_pct_change = ticker2_df.pct_change(axis=1) * 100
+
+        ticker1_pct_change_1 = ticker1_pct_change[['Gross Profit',  'Pretax Income', 'Net Income']]
+        ticker2_pct_change_2 = ticker2_pct_change[['Gross Profit',  'Pretax Income', 'Net Income']]
+
+        #calculate the vertical analysis 
+        ticker_1_vertical = ticker1_df.T.div(ticker1_df['Total Revenue'], axis=1).round(2) * 100
+        ticker_2_vertical = ticker2_df.T.div(ticker2_df['Total Revenue'], axis=1).round(2) * 100
+
+        #MARGINS & Ratios
+        #ticker one
+        ticker1_df['Operating_profit_Margin'] = (ticker1_df['Operating Income'] /ticker1_df['Total Revenue']) *100
+        ticker1_df['Operating_Expense_Ratio'] = (ticker1_df['Operating Expense'] /ticker1_df['Total Revenue']) *100
+        ticker1_df['Interest_Coverage_Ratio'] = ticker1_df['EBIT'] / abs(ticker1_df['Net Interest Income']) 
+        ticker1_df['Effective_Tax_Rate'] = (ticker1_df['Tax Provision'] / ticker1_df['Pretax Income']) * 100
+        ticker1_df['Net_profit_Margin'] = (ticker1_df['Net Income'] /ticker1_df['Total Revenue']) *100
+
+        ticker2_df['Operating_profit_Margin'] = (ticker2_df['Operating Income'] /ticker2_df['Total Revenue']) *100
+        ticker2_df['Operating_Expense_Ratio'] = (ticker2_df['Operating Expense'] /ticker2_df['Total Revenue']) *100
+        ticker2_df['Interest_Coverage_Ratio'] = ticker2_df['EBIT'] / abs(ticker2_df['Net Interest Income']) 
+        ticker2_df['Effective_Tax_Rate'] = (ticker2_df['Tax Provision'] / ticker2_df['Pretax Income']) * 100
+        ticker2_df['Net_profit_Margin'] = (ticker2_df['Net Income'] /ticker2_df['Total Revenue']) *100
+
+
+        Profit_Margins_1 = ticker1_df[['Operating_profit_Margin', 'Operating_Expense_Ratio', 'Interest_Coverage_Ratio', 'Effective_Tax_Rate', 'Net_profit_Margin']]
+        Profit_Margins_2 = ticker2_df[['Operating_profit_Margin', 'Operating_Expense_Ratio', 'Interest_Coverage_Ratio', 'Effective_Tax_Rate', 'Net_profit_Margin']]
+
+
+
+        # Display side-by-side
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.header(f"Vertical Analysis : {ticker1}")
+            st.dataframe(ticker_1_vertical)
+            st.header(f"Horizantal Analysis : {ticker1}")
+            st.dataframe(ticker1_pct_change)
+            st.header(f"Trend Analysis : {ticker1}")
+            st.line_chart(ticker1_pct_change_1)
+            # st.dataframe(Profit_Margins)
+            fig, ax =plt.subplots()
+            plt.title(f"Margins & Tax coverage Ratio of : {ticker1}")
+            sns.heatmap(Profit_Margins_1, annot=True, fmt='.2f', cmap='coolwarm', ax=ax)
+            st.pyplot(fig)
+            
+
+
+
+        with col2:
+            st.header(f"Vertical Analysis of : {ticker2}")
+            st.dataframe(ticker_2_vertical)
+            st.header(f"Horizantal Analysis : {ticker2}")
+            st.dataframe(ticker2_pct_change)
+            st.header(f"Trend Analysis of :{ticker2}")
+            st.line_chart(ticker2_pct_change_2)
+            fig, ax =plt.subplots()
+            plt.title(f"Margins & Tax coverage Ratio of : {ticker2}")
+            sns.heatmap(Profit_Margins_2, annot=True, fmt='.2f', cmap='coolwarm', ax=ax)
+            st.pyplot(fig)
+
+
+
+    #     # GPT-3 Integration
+    #     openai.api_key = ""
+    #     # Prepare data for GPT-3
+    #     ticker1_summary = f"**{ticker1}**\n\n" \
+    #                      f"**Vertical Analysis:**\n{ticker_1_vertical.to_markdown()}\n\n" \
+    #                      f"**Horizontal Analysis:**\n{ticker1_pct_change.to_markdown()}\n\n" \
+    #                      f"**Key Ratios:**\n{Profit_Margins_1.to_markdown()}\n\n"
+    #     ticker2_summary = f"**{ticker2}**\n\n" \
+    #                      f"**Vertical Analysis:**\n{ticker_2_vertical.to_markdown()}\n\n" \
+    #                      f"**Horizontal Analysis:**\n{ticker2_pct_change.to_markdown()}\n\n" \
+    #                      f"**Key Ratios:**\n{Profit_Margins_2.to_markdown()}\n\n"
+
+    #     prompt = f"Compare and contrast the financial performance of the two companies based on their P&L data:\n\n" \
+    #              f"{ticker1_summary}\n\n" \
+    #              f"{ticker2_summary}\n\n" \
+    #              f"Provide insights into their profitability, growth trends, and operational efficiency."
+
+    #     # Generate response from GPT-3
+    #     response = openai.Completion.create(
+    #         engine="text-ada-001",  # Choose an appropriate engine
+    #         prompt=prompt,
+    #         max_tokens=1024,
+    #         n=1,
+    #         stop=None,
+    #         temperature=0.7
+    #     )
+
+    #     # Display GPT-3's analysis
+    #     st.header("GPT-3 Analysis")
+    #     st.write(response.choices[0].text)
+
+    except Exception as e:
+        st.error(f"An error occurred: {e}")
+    return load_and_display_pl
+
+    
+

app.py

@@ -0,0 +1,105 @@
+import streamlit as st
+import pandas as pd
+import yfinance as yf
+import plotly.graph_objects as go
+from PL import load_and_display_pl
+from Balance_sheet import load_and_display_BS
+from Cashflows import load_and_display_cashflows
+# from news import classify_sentiment
+from daily_prices import load_and_display_prices
+from macd_prices import load_and_display_macd
+
+
+def main():
+    # st.title("Compare Companies fundamental Statements")
+
+    # Using Markdown to make the title bold
+    st.markdown("# **SURF THROUGH YOUR STOCKS**")
+    
+
+    # User input for ticker symbols
+    
+    ticker1 = st.text_input("Your Yahoo Ticker Symbol-1")
+    ticker2 = st.text_input("Your Yahoo Ticker Symbol-2")
+
+    # Tabbed interface
+    tab1, tab2, tab3, tab5, tab6  = st.tabs([  "P/L Statement","Balance Sheet", "Cashflow", 'Compare Prices', "MACD Indicatords"])
+
+    with tab1:
+    # Button to trigger data loading and display
+      if st.button("Load and Compare Profit and loss statement"):
+        load_and_display_pl(ticker1, ticker2)
+
+    with tab2:
+    # Button to trigger data loading and display the Balance sheets Ratios
+      if st.button("Load and Compare Balance statement"):
+        load_and_display_BS(ticker1, ticker2)
+
+    with tab3:
+    # Button to trigger data loading and display the cashflow statement Ratios
+      if st.button("Load and Compare cashflow statement"):
+        load_and_display_cashflows(ticker1, ticker2)
+
+    # with tab4:
+    # # Button to trigger data loading and display the news updates
+    #   if st.button("Load and Compare News updates"):
+            
+        
+
+    with tab5:
+      
+      if st.button("Load and Compare Prices"): 
+        load_and_display_prices(ticker1, ticker2)
+    
+    with tab6:
+      # User input for MACD parameters
+       price_column = st.selectbox("Price Column", ["High", "Low", "Close", "Open"], index=2)  # Default to "Close"
+       ema_fast = st.number_input("Fast EMA Span", min_value=1, step=1, value=12)
+       ema_slow = st.number_input("Slow EMA Span", min_value=1, step=1, value=26)
+       signal_span = st.number_input("Signal Span", min_value=1, step=1, value=9)
+       user_inputs = {
+      "price_column": price_column,
+      "ema_fast": ema_fast,
+      "ema_slow": ema_slow,
+      "signal_span": signal_span
+          }
+      
+       if st.button("Load and Compare MACD Indicators"): 
+        load_and_display_macd(ticker1, ticker2, user_inputs)
+
+
+    
+
+
+
+    # Add the footer with HTML
+    st.markdown(
+        """
+        <style>
+        .footer {
+            position: fixed;
+            left: 0;
+            bottom: 0;
+            width: 100%;
+            background-color: white;
+            color: black;
+            text-align: center;
+            padding: 10px;
+        }
+        </style>
+        <div class="footer">
+            <p>Made with ❤️ by TJ and Auttribe Community</p>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+    
+    # Ensure that the layout does not extend beyond the footer
+    st.write("\n" * 10)
+
+
+
+            
+
+if __name__ == "__main__":
+    main()

daily_prices.py

@@ -0,0 +1,229 @@
+import streamlit as st
+import numpy as np
+import yfinance as yf
+import pandas as pd
+import plotly.graph_objects as go
+from sklearn.preprocessing import MinMaxScaler
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense, Dropout
+
+def load_and_display_prices(ticker1, ticker2):
+
+    # Fetch historical data
+    try:
+        data1 = yf.download(ticker1, period="5y")
+        data2 = yf.download(ticker2, period="5y")
+    except Exception as e:
+        st.error(f"Error fetching data: {e}")
+        return
+
+    # Calculate daily change in closing price
+    data1['Daily Change (' + ticker1 + ')'] = data1['Close'].diff()
+    data2['Daily Change (' + ticker2 + ')'] = data2['Close'].diff()
+
+    # ---- Chart of Daily Changes ----
+    fig = go.Figure()
+
+    # Create line traces for daily changes
+    fig.add_trace(go.Scatter(
+        x=data1.index,
+        y=data1['Daily Change (' + ticker1 + ')'],
+        name='Daily Change (' + ticker1 + ')',
+        mode='lines',
+        marker=dict(color='royalblue')
+    ))
+    fig.add_trace(go.Scatter(
+        x=data2.index,
+        y=data2['Daily Change (' + ticker2 + ')'],
+        name='Daily Change (' + ticker2 + ')',
+        mode='lines',
+        marker=dict(color='darkorange')
+    ))
+
+    # Customize the layout
+    fig.update_layout(
+        xaxis_title='Date',
+        yaxis_title='Daily Change',
+        title='Daily Change in Closing Price for ' + ticker1 + ' and ' + ticker2
+    )
+
+    # Display the chart
+    st.plotly_chart(fig)
+
+    # Calculate 50-day and 100-day moving averages
+    data1['50-Day MA (' + ticker1 + ')'] = data1['Close'].rolling(window=50).mean()
+    data1['100-Day MA (' + ticker1 + ')'] = data1['Close'].rolling(window=100).mean()
+    data2['50-Day MA (' + ticker2 + ')'] = data2['Close'].rolling(window=50).mean()
+    data2['100-Day MA (' + ticker2 + ')'] = data2['Close'].rolling(window=100).mean()
+
+    # ---- Candlestick Chart with Moving Averages ----
+    fig_1 = go.Figure()
+
+    # Add candlestick traces for each ticker
+    fig_1.add_trace(go.Candlestick(
+        x=data1.index,
+        open=data1['Open'],
+        high=data1['High'],
+        low=data1['Low'],
+        close=data1['Close'],
+        name=ticker1
+    ))
+    fig_1.add_trace(go.Candlestick(
+        x=data2.index,
+        open=data2['Open'],
+        high=data2['High'],
+        low=data2['Low'],
+        close=data2['Close'],
+        name=ticker2
+    ))
+
+    # Add moving average lines for each ticker
+    fig_1.add_trace(go.Scatter(
+        x=data1.index,
+        y=data1['50-Day MA (' + ticker1 + ')'],
+        name='50-Day MA (' + ticker1 + ')',
+        mode='lines',
+        line=dict(color='blue', width=2)
+    ))
+    fig_1.add_trace(go.Scatter(
+        x=data1.index,
+        y=data1['100-Day MA (' + ticker1 + ')'],
+        name='100-Day MA (' + ticker1 + ')',
+        mode='lines',
+        line=dict(color='green', width=2)
+    ))
+    fig_1.add_trace(go.Scatter(
+        x=data2.index,
+        y=data2['50-Day MA (' + ticker2 + ')'],
+        name='50-Day MA (' + ticker2 + ')',
+        mode='lines',
+        line=dict(color='orange', width=2)
+    ))
+    fig_1.add_trace(go.Scatter(
+        x=data2.index,
+        y=data2['100-Day MA (' + ticker2 + ')'],
+        name='100-Day MA (' + ticker2 + ')',
+        mode='lines',
+        line=dict(color='teal', width=2)
+    ))
+
+    # Customize the layout
+    fig_1.update_layout(
+        xaxis_title='Date',
+        yaxis_title='Price'
+    )
+
+    # Display the chart
+    st.plotly_chart(fig_1)
+
+    # ---- Machine Learning Model for Future Price Prediction ----
+    def create_model(x_train, y_train):
+        model = Sequential()
+        model.add(LSTM(100, return_sequences=True, input_shape=(x_train.shape[1], x_train.shape[2])))  # Explicitly define input shape
+        model.add(Dropout(0.2))
+        model.add(LSTM(100))
+        model.add(Dropout(0.01))
+        model.add(Dense(1))
+        model.compile(loss='mse', optimizer='adam')
+        model.fit(x_train, y_train, epochs=5, batch_size=32 , verbose=1)
+        return model
+
+    # Hyperparameters (adjust as needed)
+    look_back = 500  # Number of days to look back for prediction
+    n_features = 1  # Using closing price as the feature
+
+    # Prepare data for model (assuming closing price for prediction)
+    scaler_1 = MinMaxScaler(feature_range=(0, 1))
+    scaler_2 = MinMaxScaler(feature_range=(0, 1))
+    scaled_data1 = scaler_1.fit_transform(data1[['Close']])
+    scaled_data2 = scaler_2.fit_transform(data2[['Close']])
+
+    x_train1, y_train1 = [], []
+    x_train2, y_train2 = [], []
+
+    for i in range(look_back, len(scaled_data1)):
+        x_train1.append(scaled_data1[i-look_back:i, 0])
+        y_train1.append(scaled_data1[i, 0])
+
+    for i in range(look_back, len(scaled_data2)):
+        x_train2.append(scaled_data2[i-look_back:i, 0])
+        y_train2.append(scaled_data2[i, 0])
+
+    x_train1, y_train1 = np.array(x_train1), np.array(y_train1)
+    x_train2, y_train2 = np.array(x_train2), np.array(y_train2)
+
+    # Reshape input data to 3D format (samples, timesteps, features)
+    x_train1 = np.reshape(x_train1, (x_train1.shape[0], x_train1.shape[1], n_features))
+    x_train2 = np.reshape(x_train2, (x_train2.shape[0], x_train2.shape[1], n_features))
+
+    # Train the model (feel free to experiment with different architectures)
+    model1 = create_model(x_train1, y_train1)
+    model2 = create_model(x_train2, y_train2)
+
+    # ---- User Interface for Prediction ----
+    prediction_days = st.slider('Number of Days to Predict', 1, 30, 7)
+
+    # Make predictions
+    predicted_prices1 = []
+    predicted_prices2 = []
+
+    for i in range(prediction_days):
+        # Get the last 'look_back' days of data for each ticker
+        last_n_days1 = scaled_data1[-look_back:]
+        last_n_days2 = scaled_data2[-look_back:]
+
+        # Reshape input data to 3D format (samples, timesteps, features)
+        x_test1 = np.array([last_n_days1]).reshape(1, look_back, n_features) 
+        x_test2 = np.array([last_n_days2]).reshape(1, look_back, n_features)
+
+        # Predict future prices
+        predicted_price1 = model1.predict(x_test1)
+        predicted_price2 = model2.predict(x_test2)
+
+        # Inverse scale the predicted prices
+        predicted_price1 = scaler_1.inverse_transform(predicted_price1)
+        predicted_price2 = scaler_2.inverse_transform(predicted_price2)
+
+        # Append the predicted prices to the lists
+        predicted_prices1.append(predicted_price1.flatten()[0])
+        predicted_prices2.append(predicted_price2.flatten()[0])
+
+        # Update data for the next day's prediction
+        scaled_data1 = np.append(scaled_data1[1:], predicted_price1.flatten())
+        scaled_data2 = np.append(scaled_data2[1:], predicted_price2.flatten())
+
+    # Create a DataFrame for predicted prices
+    prediction_df = pd.DataFrame({'Predicted Price (' + ticker1 + ')': predicted_prices1,
+                                  'Predicted Price (' + ticker2 + ')': predicted_prices2},
+                                 index=pd.date_range(start=data1.index[-1] + pd.Timedelta(days=1),
+                                                      periods=prediction_days))
+
+    # Display the predicted prices
+    st.write("Predicted Prices for the Next", prediction_days, "Days:")
+    st.dataframe(prediction_df)
+
+    # Get current prices
+    try:
+        current_price1 = yf.download(ticker1, period="1d")['Close'][0]
+        current_price2 = yf.download(ticker2, period="1d")['Close'][0]
+    except Exception as e:
+        st.error(f"Error fetching current prices: {e}")
+        return
+
+    # Display current prices
+    st.write(f"**Current Price ({ticker1}): ** {current_price1:.2f}")
+    st.write(f"**Current Price ({ticker2}): ** {current_price2:.2f}")
+
+
+    # Calculate prediction errors for each day
+    prediction_df['Error (' + ticker1 + ')'] = prediction_df['Predicted Price (' + ticker1 + ')'] - current_price1
+    prediction_df['Error (' + ticker2 + ')'] = prediction_df['Predicted Price (' + ticker2 + ')'] - current_price2 
+
+    
+
+    # Display the prediction errors along with predicted prices
+    st.write("Predicted Prices and Errors for the Next", prediction_days, "Days:")
+    st.dataframe(prediction_df)
+
+
+

macd_prices.py

@@ -0,0 +1,186 @@
+import streamlit as st
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from sklearn.preprocessing import StandardScaler
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense, Conv1D, MaxPooling1D, Flatten
+
+def load_and_display_macd(ticker1, ticker2, user_inputs):
+    """
+    Fetches historical data, calculates MACD and moving averages based on user input,
+    trains LSTM-CNN models (for each ticker), and displays charts and predictions.
+
+    Args:
+        ticker1 (str): First ticker symbol.
+        ticker2 (str): Second ticker symbol.
+        user_inputs (dict): Dictionary containing user-specified parameters
+            - price_column (str): "High", "Low", "Close", or "Open" (default: "Close")
+            - ema_fast (int): Span for fast EMA (default: 12)
+            - ema_slow (int): Span for slow EMA (default: 26)
+            - signal_span (int): Span for signal EMA (default: 9)
+    """
+
+    try:
+        data1 = yf.download(ticker1, period="3mo", interval="1h")
+        data2 = yf.download(ticker2, period="3mo", interval="1h")
+    except Exception as e:
+        st.error(f"Error fetching data: {e}")
+        return
+
+    # Get user-specified parameters (with defaults)
+    price_column = user_inputs.get("price_column", "Close")
+    ema_fast = user_inputs.get("ema_fast", 12)
+    ema_slow = user_inputs.get("ema_slow", 26)
+    signal_span = user_inputs.get("signal_span", 9)
+
+    # Calculate MACD and Signal based on user input
+    data1['ema_fast'] = data1[price_column].ewm(span=ema_fast, adjust=False).mean()
+    data1['ema_slow'] = data1[price_column].ewm(span=ema_slow, adjust=False).mean()
+    data1['MACD'] = data1['ema_fast'] - data1['ema_slow']
+    data1['Signal'] = data1['MACD'].ewm(span=signal_span, adjust=False).mean()
+    data1['Histogram'] = data1['MACD'] - data1['Signal']
+
+    data2['ema_fast'] = data2[price_column].ewm(span=ema_fast, adjust=False).mean()
+    data2['ema_slow'] = data2[price_column].ewm(span=ema_slow, adjust=False).mean()
+    data2['MACD'] = data2['ema_fast'] - data2['ema_slow']
+    data2['Signal'] = data2['MACD'].ewm(span=signal_span, adjust=False).mean()
+    data2['Histogram'] = data1['MACD'] - data2['Signal']
+
+    # Create candlestick charts with EMAs
+    fig1_candlestick = go.Figure()
+    fig1_candlestick.add_trace(go.Candlestick(x=data1.index,
+                                             open=data1['Open'],
+                                             high=data1['High'],
+                                             low=data1['Low'],
+                                             close=data1['Close'],
+                                             name=f'{ticker1} Candlestick'))
+    fig1_candlestick.add_trace(go.Scatter(x=data1.index, y=data1['ema_fast'], name=f'{ticker1} {ema_fast}-EMA', line=dict(color='red')))
+    fig1_candlestick.add_trace(go.Scatter(x=data1.index, y=data1['ema_slow'], name=f'{ticker1} {ema_slow}-EMA', line=dict(color='blue')))
+    fig1_candlestick.update_layout(title=f'{ticker1} Candlestick Chart with EMAs')
+
+    fig2_candlestick = go.Figure()
+    fig2_candlestick.add_trace(go.Candlestick(x=data2.index,
+                                             open=data2['Open'],
+                                             high=data2['High'],
+                                             low=data2['Low'],
+                                             close=data2['Close'],
+                                             name=f'{ticker2} Candlestick'))
+    fig2_candlestick.add_trace(go.Scatter(x=data2.index, y=data2['ema_fast'], name=f'{ticker2} {ema_fast}-EMA', line=dict(color='red')))
+    fig2_candlestick.add_trace(go.Scatter(x=data2.index, y=data2['ema_slow'], name=f'{ticker2} {ema_slow}-EMA', line=dict(color='blue')))
+    fig2_candlestick.update_layout(title=f'{ticker2} Candlestick Chart with EMAs')
+
+    # Create line chart for MACD and Signal
+    fig1_macd = go.Figure()
+    fig1_macd.add_trace(go.Histogram(x=data1['Histogram'], name=f'{ticker1} MACD Histogram', opacity=0.5))
+    fig1_macd.add_trace(go.Scatter(x=data1.index, y=data1['MACD'], name=f'{ticker1} MACD', line=dict(color='red')))
+    fig1_macd.add_trace(go.Scatter(x=data1.index, y=data1['Signal'], name=f'{ticker1} Signal', line=dict(color='green')))
+    fig1_macd.update_layout(title=f'{ticker1} MACD and Signal & Histogram')
+
+    fig2_macd = go.Figure()
+    fig2_macd.add_trace(go.Histogram(x=data2['Histogram'], name=f'{ticker2} MACD Histogram', opacity=0.5))
+    fig2_macd.add_trace(go.Scatter(x=data2.index, y=data2['MACD'], name=f'{ticker2} MACD', line=dict(color='red')))
+    fig2_macd.add_trace(go.Scatter(x=data2.index, y=data2['Signal'], name=f'{ticker2} Signal', line=dict(color='green')))
+    fig2_macd.update_layout(title=f'{ticker2} MACD and Signal & Histogram')
+
+    # Display charts
+    col1, col2 = st.columns(2)
+    with col1:
+        st.plotly_chart(fig1_candlestick)
+        st.plotly_chart(fig1_macd)
+    with col2:
+        st.plotly_chart(fig2_candlestick)
+        st.plotly_chart(fig2_macd)
+
+    # Create features and target for training
+    features_1 = data1[['ema_fast', 'ema_slow', 'MACD', 'Signal']]
+    target_1 = data1[price_column]
+
+    features_2 = data2[['ema_fast', 'ema_slow', 'MACD', 'Signal']]
+    target_2 = data2[price_column]
+
+    # Split data into training and testing sets (80/20 split)
+    train_size_1 = int(len(data1) * 0.8)
+    train_data_1, test_data_1 = features_1.iloc[:train_size_1], features_1.iloc[train_size_1:]
+    train_target_1, test_target_1 = target_1.iloc[:train_size_1], target_1.iloc[train_size_1:]
+
+    train_size_2 = int(len(data2) * 0.8)
+    train_data_2, test_data_2 = features_2.iloc[:train_size_2], features_2.iloc[train_size_2:]
+    train_target_2, test_target_2 = target_2.iloc[:train_size_2], target_2.iloc[train_size_2:]
+
+    # Standardize data (using StandardScaler)
+    scaler = StandardScaler()
+    scaled_train_data_1 = scaler.fit_transform(train_data_1)
+    scaled_test_data_1 = scaler.transform(test_data_1)
+
+    scaled_train_data_2 = scaler.fit_transform(train_data_2)
+    scaled_test_data_2 = scaler.transform(test_data_2)
+
+    # Reshape data for LSTM-CNN input (samples, time steps, features)
+    train_data_reshaped_1 = scaled_train_data_1.reshape(train_data_1.shape[0], train_data_1.shape[1], 1)
+    test_data_reshaped_1 = scaled_test_data_1.reshape(test_data_1.shape[0], test_data_1.shape[1], 1)
+
+    train_data_reshaped_2 = scaled_train_data_2.reshape(train_data_2.shape[0], train_data_2.shape[1], 1)
+    test_data_reshaped_2 = scaled_test_data_2.reshape(test_data_2.shape[0], test_data_2.shape[1], 1)
+
+    # Create LSTM-CNN models
+    model1 = Sequential()
+    model1.add(Conv1D(filters=32, kernel_size=3, activation='relu', input_shape=(train_data_reshaped_1.shape[1], 1)))
+    model1.add(MaxPooling1D(pool_size=2))
+    model1.add(LSTM(50, return_sequences=True))
+    model1.add(LSTM(50))
+    # Add a Flatten layer before the Dense layer
+    model1.add(Flatten())
+    model1.add(Dense(features_1.shape[1]))  # Use the number of features from training data
+    model1.compile(loss='mse', optimizer='adam')
+
+    model2 = Sequential()
+    model2.add(Conv1D(filters=32, kernel_size=3, activation='relu', input_shape=(train_data_reshaped_2.shape[1], 1)))
+    model2.add(MaxPooling1D(pool_size=2))
+    model2.add(LSTM(50, return_sequences=True))
+    model2.add(LSTM(50))
+    model2.add(Flatten())
+    model2.add(Dense(features_2.shape[1]))  # Use the number of features from training data
+    model2.compile(loss='mse', optimizer='adam')
+
+    # Train the models
+    model1.fit(train_data_reshaped_1, train_target_1, epochs=50, batch_size=32, verbose=1)
+    model2.fit(train_data_reshaped_2, train_target_2, epochs=50, batch_size=32, verbose=1)
+
+    # Make predictions
+    predictions_1 = model1.predict(test_data_reshaped_1)
+    predictions_2 = model2.predict(test_data_reshaped_2)
+
+    # Inverse transform predictions
+    predictions_1 = scaler.inverse_transform(predictions_1)
+    predictions_2 = scaler.inverse_transform(predictions_2)
+
+    # Append the predicted prices to the lists
+    last_prediction_1 = predictions_1[-1].reshape(1, -1)
+    predictions_1 = np.concatenate((predictions_1, last_prediction_1), axis=0) 
+
+    last_prediction_2 = predictions_2[-1].reshape(1, -1)
+    predictions_2 = np.concatenate((predictions_2, last_prediction_2), axis=0) 
+
+    # Update data for the next day's prediction
+    # Note: This part might need adjustment based on your specific data handling and prediction logic
+    # Here, we simply append the last prediction to the existing data 
+    # In a real-world scenario, you might need to shift the data and handle windows more carefully
+
+    # Create a DataFrame for predicted prices
+    prediction_df = pd.DataFrame({'Predicted Price (' + ticker1 + ')': predictions_1[:, 0],  # Assuming single-step price prediction
+                                 'Predicted Price (' + ticker2 + ')': predictions_2[:, 0]},
+                                 index=pd.date_range(start=data1.index[-1] + pd.Timedelta(days=1), 
+                                                    periods=len(predictions_1)))
+
+    # Display the predicted prices
+    st.write("Predicted Prices for the Next Day:")
+    st.dataframe(prediction_df)
+
+    # # Display predictions
+    # st.dataframe(predictions_1)
+    # st.dataframe(predictions_2)
+    # st.write("Predictions for Next 3 Days:")
+    # st.write(f"{ticker1}: {predictions_1[-3:]}")
+    # st.write(f"{ticker2}: {predictions_2[-3:]}")

news.py

@@ -0,0 +1,158 @@
+import streamlit as st
+import pandas as pd
+import yfinance as yf
+from textblob import TextBlob
+import re
+from gensim import corpora, models
+from nltk import word_tokenize
+from nltk.corpus import stopwords
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.decomposition import LatentDirichletAllocation
+from nltk import pos_tag
+from nltk.chunk import conlltags2tree, tree2conlltags
+import spacy
+from spacy import displacy
+
+def fetch_news_data(ticker1, ticker2):
+    """
+    Fetches news data for the given tickers from Yahoo Finance.
+    """
+    try:
+        ticker1_data = yf.Ticker(ticker1).news
+        ticker2_data = yf.Ticker(ticker2).news
+        return ticker1_data, ticker2_data
+    except Exception as e:
+        st.error(f"An error occurred while fetching news data: {e}")
+        return fetch_news_data()
+
+def clean_news_data(news_data):
+    """
+    Cleans the news data by removing special characters and extra spaces.
+    """
+    clean_data = []
+    for news in news_data:
+        news_text = re.sub(r"[^\w\s]", "", news['title'])
+        news_text = " ".join(news_text.split())
+        clean_data.append(news_text)
+    return clean_data
+
+def perform_sentiment_analysis(news_data):
+    """
+    Performs sentiment analysis on the given news data using TextBlob.
+    """
+    sentiments = []
+    for news in news_data:
+        analysis = TextBlob(news)
+        sentiments.append(analysis.sentiment.polarity)
+    return sentiments
+
+def classify_sentiment(sentiment_scores):
+    """
+    Classifies sentiment based on the polarity scores.
+    """
+    sentiments = []
+    for score in sentiment_scores:
+        if score > 0:
+            sentiments.append('Positive')
+        elif score < 0:
+            sentiments.append('Negative')
+        else:
+            sentiments.append('Neutral')
+    return sentiments
+
+def topic_modeling(news_data):
+    """
+    Performs topic modeling using LDA.
+    """
+    # Tokenize and remove stop words
+    stop_words = set(stopwords.words('english'))
+    tokenized_news = [word_tokenize(text) for text in news_data]
+    tokenized_news = [[word for word in tokens if not word in stop_words] for tokens in tokenized_news]
+
+    # Create Dictionary and Corpus
+    dictionary = corpora.Dictionary(tokenized_news)
+    corpus = [dictionary.doc2bow(text) for text in tokenized_news]
+
+    # Train LDA model
+    lda_model = models.LdaMulticore(corpus=corpus, id2word=dictionary, num_topics=5, passes=10)
+
+    return lda_model, dictionary
+
+def extract_topics(lda_model, dictionary, num_words=5):
+    """
+    Extracts top topics from the LDA model.
+    """
+    topics = []
+    for idx, topic in lda_model.print_topics(-1):
+        topic_words = " ".join([word for word, _ in dictionary.items() if word in topic])
+        topics.append(f"Topic {idx}: {topic_words}")
+    return topics
+
+def topic_sentiment_analysis(news_data, lda_model, dictionary):
+    """
+    Performs sentiment analysis for each topic.
+    """
+    topic_sentiments = {}
+    for news, topic_idx in zip(news_data, lda_model.get_document_topics()):
+        topic_idx = max(topic_idx, key=lambda x: x[1])[0]
+        if topic_idx not in topic_sentiments:
+            topic_sentiments[topic_idx] = []
+        topic_sentiments[topic_idx].append(TextBlob(news).sentiment.polarity)
+
+    return topic_sentiments
+
+def ner_and_event_detection(news_data):
+    """
+    Performs Named Entity Recognition and Event Detection.
+    """
+    nlp = spacy.load("en_core_web_sm")
+    events = []
+    for news in news_data:
+        doc = nlp(news)
+        entities = [(ent.text, ent.label_) for ent in doc.ents]
+        events.extend(entities)
+
+    return events
+
+def display_results(ticker1, ticker2, ticker1_sentiments, ticker2_sentiments,
+                    ticker1_topics, ticker2_topics, 
+                    ticker1_topic_sentiments=None, ticker2_topic_sentiments=None):
+    """
+    Displays the sentiment analysis results in Streamlit.
+
+    Args:
+        ticker1: The first ticker symbol.
+        ticker2: The second ticker symbol.
+        ticker1_sentiments: A list of sentiment classifications for ticker1.
+        ticker2_sentiments: A list of sentiment classifications for ticker2.
+        ticker1_topics: A list of topics for ticker1.
+        ticker2_topics: A list of topics for ticker2.
+        ticker1_topic_sentiments: A dictionary of topic sentiments for ticker1.
+        ticker2_topic_sentiments: A dictionary of topic sentiments for ticker2.
+    """
+    st.title(f"{ticker1} vs. {ticker2} Sentiment Analysis")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.header(f"{ticker1} Sentiment")
+        st.bar_chart(pd.Series(ticker1_sentiments).value_counts())
+        st.header(f"{ticker1} Topics")
+        for topic in ticker1_topics:
+            st.write(topic)
+        if ticker1_topic_sentiments:
+            st.header(f"{ticker1} Topic Sentiments")
+            for topic_idx, sentiments in ticker1_topic_sentiments.items():
+                st.write(f"Topic {topic_idx}: Average Sentiment = {sum(sentiments) / len(sentiments)}")
+
+    with col2:
+        st.header(f"{ticker2} Sentiment")
+        st.bar_chart(pd.Series(ticker2_sentiments).value_counts())
+        st.header(f"{ticker2} Topics")
+        for topic in ticker2_topics:
+            st.write(topic)
+        if ticker2_topic_sentiments:
+            st.header(f"{ticker2} Topic Sentiments")
+            for topic_idx, sentiments in ticker2_topic_sentiments.items():
+                st.write(f"Topic {topic_idx}: Average Sentiment = {sum(sentiments) / len(sentiments)}")
+
+    return display_results

requirements.txt

@@ -0,0 +1,8 @@
+plotly
+seaborn
+yfinance
+streamlit
+scipy
+scikit-learn
+textblob
+tensorflow