Upload 19 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+faiss_HD/index.faiss filter=lfs diff=lfs merge=lfs -text
+faiss_RD/index.faiss filter=lfs diff=lfs merge=lfs -text

Resources/nse_companies.csv

@@ -0,0 +1,7 @@
+company Name,company_ticker
+Reliance Industries,RELIANCE
+HDFC Bank,HDFCBANK
+Hindustan Unilever,HINDUNILVR
+Bharti Airtel,BHARTIARTL
+Asian Paints,ASIANPAINT
+Maruti Suzuki India,MARUTI

app.py

@@ -0,0 +1,650 @@
+import sys
+import json
+import os
+import requests
+from dotenv import load_dotenv
+import streamlit as st
+import plotly.graph_objects as go
+import plotly.express as px
+from openai import AzureOpenAI
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from dotted_dict import DottedDict
+from langchain_community.vectorstores import Chroma
+from langchain_openai import AzureChatOpenAI, AzureOpenAIEmbeddings
+from py.data_fetch import DataFetch
+from py.handle_files import *
+from py.db_storage import DBStorage
+from langchain.callbacks import get_openai_callback
+from PyPDF2 import PdfReader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain.chains.question_answering import load_qa_chain
+from langchain.prompts import PromptTemplate
+import yfinance as yf
+
+class StockAdviserConfig:
+    def __init__(self):
+        load_dotenv()
+        self.azure_config = {
+            "base_url": os.getenv("AZURE_OPENAI_ENDPOINT"),
+            "embedding_base_url": os.getenv("AZURE_OPENAI_EMBEDDING_ENDPOINT"),
+            "model_deployment": os.getenv("AZURE_OPENAI_MODEL_DEPLOYMENT_NAME"),
+            "model_name": os.getenv("AZURE_OPENAI_MODEL_NAME"),
+            "embedding_deployment": os.getenv("AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME"),
+            "embedding_name": os.getenv("AZURE_OPENAI_EMBEDDING_NAME"),
+            "api-key": os.getenv("AZURE_OPENAI_API_KEY"),
+            "api_version": os.getenv("AZURE_OPENAI_API_VERSION")
+        }
+        self.models = DottedDict()
+
+class StockAdviserUI:
+    def __init__(self):
+        st.set_page_config(page_title="GEN AI Stock Adviser by Karthikeyen", layout="wide",
+                           initial_sidebar_state="expanded")
+        self._setup_css()
+        self._setup_header()
+
+    def _setup_css(self):
+        st.markdown("""
+            <style>
+            .main-header {
+                text-align: center;
+                padding-right: 20px;
+                padding-left: 20px;
+                color: #E9EBED;
+                margin-bottom: 2rem;
+            }
+            .main-header2 {
+                text-align: left;
+                color: #E9EBED;
+            }
+            .column-header {
+                color: #FFFF9E;
+                border-bottom: 2px solid #eee;
+                padding-bottom: 10px;
+                margin-bottom: 1.5rem;
+            }
+            .column-header2 {
+                color: #CEFFFF;
+                padding-top: 5px;
+                padding-bottom: 5px;
+            }
+            .content-section {
+                background-color: #f8f9fa;
+                padding: 15px;
+                border-radius: 5px;
+                margin-top: 10px;
+            }
+            .metric-card {
+                background-color: #1E1E1E;
+                padding: 1rem;
+                border-radius: 8px;
+                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                margin-bottom: 1rem;
+            }
+            .metric-title {
+                font-size: 0.9rem;
+                color: #888;
+                margin-bottom: 0.5rem;
+            }
+            .metric-value {
+                font-size: 1.5rem;
+                font-weight: bold;
+                color: #fff;
+            }
+            </style>
+            """, unsafe_allow_html=True)
+
+    def _setup_header(self):
+        st.markdown("<h1 class='main-header'>RAG Stock Analysis</h1>", unsafe_allow_html=True)
+        with st.expander("Available Historical Demo Companies"):
+            st.markdown("""
+                For Demo purpose, historical data is available only for the below companies:
+                - Reliance Industries (RELIANCE)
+                - HDFC Bank (HDFCBANK)
+                - Hindustan Unilever (HINDUNILVR)
+                - Bharti Airtel (BHARTIARTL)
+                - Asian Paints (ASIANPAINT)
+                - Maruti Suzuki India (MARUTI)
+            """, unsafe_allow_html=True)
+
+class StockDataVisualizer:
+    @staticmethod
+    def create_price_chart(df, symbol):
+        fig = go.Figure()
+        
+        fig.add_trace(go.Candlestick(
+            x=df.index,
+            open=df['Open'],
+            high=df['High'],
+            low=df['Low'],
+            close=df['Close'],
+            name='OHLC'
+        ))
+        
+        fig.update_layout(
+            title=f'{symbol} Stock Price Movement',
+            yaxis_title='Stock Price (INR)',
+            template='plotly_dark',
+            xaxis_rangeslider_visible=False,
+            height=500
+        )
+        
+        return fig
+
+    @staticmethod
+    def create_volume_chart(df, symbol):
+        fig = go.Figure()
+        
+        fig.add_trace(go.Bar(
+            x=df.index,
+            y=df['Volume'],
+            name='Volume',
+            marker_color='rgba(0, 150, 255, 0.6)'
+        ))
+        
+        fig.update_layout(
+            title=f'{symbol} Trading Volume',
+            yaxis_title='Volume',
+            template='plotly_dark',
+            height=300
+        )
+        
+        return fig
+
+    @staticmethod
+    def create_sentiment_gauge(sentiment_score):
+        fig = go.Figure(go.Indicator(
+            mode="gauge+number",
+            value=sentiment_score,
+            domain={'x': [0, 1], 'y': [0, 1]},
+            gauge={
+                'axis': {'range': [-1, 1]},
+                'bar': {'color': "rgba(0, 150, 255, 0.6)"},
+                'steps': [
+                    {'range': [-1, -0.25], 'color': "red"},
+                    {'range': [-0.25, 0.25], 'color': "yellow"},
+                    {'range': [0.25, 1], 'color': "green"}
+                ]
+            },
+            title={'text': "Sentiment Score"}
+        ))
+        
+        fig.update_layout(
+            template='plotly_dark',
+            height=250
+        )
+        
+        return fig
+
+class StockAdviser:
+    def __init__(self):
+        self.config = StockAdviserConfig()
+        self.ui = StockAdviserUI()
+        self.visualizer = StockDataVisualizer()
+        self.client = AzureOpenAI(
+            azure_endpoint=self.config.azure_config["base_url"],
+            api_key=self.config.azure_config["api-key"],
+            api_version="2024-02-01"
+        )
+
+
+    def create_models(self):
+        print("creating models")
+        llm = AzureChatOpenAI(
+            temperature=0,
+            api_key=self.config.azure_config["api-key"],
+            openai_api_version=self.config.azure_config["api_version"],
+            azure_endpoint=self.config.azure_config["base_url"],
+            model=self.config.azure_config["model_deployment"],
+            validate_base_url=False
+        )
+        embedding_model = AzureOpenAIEmbeddings(
+            api_key=self.config.azure_config["api-key"],
+            openai_api_version=self.config.azure_config["api_version"],
+            azure_endpoint=self.config.azure_config["embedding_base_url"],
+            model=self.config.azure_config["embedding_deployment"]
+        )
+        self.config.models.llm = llm
+        self.config.models.embedding_model = embedding_model
+        return self.config.models
+
+    def get_symbol(self, user_question):
+        qna_system_message = """
+        You are an assistant to a financial services firm who finds the 'nse company symbol' (assigned to the company in the provided stock market)) of the company in the question provided.
+
+        User questions will begin with the token: ###Question.
+
+        Please find the 'nse company symbol' of the company in the question provided. In case of an invalid company, return "NOTICKER".
+        
+        Response format:
+        {nse company symbol}
+        
+        Do not mention anything about the context in your final answer. Stricktly respond only the company symbol.
+        """
+
+        qna_user_message_template = """
+        ###Question
+        {question}
+        """
+
+        prompt = [
+            {'role': 'system', 'content': qna_system_message},
+            {'role': 'user', 'content': qna_user_message_template.format(question=user_question)}
+        ]
+
+        try:
+            response = self.client.chat.completions.create(
+                model=self.config.azure_config["model_name"],
+                messages=prompt,
+                temperature=0
+            )
+            cmp_tkr = response.choices[0].message.content.strip()
+        except Exception as e:
+            cmp_tkr = f'Sorry, I encountered the following error: \n {e}'
+            st.write("Reply: ", cmp_tkr)
+            return
+        print(cmp_tkr)
+        return cmp_tkr
+
+
+    def process_historical_data(self, user_question):
+        cmp_tr = self.get_symbol(user_question)
+        
+        # Initialize ChromaDB Database
+        chroma_db = DBStorage()
+        FAISS_DB_PATH = os.path.join(os.getcwd(), "Stock Sentiment Analysis", "faiss_HD")
+        chroma_db.load_vectors(FAISS_DB_PATH)
+        context_for_query = chroma_db.get_context_for_query(cmp_tr, k=5)
+        
+        sentiment_response = self._get_sentiment_analysis(context_for_query, cmp_tr)
+        self._display_sentiment(sentiment_response)
+        
+        return cmp_tr
+    
+    def display_charts(self,cmp_tr,sentiment_response):
+        sentiment = self._extract_between(sentiment_response, "Overall Sentiment:", "Overall Justification:").strip()
+        
+        days = 365
+        
+        print(f"\nFetching {days} days of stock data for {cmp_tr}...")
+        df, analysis = self.get_nse_stock_data(cmp_tr, days)
+        
+        print(analysis)
+        
+        # Create metrics cards
+        col1, col2, col3 = st.columns(3)
+        
+        # Simulate some metric data (replace with real data in production)
+        with col1:
+            self._create_metric_card(f"52-Week High on {analysis['week_52_high_date']}", 
+                                     f"₹{analysis['week_52_high']:,.2f}", 
+                                     self.format_percentage(analysis['pct_from_52w_high']))
+        with col2:
+            self._create_metric_card(f"52-Week Low on {analysis['week_52_low_date']}",  
+                                     f"₹{analysis['week_52_low']:,.2f}", 
+                                     self.format_percentage(analysis['pct_from_52w_low']))
+        with col3:
+            self._create_metric_card("Average Volume", 
+                                     f"{int(analysis['avg_volume']):,}", 
+                                     f"{self.format_percentage(analysis['volume_pct_diff'])}")
+                
+        # Display price chart
+        st.plotly_chart(self.visualizer.create_price_chart(df, cmp_tr))
+        
+        # Display volume chart
+        st.plotly_chart(self.visualizer.create_volume_chart(df, cmp_tr))
+        
+        # Display sentiment gauge (simulate sentiment score)
+        # Generating random score for Demo purpose
+        if sentiment == "Negative":
+            sentiment_score = np.random.uniform(-1, -0.75)
+        elif sentiment == "Neutral":
+            sentiment_score = np.random.uniform(-0.75, 0.25)
+        elif sentiment == "Positive":
+            sentiment_score = np.random.uniform(0.25, 1)
+        else:
+            sentiment_score = 0
+            
+            
+        st.plotly_chart(self.visualizer.create_sentiment_gauge(sentiment_score))
+    
+    def get_nse_stock_data(self,symbol, days):
+        """
+        Fetch stock data and perform extended analysis including 52-week highs/lows
+        and volume comparisons.
+        
+        Args:
+            symbol (str): NSE stock symbol (e.g., 'RELIANCE.NS')
+        
+        Returns:
+            tuple: (DataFrame of daily data, dict of analysis metrics)
+        """
+        try:
+            # Add .NS suffix if not present
+            if not symbol.endswith('.NS'):
+                symbol = f"{symbol}.NS"
+            
+            # Create Ticker object and fetch 1 year of data
+            ticker = yf.Ticker(symbol)
+            
+            # Get last 90 days of data
+            end_date = datetime.now()
+            start_date = end_date - timedelta(days=days)
+            df_90d = ticker.history(start=start_date, end=end_date)
+            
+            # Get 1 year of data for 52-week analysis
+            start_date_52w = end_date - timedelta(days=365)
+            df_52w = ticker.history(start=start_date_52w, end=end_date)
+            
+            # Create main DataFrame with 90-day data
+            df = pd.DataFrame({
+                'Open': df_90d['Open'],
+                'High': df_90d['High'],
+                'Low': df_90d['Low'],
+                'Close': df_90d['Close'],
+                'Volume': df_90d['Volume']
+            }, index=df_90d.index)
+            
+            # Round numerical values
+            df[['Open', 'High', 'Low', 'Close']] = df[['Open', 'High', 'Low', 'Close']].round(2)
+            df['Volume'] = df['Volume'].astype(int)
+            
+            # Get current price (latest close)
+            current_price = df['Close'].iloc[-1]
+            
+            # Calculate 52-week metrics
+            week_52_high = df_52w['High'].max()
+            week_52_low = df_52w['Low'].min()
+            
+            # Calculate percentage differences
+            pct_from_52w_high = ((current_price - week_52_high) / week_52_high) * 100
+            pct_from_52w_low = ((current_price - week_52_low) / week_52_low) * 100
+            
+            # Volume analysis
+            current_volume = df['Volume'].iloc[-1]
+            avg_volume = df_52w['Volume'].mean()
+            volume_pct_diff = ((current_volume - avg_volume) / avg_volume) * 100
+                    
+            # Find dates of 52-week high and low
+            high_date = df_52w[df_52w['High'] == week_52_high].index[0].strftime('%Y-%m-%d')
+            low_date = df_52w[df_52w['Low'] == week_52_low].index[0].strftime('%Y-%m-%d')
+        
+            # Create analysis metrics dictionary
+            analysis = {
+                'current_price': current_price,
+                'week_52_high': week_52_high,
+                'week_52_high_date': high_date,
+                'week_52_low': week_52_low,
+                'week_52_low_date': low_date,
+                'pct_from_52w_high': pct_from_52w_high,
+                'pct_from_52w_low': pct_from_52w_low,
+                'current_volume': current_volume,
+                'avg_volume': avg_volume,
+                'volume_pct_diff': volume_pct_diff
+            }
+            
+            print(analysis)
+            
+            return df, analysis
+        
+        except Exception as e:
+            print(f"Error fetching data: {str(e)}")
+            return None, None
+
+    def format_percentage(self, value):
+        """Format percentage with + or - sign"""
+        return f"+{value:.2f}%" if value > 0 else f"{value:.2f}%"
+
+
+    def process_realtime_data(self, cmp_tr):
+        if cmp_tr == "NOTICKER":
+            st.write("No valid company in the query.")
+            return
+
+        data_fetch = DataFetch()
+        query_context = []
+        
+        # Create a placeholder for the current source
+        source_status = st.empty()
+        
+        # Collect data from various sources
+        data_sources = [
+            ("Reddit", data_fetch.collect_reddit_data),
+            ("YouTube", data_fetch.collect_youtube_data),
+            ("Tumblr", data_fetch.collect_tumblr_data),
+            ("Google News", data_fetch.collect_google_news),
+            ("Financial Times", data_fetch.collect_financial_times),
+            ("Bloomberg", data_fetch.collect_bloomberg),
+            ("Reuters", data_fetch.collect_reuters)
+        ]
+        
+        st_status = ""
+
+        for source_name, collect_func in data_sources:
+            st_status = st_status.replace("Currently fetching", "Fetched") + f"📡 Currently fetching data from: {source_name} \n \n"
+            source_status.write(st_status, unsafe_allow_html=True)
+            print(f"Collecting {source_name} Data")
+            query_context.extend(collect_func(cmp_tr))
+
+        st_status = st_status.replace("Currently fetching", "Fetched") +  "📡 Currently fetching data from: Serper - StockNews, Yahoo Finance, Insider Monkey, Investor's Business Daily, etc."
+        source_status.write(st_status, unsafe_allow_html=True)
+        print("Collecting Serper Data")
+        query_context.extend(data_fetch.search_news(cmp_tr, 100))
+
+        # Process collected data
+        db_store = DBStorage()
+        FAISS_DB_PATH = os.path.join(os.getcwd(), "Stock Sentiment Analysis", "faiss_RD")
+        db_store.embed_vectors(to_documents(query_context), FAISS_DB_PATH)
+        
+        db_store.load_vectors(FAISS_DB_PATH)
+        context_for_query = db_store.get_context_for_query(cmp_tr, k=5)
+        
+        sentiment_response = self._get_sentiment_analysis(context_for_query, cmp_tr, is_realtime=True)
+        self._display_sentiment(sentiment_response)
+        
+        # Clear the status message after all sources are processed
+        source_status.empty()
+        
+        return sentiment_response
+
+
+    def _create_metric_card(self, title, value, change):
+        st.markdown(f"""
+            <div class="metric-card">
+                <div class="metric-title">{title}</div>
+                <div class="metric-value">{value}</div>
+                <div style="color: {'green' if float(change.strip('%')) > 0 else 'red'}">
+                    {change}
+                </div>
+            </div>
+        """, unsafe_allow_html=True)
+
+    def _get_sentiment_analysis(self, context, cmp_tr, is_realtime=False):
+        system_message = self._get_system_prompt(is_realtime)
+        user_message = f"""
+        ###Context
+        Here are some documents that are relevant to the question mentioned below.
+        {context}
+
+        ###Question
+        {cmp_tr}
+        """
+
+        try:
+            response = self.client.chat.completions.create(
+                model=self.config.azure_config["model_name"],
+                messages=[
+                    {'role': 'system', 'content': system_message},
+                    {'role': 'user', 'content': user_message}
+                ],
+                temperature=0
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            return f'Sorry, I encountered the following error: \n {e}'
+
+    def _display_sentiment(self, prediction):
+        sentiment = self._extract_between(prediction, "Overall Sentiment:", "Overall Justification:").strip()
+        print("Sentiment: "+ sentiment)
+        print(prediction)
+        if sentiment == "Positive":
+            st.success("Positive : Go Ahead...!")
+        elif sentiment == "Negative":
+            st.warning("Negative : Don't...!")
+        elif sentiment == "Neutral":
+            st.info("Neutral : Need to Analyse further")
+        st.write(prediction, unsafe_allow_html=True)
+
+    @staticmethod
+    def _extract_between(text: str, start: str, end: str) -> str:
+        try:
+            start_pos = text.find(start)
+            if start_pos == -1:
+                return ""
+            start_pos += len(start)
+            end_pos = text.find(end, start_pos)
+            if end_pos == -1:
+                return ""
+            return text[start_pos:end_pos]
+        except (AttributeError, TypeError):
+            return ""
+
+    @staticmethod
+    def _get_system_prompt(is_realtime):
+        """
+        Returns the appropriate system prompt based on whether it's realtime or historical data analysis.
+        
+        Args:
+            is_realtime (bool): Flag indicating if this is for realtime data analysis
+        
+        Returns:
+            str: The complete system prompt for the sentiment analysis
+        """
+        base_prompt = """
+        You are an assistant to a financial services firm who answers user queries on Stock Investments.
+        User input will have the context required by you to answer user questions.
+        This context will begin with the token: ###Context.
+        The context contains references to specific portions of a document relevant to the user query.
+
+        User questions will begin with the token: ###Question.
+        
+        First, find the 'nse company symbol' of the related company in the question provided.
+        Your task is to perform sentiment analysis on the content part of each documents provided in the Context, which discuss a company identified by its 'nse company symbol'. The goal is to determine the overall sentiment expressed across all documents and provide an overall justification. Based on the sentiment analysis, give a recommendation on whether the company's stock should be purchased.
+
+        Step-by-Step Instructions:
+            1. See if the question is "NOTICKER". If so, give response and don't proceed.
+            2. If the company in question is not found in the context, give the corresponding response and don't proceed.
+            3. Read the Context: Carefully read the content parts of each document provided in the list of Documents.
+            4. Determine Overall Sentiment: Analyze the sentiment across all documents and categorize the overall sentiment as Positive, Negative, or Neutral.
+            5. Provide Overall Justification: Summarize the key points from all documents to justify the overall sentiment.
+            6. Stock Advice: Based on the overall sentiment and justification, provide a recommendation on whether the company's stock should be purchased.
+
+        Example Analysis:
+            Context: 
+                [Document(metadata={'platform': 'Moneycontrol', 'company': 'ASIANPAINT', 'ingestion_timestamp': '2024-10-25T17:13:42.970099', 'word_count': 134}, page_content="{'title': 'Asian Paints launches Neo Bharat Latex Paint to tap on booming demand', 'content': 'The company, which is the leading player in India, touts the new segment to being affordable, offering over 1000 shades for consumers.'}"), Document(metadata={'platform': 'MarketsMojo', 'company': 'ASIANPAINT', 'ingestion_timestamp': '2024-10-25T17:13:42.970099', 'word_count': 128}, page_content="{'title': 'Asian Paints Ltd. Stock Performance Shows Positive Trend, Outperforms Sector by 0.9%', 'content': 'Asian Paints Ltd., a leading player in the paints industry, has seen a positive trend in its stock performance on July 10, 2024.'}"), Document(metadata={'platform': 'Business Standard', 'company': 'ASIANPAINT', 'ingestion_timestamp': '2024-10-25T17:13:42.970099', 'word_count': 138}, page_content="{'title': 'Asian Paints, Indigo Paints, Kansai gain up to 5% on falling oil prices', 'content': 'Shares of paint companies were trading higher on Wednesday, rising up to 5 per cent on the BSE, on the back of a fall in crude oil prices.'}")]
+        """
+
+        if is_realtime:
+            response_format = """
+        Response Formats:
+        Only If the Question is 'NOTICKER':
+            No valid company in the query.
+        
+        Else, If the context does not have relevent data for the company:
+            Respond "Company {Company name} {nse company symbol}({symbol}) details not found in the RealTime Data".
+        """
+        else:
+            response_format = """
+        Response Formats:
+        If the Question value is "NOTICKER":
+            No valid company in the query.
+        
+        If the context does not have relevent data for the company (Question value):
+            Respond "Company {Company name} {nse company symbol}({symbol}) details not found in the Historical Data".
+        """
+
+        common_format = """
+        else, If the content parts of context has relevent data:
+        Overall Sentiment: [Positive/Negative/Neutral]  <line break>
+        Overall Justification: [Detailed analysis of why the sentiment was chosen, summarizing key points from the documents]  <line break>
+        Stock Advice: [Clear recommendation on whether to purchase the stock, based on the sentiment analysis and justification]
+        
+        Please follow the steps to analyze the sentiment of each document's content; and strictly follow exact structure illustrated in above example response to provide an overall sentiment, justification and give stock purchase advice. Provide only Overall response, don't provide documentwise response or any note. Decorate the response with html/css tags.
+        """
+
+        return base_prompt + response_format + common_format
+
+
+def main():
+    adviser = StockAdviser()
+    
+
+    # Create sidebar for filters and settings
+    st.logo(
+    "https://cdn.shopify.com/s/files/1/0153/8513/3156/files/info_omac.png?v=1595717396",
+    size="large"
+    )
+
+    with st.sidebar:
+    # About the Application
+        st.markdown("""
+            <div style="background-color: #2d2d2d; padding: 20px; border-radius: 10px; box-shadow: 0 4px 8px rgba(255, 255, 255, 0.1);">
+                <h2 style="color: #e6e6e6; text-align: Left;">About the Application</h2>
+                <p style="font-size: 16px; color: #cccccc; line-height: 1.6; text-align: justify;">
+                    This application provides investment managers with daily insights into social media and news sentiment surrounding specific stocks and companies. 
+                    By analyzing posts and articles across major platforms such as <strong>Reddit</strong>, <strong>YouTube</strong>, <strong>Tumblr</strong>, <strong>Google News</strong>, 
+                    <strong>Financial Times</strong>, <strong>Bloomberg</strong>, <strong>Reuters</strong>, and <strong>Wall Street Journal</strong> (WSJ), it detects shifts 
+                    in public and media opinion that may impact stock performance.
+                </p>
+                <p style="font-size: 16px; color: #cccccc; line-height: 1.6; text-align: justify;">
+                    Additionally, sources like <strong>Serper</strong> provide data from <strong>StockNews</strong>, <strong>Yahoo Finance</strong>, <strong>Insider Monkey</strong>, 
+                    <strong>Investor's Business Daily</strong>, and others. Using advanced AI techniques, the application generates a sentiment report that serves as a leading indicator, 
+                    helping managers make informed, timely adjustments to their positions. With daily updates and historical trend analysis, it empowers users to stay ahead in a fast-paced, 
+                    sentiment-driven market.
+                </p>
+            </div>
+        
+        """, unsafe_allow_html=True)
+        # Sidebar Footer (Floating Footer)
+        st.sidebar.markdown("""
+            <div style="position: fixed; bottom: 5px; padding: 5px; background-color: #1f1f1f; border-radius: 5px; text-align: left;">
+                <p style="color: #cccccc; font-size: 14px;">
+                    Developed by: <a href="https://www.linkedin.com/in/karthikeyen92/" target="_blank" style="color: #4DA8DA; text-decoration: none;">Karthikeyen Packirisamy</a>
+                </p>
+            </div>
+        """, unsafe_allow_html=True)
+                    
+                    
+
+    # Main content
+    cmp_tr = "NOTICKER"
+    st.header("Ask a question")
+    user_question = st.text_input("Ask a stock advice related question", key="user_question")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("<h2 class='column-header'>Historical Analysis</h2>", unsafe_allow_html=True)
+        with st.container():
+            if user_question:
+                cmp_tr = adviser.process_historical_data(user_question)
+
+    with col2:
+        st.markdown("<h2 class='column-header'>Real-Time Analysis</h2>", unsafe_allow_html=True)
+        with st.container():
+            if user_question:
+                sentiment_response = adviser.process_realtime_data(cmp_tr)
+      
+    if (str(cmp_tr) is not "NOTICKER"):            
+        with st.container():
+            if user_question:
+                adviser.display_charts(cmp_tr,sentiment_response)
+
+    st.markdown("---")
+    st.markdown("<p style='text-align: center; color: #666;'>© 2024 EY</p>", unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

faiss_HD/index.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21f90f9597d9b256565bc742f8759189c447bf5be0c895f1eab5fd101c4a862e
+size 5394477

faiss_HD/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f71f9ccd673b0e19777d7b506ee2aad6681830765ea9fb033e7ff5acf5ee142
+size 366007

faiss_RD/index.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d7be7becea5e20fea3eeae7e02278e46d35eec95ebb0ec718e1492af86384a2
+size 1425453

faiss_RD/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:668a312f77a5e10ddf4a339b4ce66c27f824bbd2c017105562ed87115d9c1331
+size 84595

files/analysed_data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e39af0e4aa0d68a1913fe71de5940e5ee6ca955823fc474ad2f442ffa2b26811
+size 794212

files/ingested_data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8e765ea9bb535c56374bc8cc5a92b12ba6ee19f60bacca6aac7bf9a0fb638dd
+size 737464

files/labels.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0478b55762921f2d931893f59493062499fb59113770ce8a61cbe80980f0339
+size 48

files/social_media_data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df4e596eac08af0ff840ee263840b5c49285e6288947fb38fa1dcbece28a03a2
+size 670285

main.py

@@ -0,0 +1,43 @@
+import warnings
+from py.data_fetch import * 
+from py.handle_files import *
+from py.db_storage import *
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+from typing import List, Dict, Any
+warnings.filterwarnings("ignore")
+
+stock="nse"
+# stock="nasdaq"
+
+# Collect Data    
+data_fetch = DataFetch()
+data_fetch.load_company_list("Stock Sentiment Analysis/Resources/"+stock+"_companies.csv")
+social_media_data = data_fetch.collect_data()
+
+# Save collected data to Files
+create_files(social_media_data)
+
+# Fetch saved Social Media Data
+social_media_document = fetch_social_media_data()
+print(len(social_media_document))
+
+# Samples `n` entries for each unique `"platform"` and `"company"` metadata combination from the input `Document[]`.
+social_media_document_samples = sample_documents(social_media_document, 20)
+print(len(social_media_document_samples))
+
+# Delete and clear any ChromaDB databases
+clear_db()
+
+# Initialise ChromaDB Database
+chroma_db = DBStorage()
+
+# Create chunks and embeddings in the database
+FAISS_DB_PATH = os.path.join(os.getcwd(), "Stock Sentiment Analysis", "faiss_HD")
+chroma_db.embed_vectors(social_media_document_samples, FAISS_DB_PATH)
+
+
+        
+
+

py/data_fetch.py

@@ -0,0 +1,236 @@
+import os
+from datetime import datetime, timedelta
+from typing import Dict, List
+import pandas as pd
+import tweepy
+import praw
+import googleapiclient.discovery
+import pytumblr
+from gnews import GNews
+import requests
+from bs4 import BeautifulSoup
+import time
+import math
+
+
+class DataFetch:
+    def __init__(self):
+        # Load company list and set date range
+        self.end_date = datetime.now()
+        self.start_date = self.end_date - timedelta(days=1)
+
+        # Initialize API clients
+        self.tumblr_client = pytumblr.TumblrRestClient(
+            os.getenv("TUMBLR_CONSUMER_KEY"),
+            os.getenv("TUMBLR_CONSUMER_SECRET"),
+            os.getenv("TUMBLR_OAUTH_TOKEN"),
+            os.getenv("TUMBLR_OAUTH_SECRET")
+        )
+        
+        twitter_auth = tweepy.OAuthHandler(os.getenv("TWITTER_API_KEY"), os.getenv("TWITTER_API_SECRET"))
+        twitter_auth.set_access_token(os.getenv("TWITTER_ACCESS_TOKEN"), os.getenv("TWITTER_ACCESS_TOKEN_SECRET"))
+        self.twitter_api = tweepy.API(twitter_auth)
+
+        self.reddit = praw.Reddit(
+            client_id=os.getenv("REDDIT_CLIENT_ID"),
+            client_secret=os.getenv("REDDIT_CLIENT_SECRET"),
+            user_agent="Sentiment Analysis Bot 1.0"
+        )
+
+        self.youtube = googleapiclient.discovery.build("youtube", "v3", developerKey=os.getenv("YOUTUBE_API_KEY"))
+
+    def load_company_list(self, file_path: str) -> List[str]:
+        self.company_list = pd.read_csv(file_path)['company_ticker'].tolist()
+
+    def collect_data(self) -> List[Dict]:
+        all_data = []
+        
+        for company in self.company_list:
+            print(f"{company}:")
+            all_data.extend(self._collect_social_media_data(company))
+            all_data.extend(self._collect_news_data(company))
+        
+        return all_data
+
+    def _collect_social_media_data(self, query: str) -> List[Dict]:
+        social_data = []
+
+        print("Collecting Reddit Data")
+        social_data.extend(self.collect_reddit_data(query))
+
+        print("Collecting YouTube Data")
+        social_data.extend(self.collect_youtube_data(query))
+
+        print("Collecting Tumblr Data")
+        social_data.extend(self.collect_tumblr_data(query))
+
+        return social_data
+
+    def _collect_news_data(self, query: str) -> List[Dict]:
+        news_data = []
+
+        print("Collecting Google News Data")
+        news_data.extend(self.collect_google_news(query))
+
+        print("Collecting Financial Times Data")
+        news_data.extend(self.collect_financial_times(query))
+
+        print("Collecting Bloomberg Data")
+        news_data.extend(self.collect_bloomberg(query))
+
+        print("Collecting Reuters Data")
+        news_data.extend(self.collect_reuters(query))
+
+        print("Collecting WSJ Data")
+        # news_data.extend(self.collect_wsj(query))
+
+        print("Collecting Serper Data - StockNews, Yahoo Finance, Insider Monkey, Investor's Business Daily, etc.")
+        news_data.extend(self.search_news(query))
+
+        return news_data
+
+    def collect_tumblr_data(self, query: str) -> List[Dict]:
+        posts = self.tumblr_client.tagged(query)
+        return [{"platform": "Tumblr", "company": query, "page_content": {
+            "title": post["blog"]["title"], "content": post["blog"]["description"]}} for post in posts]
+
+    def collect_twitter_data(self, query: str) -> List[Dict]:
+        tweets = []
+        for tweet in tweepy.Cursor(self.twitter_api.search_tweets, q=query, lang="en",
+                                   since=self.start_date, until=self.end_date).items(100):
+            tweets.append(tweet._json)
+        return [{"platform": "Twitter", "company": query, "page_content": tweet} for tweet in tweets]
+
+    def collect_reddit_data(self, query: str) -> List[Dict]:
+        posts = []
+        subreddit = self.reddit.subreddit("all")
+        for post in subreddit.search(query, sort="new", time_filter="day"):
+            post_date = datetime.fromtimestamp(post.created_utc)
+            if self.start_date <= post_date <= self.end_date:
+                posts.append({"platform": "Reddit", "company": query, "page_content": {
+                    "title": post.title, "content": post.selftext}})
+        return posts
+
+    def collect_youtube_data(self, query: str) -> List[Dict]:
+        request = self.youtube.search().list(
+            q=query, type="video", part="id,snippet", maxResults=50,
+            publishedAfter=self.start_date.isoformat() + "Z", publishedBefore=self.end_date.isoformat() + "Z"
+        )
+        response = request.execute()
+        return [{"platform": "YouTube", "company": query, "page_content": {
+            "title": item["snippet"]["title"], "content": item["snippet"]["description"]}} for item in response['items']]
+
+    def collect_google_news(self, query: str) -> List[Dict]:
+        google_news = GNews(language='en', country='US', start_date=self.start_date, end_date=self.end_date)
+        articles = google_news.get_news(query)
+        return [{"platform": "Google News", "company": query, "page_content": {
+            "title": article["title"], "content": article["description"]}} for article in articles]
+
+    def collect_financial_times(self, query: str) -> List[Dict]:
+        url = f"https://www.ft.com/search?q={query}&dateTo={self.end_date.strftime('%Y-%m-%d')}&dateFrom={self.start_date.strftime('%Y-%m-%d')}"
+        response = requests.get(url)
+        soup = BeautifulSoup(response.content, 'html.parser')
+        articles = soup.find_all('div', class_='o-teaser__content')
+        return [{"platform": "Financial Times", "company": query, "page_content": {
+            "title": a.find('div', class_='o-teaser__heading').text.strip(),
+            "content": a.find('p', class_='o-teaser__standfirst').text.strip() if a.find('p', class_='o-teaser__standfirst') else ''
+        }} for a in articles]
+
+    def collect_bloomberg(self, query: str) -> List[Dict]:
+        url = f"https://www.bloomberg.com/search?query={query}"
+        response = requests.get(url)
+        soup = BeautifulSoup(response.content, 'html.parser')
+        articles = soup.find_all('div', class_='storyItem__aaf871c1')
+        return [{"platform": "Bloomberg", "company": query, "page_content": {
+            "title": a.find('a', class_='headline__3a97424d').text.strip(),
+            "content": a.find('p', class_='summary__483358e1').text.strip() if a.find('p', class_='summary__483358e1') else ''
+        }} for a in articles]
+
+    def collect_reuters(self, query: str) -> List[Dict]:
+        articles = []
+        base_url = "https://www.reuters.com/site-search/"
+        page = 1
+        while True:
+            url = f"{base_url}?blob={query}&page={page}"
+            response = requests.get(url)
+            soup = BeautifulSoup(response.content, 'html.parser')
+            results = soup.find_all('li', class_='search-result__item')
+            if not results:
+                break
+            for result in results:
+                date_elem = result.find('time', class_='search-result__timestamp')
+                if date_elem:
+                    date = datetime.strptime(date_elem['datetime'], "%Y-%m-%dT%H:%M:%SZ")
+                    if self.start_date <= date <= self.end_date:
+                        articles.append({"platform": "Reuters", "company": query, "page_content": {
+                            "title": result.find('h3', class_='search-result__headline').text.strip(),
+                            "content": result.find('p', class_='search-result__excerpt').text.strip()
+                        }})
+                    elif date < self.start_date:
+                        return articles
+            page += 1
+            time.sleep(1)
+        return articles
+
+    def collect_wsj(self, query: str) -> List[Dict]:
+        articles = []
+        base_url = "https://www.wsj.com/search"
+        page = 1
+        while True:
+            params = {
+                'query': query, 'isToggleOn': 'true', 'operator': 'AND', 'sort': 'date-desc',
+                'duration': 'custom', 'startDate': self.start_date.strftime('%Y/%m/%d'),
+                'endDate': self.end_date.strftime('%Y/%m/%d'), 'page': page
+            }
+            response = requests.get(base_url, params=params)
+            soup = BeautifulSoup(response.content, 'html.parser')
+            results = soup.find_all('article', class_='WSJTheme--story--XB4V2mLz')
+            if not results:
+                break
+            for result in results:
+                date_elem = result.find('p', class_='WSJTheme--timestamp--22sfkNDv')
+                if date_elem:
+                    date = datetime.strptime(date_elem.text.strip(), "%B %d, %Y")
+                    if self.start_date <= date <= self.end_date:
+                        articles.append({"platform": "Wall Street Journal", "company": query, "page_content": {
+                            "title": result.find('h3', class_='WSJTheme--headline--unZqjb45').text.strip(),
+                            "content": result.find('p', class_='WSJTheme--summary--lmOXEsbN').text.strip()
+                        }})
+                    elif date < self.start_date:
+                        return articles
+            page += 1
+            time.sleep(1)
+        return articles
+
+    def search_news(self, query: str,cnt=300) -> List[Dict]:
+        articles = []
+        num_results = cnt
+
+        headers = {
+            "X-API-KEY": os.getenv("SERP_API_KEY"),
+            "Content-Type": "application/json"
+        }
+        payload = {"q": f"{query} company news",
+            "num": num_results,
+            "dateRestrict": 14
+            }
+        response = requests.post(
+            "https://google.serper.dev/news",
+            headers=headers,
+            json=payload
+            )
+        # print(response)
+        if response.status_code == 200:
+            results = response.json().get("news", [])
+            for result in results:
+                articles.append({"platform": result["source"], "company": query, "page_content": {
+                    "title": result["title"],
+                    "content": result["snippet"]
+                }})
+        return articles
+
+# Usage Example
+if __name__ == "__main__":
+    analyzer = DataFetch("company_list.csv")
+    data = analyzer.collect_data()
+    # Here, data would contain all collected sentiment data for the given companies

py/db_storage.py

@@ -0,0 +1,183 @@
+import os
+import warnings
+import shutil
+from langchain_openai import AzureChatOpenAI, AzureOpenAIEmbeddings
+from langchain_community.vectorstores import Chroma
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.chains import RetrievalQA
+from langchain_community.document_loaders import PyPDFLoader, Docx2txtLoader, TextLoader, WikipediaLoader
+from typing import List, Optional, Dict, Any
+from langchain.schema import Document
+import chromadb
+# from langchain_community.embeddings.sentence_transformer import (SentenceTransformerEmbeddings)
+from langchain_community.vectorstores import FAISS
+
+
+
+warnings.filterwarnings("ignore")
+CHROMA_DB_PATH = os.path.join(os.getcwd(), "Stock Sentiment Analysis", "chroma_db")
+# FAISS_DB_PATH = os.path.join(os.getcwd(), "Stock Sentiment Analysis", "faiss_index")
+tesla_10k_collection = 'tesla-10k-2019-to-2023'
+embedding_model = ""
+# embedding_model = SentenceTransformerEmbeddings(model_name='thenlper/gte-large')
+
+
+class DBStorage:
+    def __init__(self):
+        self.CHROMA_PATH = CHROMA_DB_PATH
+        self.vector_store = None
+        self.client = chromadb.PersistentClient(path=CHROMA_DB_PATH)
+        print(self.client.list_collections())
+        self.collection = self.client.get_or_create_collection(name=tesla_10k_collection)
+        print(self.collection.count())
+
+    def chunk_data(self, data, chunk_size=10000):
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=0)
+        return text_splitter.split_documents(data)
+
+    def create_embeddings(self, chunks):
+        embeddings = AzureOpenAIEmbeddings(
+            model=os.getenv("AZURE_OPENAI_EMBEDDING_NAME"),
+            api_key=os.getenv("AZURE_OPENAI_EMBEDDING_API_KEY"),
+            api_version=os.getenv("AZURE_OPENAI_EMBEDDING_API_VERSION"),
+            azure_endpoint=os.getenv("AZURE_OPENAI_EMBEDDING_ENDPOINT")
+        )
+        
+        self.vector_store = Chroma.from_documents(documents=chunks, 
+                                                #   embedding=embeddings, 
+                                                  embedding=embedding_model, 
+                                                  collection_name=tesla_10k_collection, 
+                                                  persist_directory=self.CHROMA_PATH)
+        print("Here B")
+        self.collection = self.client.get_or_create_collection(name=tesla_10k_collection)
+        print("here"+str(self.collection.count()))
+        # return self.vector_store
+    
+    def create_vector_store(self, chunks):
+        embeddings = AzureOpenAIEmbeddings(
+            model=os.getenv("AZURE_OPENAI_EMBEDDING_NAME"),
+            api_key=os.getenv("AZURE_OPENAI_EMBEDDING_API_KEY"),
+            api_version=os.getenv("AZURE_OPENAI_EMBEDDING_API_VERSION"),
+            azure_endpoint=os.getenv("AZURE_OPENAI_EMBEDDING_ENDPOINT")
+        )
+        return FAISS.from_documents(chunks, embedding=embeddings)
+        # vector_store.save_local(FAISS_DB_PATH)
+        
+    
+    def load_embeddings(self):
+        embeddings = AzureOpenAIEmbeddings(
+            model=os.getenv("AZURE_OPENAI_EMBEDDING_NAME"),
+            api_key=os.getenv("AZURE_OPENAI_EMBEDDING_API_KEY"),
+            api_version=os.getenv("AZURE_OPENAI_EMBEDDING_API_VERSION"),
+            azure_endpoint=os.getenv("AZURE_OPENAI_EMBEDDING_ENDPOINT")
+        )
+
+        self.vector_store = Chroma(collection_name=tesla_10k_collection, 
+                                   persist_directory=CHROMA_DB_PATH, 
+                                #    embedding_function=embeddings
+                                   embedding_function=embedding_model
+                                   )
+        print("loaded vector store: ")
+        print(self.vector_store)
+        # return self.vector_store
+
+    def load_vectors(self,FAISS_DB_PATH):
+        embeddings = AzureOpenAIEmbeddings(
+            model=os.getenv("AZURE_OPENAI_EMBEDDING_NAME"),
+            api_key=os.getenv("AZURE_OPENAI_EMBEDDING_API_KEY"),
+            api_version=os.getenv("AZURE_OPENAI_EMBEDDING_API_VERSION"),
+            azure_endpoint=os.getenv("AZURE_OPENAI_EMBEDDING_ENDPOINT")
+        )
+
+        self.vector_store = FAISS.load_local(folder_path=FAISS_DB_PATH, 
+                                            embeddings=embeddings, 
+                                            allow_dangerous_deserialization=True)
+
+
+    
+    def fetch_documents(self, metadata_filter: Dict[str, Any]) -> List[Document]:
+        results = self.collection.get(
+            where=metadata_filter,
+            include=["documents", "metadatas"],
+        )
+
+        documents = []
+        for content, metadata in zip(results['documents'][0], results['metadatas'][0]):
+            documents.append(Document(page_content=content, metadata=metadata))
+
+        return documents
+
+    
+    def get_context_for_query(self, question, k=3):
+        print(self.vector_store)
+        # if not self.vector_store:
+        #     raise ValueError("Vector store not initialized. Call create_embeddings() or load_embeddings() first.")
+
+        # relevant_document_chunks=self.fetch_documents({"company": question})
+
+        # retriever = self.vector_store.as_retriever(search_type='similarity', search_kwargs={'k': k})
+        # relevant_document_chunks = retriever.get_relevant_documents(question)
+        
+        relevant_document_chunks = self.vector_store.similarity_search(question)
+        # chain = get_conversational_chain(models.llm)
+        # response = chain({"input_documents": docs, "question": user_question}, return_only_outputs=True)
+        # print(response)
+        
+        print(relevant_document_chunks)
+        context_list = [d.page_content for d in relevant_document_chunks]
+        context_for_query = ". ".join(context_list)
+        print("context_for_query: "+ str(len(context_for_query)))
+
+        return context_for_query
+    
+    # def ask_question(self, question, k=3):
+    #     if not self.vector_store:
+    #         raise ValueError("Vector store not initialized. Call create_embeddings() or load_embeddings() first.")
+
+    #     llm = AzureChatOpenAI(
+    #         temperature=0,
+    #         api_key=os.getenv("AZURE_OPENAI_API_KEY"),
+    #         api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
+    #         azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
+    #         model=os.getenv("AZURE_OPENAI_MODEL_NAME")
+    #     )
+
+    #     retriever = self.vector_store.as_retriever(search_type='similarity', search_kwargs={'k': k})
+    #     chain = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever)
+        
+    #     return chain.invoke(question)
+    
+    def embed_vectors(self,social_media_document,FAISS_DB_PATH):
+        print("here A")
+        chunks = self.chunk_data(social_media_document)
+        print(len(chunks))
+        # self.create_embeddings(chunks)
+        vector_store = self.create_vector_store(chunks)
+        check_and_delete(FAISS_DB_PATH)
+        vector_store.save_local(FAISS_DB_PATH)
+
+def check_and_delete(PATH):
+    if os.path.isdir(PATH):
+        shutil.rmtree(PATH, onexc=lambda func, path, exc: os.chmod(path, 0o777))
+        print(f'Deleted {PATH}')
+    
+def clear_db():
+    check_and_delete(CHROMA_DB_PATH)
+    # check_and_delete(FAISS_DB_PATH)
+
+
+# Usage example
+if __name__ == "__main__":
+    qa_system = DBStorage()
+
+    # Load and process document
+    social_media_document = []
+    chunks = qa_system.chunk_data(social_media_document)
+
+    # Create embeddings
+    qa_system.create_embeddings(chunks)
+
+    # # Ask a question
+    # question = 'Summarize the whole input in 150 words'
+    # answer = qa_system.ask_question(question)
+    # print(answer)

py/handle_files.py

@@ -0,0 +1,103 @@
+
+
+from datetime import datetime
+import json
+import os
+import pickle
+from typing import List
+from langchain.schema import Document
+import pandas as pd
+
+def create_files(social_media_data):
+    folder_path = 'Stock Sentiment Analysis/files'
+
+    if not os.path.exists(folder_path):
+        os.makedirs(folder_path)
+        
+    # Save dictionary to a file
+    with open(folder_path+'/social_media_data.json', 'w') as f:
+        json.dump(social_media_data, f)
+
+    # Convert the data to a pandas DataFrame
+    df = pd.DataFrame(social_media_data)
+    df.head()
+
+    # Exporting the data to a CSV file
+    file_path = folder_path+"/social_media_data.csv"
+    df.to_csv(file_path, index=False)
+        
+    df.to_pickle(folder_path+"/social_media_data.pkl")
+
+def fetch_social_media_data():
+        with open('Stock Sentiment Analysis/files/social_media_data.json', 'r') as file:
+            data = json.load(file)
+        social_media_document = []
+        for item in data:
+            social_media_document.append(Document(
+                page_content=str(item["page_content"]), 
+                metadata={"platform":item["platform"],
+                          "company":item["company"],
+                          "ingestion_timestamp":datetime.now().isoformat(),
+                          "word_count":len(item["page_content"]["content"])
+                          }))
+        return social_media_document
+        
+def save_ingested_data(ingested_data):
+    # Save the list to a file
+    with open('Stock Sentiment Analysis/files/ingested_data.pkl', 'wb') as file:
+        pickle.dump(ingested_data, file)
+
+def save_analysed_data(analysed_data):
+    # Save the list to a file
+    with open('Stock Sentiment Analysis/files/analysed_data.pkl', 'wb') as file:
+        pickle.dump(analysed_data, file)
+
+def get_ingested_data():
+    # Load the list from the file
+    with open('Stock Sentiment Analysis/files/ingested_data.pkl', 'rb') as file:
+        loaded_documents = pickle.load(file)
+    return loaded_documents
+
+def get_analysed_data():
+    # Load the list from the file
+    with open('Stock Sentiment Analysis/files/analysed_data.pkl', 'rb') as file:
+        loaded_documents = pickle.load(file)
+    return loaded_documents
+
+def sample_documents(documents: List[Document], n: int) -> List[Document]:
+    """
+    Samples `n` entries for each unique `"platform"` and `"company"` metadata combination from the input `Document[]`.
+
+    Args:
+        documents (List[Document]): The input list of `Document` objects.
+        n (int): The number of entries to sample for each unique metadata combination.
+
+    Returns:
+        List[Document]: A new list of `Document` objects, with `n` entries per unique metadata combination.
+    """
+    # Create a dictionary to store the sampled documents per metadata combination
+    sampled_docs = {}
+
+    for doc in documents:
+        combo = (doc.metadata["platform"], doc.metadata["company"])
+        if combo not in sampled_docs:
+            sampled_docs[combo] = []
+        
+        # Add the document to the list for its metadata combination, up to n entries
+        if len(sampled_docs[combo]) < n:
+            sampled_docs[combo].append(doc)
+
+    # Flatten the dictionary into a single list
+    return [doc for docs in sampled_docs.values() for doc in docs]
+
+def to_documents(data) -> List[Document]:
+    social_media_document = []
+    for item in data:
+        social_media_document.append(Document(
+            page_content=str(item["page_content"]), 
+            metadata={"platform":item["platform"],
+                        "company":item["company"],
+                        "ingestion_timestamp":datetime.now().isoformat(),
+                        "word_count":len(item["page_content"]["content"])
+                        }))
+    return social_media_document

requirements.txt

@@ -0,0 +1,43 @@
+openai
+python-dotenv
+datasets
+numpy
+tqdm
+scikit-learn
+pip-system-certs
+# evaluate
+# bert-score
+langchain-openai
+langchain-community
+langchain-text-splitters
+chromadb
+langchain
+beautifulsoup4
+pypdf
+wikipedia
+plotly
+ragas
+renumics-spotlight
+streamlit
+# shutil
+dotted_dict
+PyPDF2
+# faiss-gpu
+faiss-cpu
+torch
+transformers
+sentence-transformers
+accelerate
+gradio
+pandas
+tweepy
+praw
+google-api-python-client
+pytumblr
+gnews
+bs4
+requests
+certifi
+plotly
+pandas_datareader
+yfinance