Upload 18 files

.gitattributes

@@ -33,3 +33,4 @@ 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
+generated-icon.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,14 +1,81 @@
----
-title: Fnonse
-emoji: 🐠
-colorFrom: yellow
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.43.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: FNO, stock analysis of NSE listed stocks
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# NSE Stock Analysis Platform 📈
+
+A comprehensive NSE stock analysis platform built with Streamlit, providing real-time technical indicators, trading signals, and news insights for investors.
+
+## Features
+
+- **Real-time Stock Analysis**: Technical indicators and interactive charts
+- **AI-Powered Recommendations**: Smart stock recommendations based on technical analysis
+- **Stock Screener**: Filter stocks based on custom technical criteria
+- **Live News Feed**: Latest news for NSE stocks using Google News RSS
+- **Interactive Charts**: Multi-timeframe analysis with various technical indicators
+
+## Technical Stack
+
+- **Frontend**: Streamlit
+- **Data Processing**: Pandas, NumPy
+- **Technical Analysis**: Custom implementations of technical indicators
+- **Data Source**: yfinance API
+- **News Feed**: Google News RSS
+- **Visualization**: Plotly
+
+## Dependencies
+
+```txt
+streamlit
+pandas
+numpy
+plotly
+yfinance
+feedparser
+pytz
+```
+
+## Deployment on Hugging Face Spaces
+
+1. Create a new Space on Hugging Face:
+   - Go to huggingface.co/spaces
+   - Click "Create new Space"
+   - Select "Streamlit" as the SDK
+   - Choose a name for your space
+
+2. Upload the Project Files:
+   - Upload all project files to your Space
+   - Ensure the file structure matches the repository
+
+3. Configure Environment:
+   - The platform will automatically install dependencies
+   - The app will run on the default Streamlit port
+
+4. Access Your App:
+   - Once deployed, your app will be available at: https://huggingface.co/spaces/[USERNAME]/[SPACE-NAME]
+
+## Usage
+
+1. **Stock Analysis**:
+   - Select a stock from the dropdown
+   - Choose timeframe and interval
+   - View technical indicators and signals
+
+2. **Stock Screener**:
+   - Set your screening criteria
+   - Get filtered results based on technical indicators
+
+3. **AI Recommendations**:
+   - View AI-generated stock recommendations
+   - Check confidence levels and recommendation basis
+
+4. **News Feed**:
+   - Access latest news for all NSE stocks
+   - Click on news titles to read full articles
+
+## Local Development
+
+1. Clone the repository
+2. Install dependencies: `pip install -r requirements.txt`
+3. Run the app: `streamlit run main.py`
+4. Access at: `http://localhost:5000`
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

attached_assets/nse_stock_signals_app_plan.md

@@ -0,0 +1,259 @@
+# AI-Based NSE Stock Technical Signals Web Application Plan
+
+## 1. System Architecture
+
+```mermaid
+graph TD
+    A[Data Collection Layer] --> B[Data Processing Layer]
+    B --> C[AI Analysis Layer]
+    C --> D[Signal Generation Layer]
+    D --> E[Web Interface Layer]
+    
+    subgraph "Data Sources"
+        F[yFinance API]
+        G[Google Finance]
+        H[Historical Data Storage]
+    end
+    
+    F --> A
+    G --> A
+    A --> H
+    H --> B
+```
+
+## 2. Component Breakdown
+
+### 2.1 Data Collection Layer
+- **Purpose**: Fetch financial data from yFinance and Google Finance APIs
+- **Components**:
+  - Stock Data Fetcher: Retrieves real-time and historical price data
+  - Financial Metrics Collector: Gathers fundamental data and market metrics
+  - Data Synchronization Manager: Ensures consistent data across sources
+- **Technologies**: Python, yfinance library, requests/BeautifulSoup for Google Finance
+
+### 2.2 Data Processing Layer
+- **Purpose**: Clean, normalize, and prepare data for analysis
+- **Components**:
+  - Data Cleaner: Handles missing values and outliers
+  - Feature Engineering: Creates derived features for technical analysis
+  - Technical Indicator Calculator: Computes standard technical indicators
+- **Technologies**: Pandas, NumPy, TA-Lib
+
+### 2.3 AI Analysis Layer
+- **Purpose**: Apply AI/ML techniques to analyze stock patterns
+- **Components**:
+  - Prediction Models: Time-series forecasting for price movements
+  - Pattern Recognition: Identify chart patterns and formations
+  - Anomaly Detection: Spot unusual market behavior
+- **Technologies**: Scikit-learn, TensorFlow/Keras, Prophet, LSTM networks
+
+### 2.4 Signal Generation Layer
+- **Purpose**: Generate actionable trading signals based on AI analysis
+- **Components**:
+  - Signal Aggregator: Combines signals from multiple sources
+  - Confidence Calculator: Assigns confidence scores to signals
+  - Alert Generator: Creates notifications for significant signals
+- **Technologies**: Custom Python algorithms, rule-based systems
+
+### 2.5 Web Interface Layer
+- **Purpose**: Present signals and analysis to users
+- **Components**:
+  - Dashboard: Visual overview of signals and market status
+  - Stock Screener: Filter stocks based on signals and criteria
+  - Detailed Analysis View: In-depth analysis for individual stocks
+  - User Preferences: Customization options for alerts and display
+- **Technologies**: Flask/FastAPI backend, React/Vue frontend, Plotly/D3.js for charts
+
+## 3. Technical Indicators to Implement
+
+We'll implement the most reliable technical indicators:
+
+1. **Trend Indicators**:
+   - Moving Averages (SMA, EMA, VWAP)
+   - MACD (Moving Average Convergence Divergence)
+   - ADX (Average Directional Index)
+   - Parabolic SAR
+
+2. **Momentum Indicators**:
+   - RSI (Relative Strength Index)
+   - Stochastic Oscillator
+   - CCI (Commodity Channel Index)
+   - Williams %R
+
+3. **Volatility Indicators**:
+   - Bollinger Bands
+   - ATR (Average True Range)
+   - Standard Deviation
+
+4. **Volume Indicators**:
+   - OBV (On-Balance Volume)
+   - Volume Rate of Change
+   - Accumulation/Distribution Line
+   - Money Flow Index
+
+## 4. AI Implementation Approach
+
+### 4.1 Prediction Models
+- **Time Series Forecasting**:
+  - ARIMA/SARIMA models for short-term predictions
+  - LSTM/GRU neural networks for capturing long-term dependencies
+  - Prophet for trend and seasonality decomposition
+- **Ensemble Methods**:
+  - Combine multiple forecasting models for improved accuracy
+  - Use techniques like stacking and boosting
+
+### 4.2 Pattern Recognition
+- **Candlestick Pattern Detection**:
+  - CNN-based image recognition for chart patterns
+  - Rule-based detection for common patterns (head and shoulders, double tops, etc.)
+- **Support/Resistance Level Identification**:
+  - Clustering algorithms to identify price levels
+  - Fractal analysis for multi-timeframe support/resistance
+
+### 4.3 Anomaly Detection
+- **Statistical Methods**:
+  - Z-score analysis for outlier detection
+  - DBSCAN for identifying unusual price/volume clusters
+- **Deep Learning Approaches**:
+  - Autoencoders for unsupervised anomaly detection
+  - Sequence models to detect unusual patterns in time series
+
+## 5. Development Roadmap
+
+### Phase 1: Foundation (Weeks 1-2)
+- Set up project structure and environment
+- Implement data collection from yFinance and Google Finance
+- Create basic data processing pipeline
+- Develop database schema for storing historical data
+
+### Phase 2: Technical Analysis Engine (Weeks 3-4)
+- Implement all technical indicators
+- Create visualization components for indicators
+- Develop backtesting framework for indicator performance
+
+### Phase 3: AI Model Development (Weeks 5-8)
+- Develop and train prediction models
+- Implement pattern recognition algorithms
+- Create anomaly detection systems
+- Integrate all AI components
+
+### Phase 4: Signal Generation (Weeks 9-10)
+- Develop signal generation logic
+- Implement confidence scoring system
+- Create alert mechanism
+- Test and optimize signal accuracy
+
+### Phase 5: Web Interface (Weeks 11-14)
+- Develop backend API
+- Create frontend dashboard
+- Implement stock screener
+- Add user preference management
+- Optimize performance and UX
+
+### Phase 6: Testing and Deployment (Weeks 15-16)
+- Comprehensive testing
+- Performance optimization
+- Deployment to production
+- Documentation and user guides
+
+## 6. Technology Stack Recommendation
+
+### Backend
+- **Language**: Python 3.9+
+- **Web Framework**: FastAPI (high performance, easy API development)
+- **Data Processing**: Pandas, NumPy, TA-Lib
+- **Machine Learning**: Scikit-learn, TensorFlow/Keras, Prophet
+- **Database**: PostgreSQL (time-series data), Redis (caching)
+- **Task Queue**: Celery (for background processing)
+
+### Frontend
+- **Framework**: React with TypeScript
+- **State Management**: Redux or Context API
+- **Charting**: TradingView Lightweight Charts or Plotly
+- **UI Components**: Material-UI or Ant Design
+- **API Communication**: Axios
+
+### DevOps
+- **Containerization**: Docker
+- **Orchestration**: Docker Compose (development), Kubernetes (production)
+- **CI/CD**: GitHub Actions
+- **Monitoring**: Prometheus, Grafana
+- **Hosting**: AWS or GCP
+
+## 7. Data Flow and Processing
+
+```mermaid
+sequenceDiagram
+    participant DS as Data Sources
+    participant DL as Data Layer
+    participant AI as AI Layer
+    participant SG as Signal Generator
+    participant UI as Web Interface
+    participant User
+    
+    DS->>DL: Raw stock data
+    DL->>DL: Clean and process data
+    DL->>DL: Calculate technical indicators
+    DL->>AI: Processed data
+    AI->>AI: Apply prediction models
+    AI->>AI: Perform pattern recognition
+    AI->>AI: Detect anomalies
+    AI->>SG: Analysis results
+    SG->>SG: Generate signals
+    SG->>SG: Calculate confidence scores
+    SG->>UI: Trading signals
+    UI->>User: Display dashboard
+    User->>UI: Select stock/timeframe
+    UI->>DL: Request specific data
+    DL->>UI: Return requested data
+    UI->>User: Show detailed analysis
+```
+
+## 8. Key Challenges and Considerations
+
+1. **Data Quality and Consistency**:
+   - Handling missing data points
+   - Reconciling differences between data sources
+   - Managing API rate limits and outages
+
+2. **Model Accuracy and Reliability**:
+   - Avoiding overfitting in prediction models
+   - Balancing sensitivity and specificity in signal generation
+   - Adapting to changing market conditions
+
+3. **Performance Optimization**:
+   - Efficient processing of large datasets
+   - Real-time updates without overwhelming resources
+   - Caching strategies for frequently accessed data
+
+4. **Scalability**:
+   - Supporting a growing number of stocks
+   - Handling increased user load
+   - Managing computational resources for AI models
+
+5. **User Experience**:
+   - Presenting complex information in an intuitive way
+   - Providing appropriate level of detail for different user types
+   - Ensuring responsive performance across devices
+
+## 9. Future Expansion Possibilities
+
+1. **Additional Data Sources**:
+   - News sentiment analysis
+   - Social media trends
+   - Economic indicators
+
+2. **Advanced AI Features**:
+   - Reinforcement learning for strategy optimization
+   - NLP for news and report analysis
+   - Explainable AI for signal justification
+
+3. **User Features**:
+   - Custom strategy builder
+   - Portfolio tracking and optimization
+   - Performance analytics and reporting
+
+4. **Integration Options**:
+   - Broker API connections for automated trading
+   - Export to trading platforms
+   - Mobile app development

attached_assets/symbol.csv

@@ -0,0 +1,218 @@
+"SYMBOL 
+"
+KEI
+BANDHANBNK
+SHRIRAMFIN
+HDFCBANK
+PHOENIXLTD
+AUBANK
+COALINDIA
+DIXON
+LUPIN
+JSWENERGY
+POLYCAB
+INDIGO
+VOLTAS
+TRENT
+SOLARINDS
+HINDALCO
+ANGELONE
+GMRAIRPORT
+PIIND
+LICI
+NYKAA
+AXISBANK
+ABFRL
+KALYANKJIL
+MRF
+FEDERALBNK
+IEX
+ACC
+GODREJPROP
+ICICIGI
+PIDILITIND
+APLAPOLLO
+ABCAPITAL
+ADANIENT
+ADANIPORTS
+GRASIM
+ALKEM
+RELIANCE
+PRESTIGE
+GAIL
+DRREDDY
+POONAWALLA
+SAIL
+NATIONALUM
+COLPAL
+AMBUJACEM
+BOSCHLTD
+TATASTEEL
+IDFCFIRSTB
+RAMCOCEM
+ZYDUSLIFE
+INDHOTEL
+LT
+TATAPOWER
+BANKINDIA
+JINDALSTEL
+ITC
+HDFCLIFE
+DLF
+ASIANPAINT
+CROMPTON
+HEROMOTOCO
+ADANIENSOL
+DEEPAKNTR
+CGPOWER
+SIEMENS
+NHPC
+NTPC
+PAYTM
+DALBHARAT
+HDFCAMC
+APOLLOHOSP
+ICICIPRULI
+POWERGRID
+ICICIBANK
+PATANJALI
+DABUR
+BAJFINANCE
+HAVELLS
+JKCEMENT
+EXIDEIND
+NCC
+ESCORTS
+JSL
+SBIN
+UNIONBANK
+SRF
+BEL
+TORNTPHARM
+UPL
+IOC
+JSWSTEEL
+HINDUNILVR
+INDIANB
+GLENMARK
+POLICYBZR
+BHARATFORG
+AUROPHARMA
+ONGC
+VEDL
+MFSL
+SONACOMS
+OBEROIRLTY
+CIPLA
+KOTAKBANK
+COFORGE
+SBICARD
+TATACHEM
+TATAELXSI
+EICHERMOT
+CUMMINSIND
+DELHIVERY
+CANBK
+SBILIFE
+BPCL
+DIVISLAB
+CESC
+TATACOMM
+DMART
+RBLBANK
+BANKBARODA
+TORNTPOWER
+BAJAJFINSV
+BIOCON
+LTTS
+IRCTC
+TIINDIA
+CHOLAFIN
+BERGEPAINT
+IDEA
+CYIENT
+PAGEIND
+IGL
+BALKRISIND
+ASTRAL
+LTF
+MOTHERSON
+LICHSGFIN
+LAURUSLABS
+HCLTECH
+CAMS
+YESBANK
+ZOMATO
+ULTRACEMCO
+PEL
+SYNGENE
+PFC
+MARUTI
+SUNPHARMA
+VBL
+SHREECEM
+MUTHOOTFIN
+NESTLEIND
+NBCC
+TCS
+ATGL
+MARICO
+M&MFIN
+UNITDSPR
+PERSISTENT
+APOLLOTYRE
+BAJAJ-AUTO
+CDSL
+HINDPETRO
+NMDC
+MANAPPURAM
+ABB
+BRITANNIA
+OFSS
+GODREJCP
+INFY
+IRB
+TATACONSUM
+HUDCO
+TITAN
+TATAMOTORS
+INDUSTOWER
+KPITTECH
+RECLTD
+LTIM
+TVSMOTOR
+BHEL
+HAL
+SUPREMEIND
+HFCL
+MAXHEALTH
+AARTIIND
+SJVN
+M&M
+BHARTIARTL
+PNB
+IIFL
+NAUKRI
+HINDCOPPER
+PETRONET
+ASHOKLEY
+MPHASIS
+WIPRO
+BSOFT
+CONCOR
+TITAGARH
+MGL
+LODHA
+ADANIGREEN
+IREDA
+TATATECH
+JIOFIN
+OIL
+TECHM
+IRFC
+CHAMBLFERT
+JUBLFOOD
+INDUSINDBK
+MCX
+GRANULES
+BSE

main.py

@@ -0,0 +1,79 @@
+import streamlit as st
+
+st.set_page_config(
+    page_title="NSE Stock Analysis",
+    page_icon="📈",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS to reduce sidebar width and improve layout
+st.markdown("""
+<style>
+    [data-testid="stSidebar"][aria-expanded="true"] {
+        min-width: 200px;
+        max-width: 200px;
+    }
+    [data-testid="stSidebar"][aria-expanded="false"] {
+        min-width: 200px;
+        margin-left: -200px;
+    }
+    .css-1d391kg {
+        padding-top: 1rem;
+    }
+    .stApp > header {
+        background-color: transparent;
+    }
+    .news-table {
+        font-size: 14px;
+        width: 100%;
+    }
+    .news-table td {
+        padding: 8px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def main():
+    st.title("NSE Stock Analysis Platform")
+
+    st.markdown("""
+    Welcome to the NSE Stock Analysis Platform. This tool provides technical analysis and trading signals
+    for NSE-listed stocks.
+
+    ### Features:
+    - Real-time stock data and technical indicators
+    - Interactive charts with multiple timeframes
+    - Trading signals based on technical analysis
+    - Stock screener with customizable criteria
+    - Latest news for NSE stocks
+    - AI-powered stock recommendations
+
+    ### Available Tools:
+    1. **Stock Analysis**: Detailed technical analysis with multiple indicators
+    2. **Stock Screener**: Screen stocks based on technical criteria
+    3. **AI Recommendations**: Get AI-powered stock recommendations
+    4. **News**: Latest news articles for NSE stocks
+
+    Choose a tool from the sidebar to get started.
+    """)
+
+    st.sidebar.title("Navigation")
+    page = st.sidebar.radio("Select a Tool", 
+                           ["Stock Analysis", "Stock Screener", "AI Recommendations", "News"])
+
+    if page == "Stock Analysis":
+        from pages.stock_analysis import stock_analysis_page
+        stock_analysis_page()
+    elif page == "Stock Screener":
+        from pages.stock_screener import stock_screener_page
+        stock_screener_page()
+    elif page == "AI Recommendations":
+        from pages.recommendations import recommendations_page
+        recommendations_page()
+    else:
+        from pages.news import news_page
+        news_page()
+
+if __name__ == "__main__":
+    main()

pages/news.py

@@ -0,0 +1,89 @@
+import streamlit as st
+import feedparser
+import pandas as pd
+from datetime import datetime
+from urllib.parse import quote
+import pytz
+
+def fetch_stock_news(symbol):
+    """Fetch news for a specific stock symbol."""
+    query = f"{symbol} NSE stock"
+    encoded_query = quote(query)
+    feed_url = f"https://news.google.com/rss/search?q={encoded_query}&hl=en-IN&gl=IN&ceid=IN:en"
+
+    try:
+        feed = feedparser.parse(feed_url)
+        news_items = []
+
+        for entry in feed.entries[:5]:  # Get top 5 news items per stock
+            # Convert UTC time to IST
+            utc_time = datetime.strptime(entry.published, '%a, %d %b %Y %H:%M:%S %Z')
+            ist_timezone = pytz.timezone('Asia/Kolkata')
+            ist_time = utc_time.replace(tzinfo=pytz.UTC).astimezone(ist_timezone)
+
+            news_items.append({
+                'Symbol': symbol,
+                'Title': entry.title,
+                'Link': entry.link,
+                'Published': ist_time,
+                'Source': entry.source.title if hasattr(entry, 'source') else 'Unknown'
+            })
+
+        return news_items
+    except Exception as e:
+        st.error(f"Error fetching news for {symbol}: {str(e)}")
+        return []
+
+def news_page():
+    st.title("NSE Stocks News")
+
+    try:
+        # Read symbols from CSV
+        symbols = pd.read_csv("attached_assets/symbol.csv", names=['Symbol'], skiprows=1)
+        symbols_list = symbols['Symbol'].dropna().tolist()
+
+        # Fetch news for all symbols
+        with st.spinner("Fetching latest news..."):
+            all_news = []
+            for symbol in symbols_list:
+                all_news.extend(fetch_stock_news(symbol))
+
+            # Sort news by publication date
+            all_news.sort(key=lambda x: x['Published'], reverse=True)
+
+            # Create DataFrame for display
+            news_df = pd.DataFrame(all_news)
+
+            # Format the table
+            if not news_df.empty:
+                # Convert datetime to IST 12-hour format string
+                news_df['Published'] = news_df['Published'].dt.strftime('%I:%M %p, %d %b %Y')
+
+                # Create clickable links
+                news_df['Title'] = news_df.apply(
+                    lambda row: f'<a href="{row["Link"]}" target="_blank">{row["Title"]}</a>', 
+                    axis=1
+                )
+
+                # Display the table with HTML
+                st.markdown("""
+                <style>
+                .news-table {
+                    font-size: 14px;
+                }
+                </style>
+                """, unsafe_allow_html=True)
+
+                st.markdown(
+                    news_df[['Published', 'Symbol', 'Title', 'Source']]
+                    .to_html(escape=False, index=False, classes='news-table'),
+                    unsafe_allow_html=True
+                )
+            else:
+                st.info("No news articles found.")
+
+    except Exception as e:
+        st.error(f"Error loading news: {str(e)}")
+
+if __name__ == "__main__":
+    news_page()

pages/recommendations.py

@@ -0,0 +1,129 @@
+import streamlit as st
+import pandas as pd
+from utils.stock_data import get_stock_data, format_number
+from utils.recommendation_engine import analyze_stock
+
+def recommendations_page():
+    st.title("AI Stock Recommendations")
+
+    # Load symbols
+    try:
+        symbols = pd.read_csv("attached_assets/symbol.csv", names=['Symbol'], skiprows=1)
+        symbols_list = symbols['Symbol'].dropna().tolist()
+    except Exception as e:
+        st.error(f"Error loading symbols: {str(e)}")
+        return
+
+    # Analysis parameters
+    min_confidence = st.selectbox("Minimum Confidence Level", ["Low", "Medium", "High"])
+
+    if st.button("Generate Recommendations"):
+        with st.spinner("Analyzing all NSE stocks..."):
+            recommendations = []
+
+            # Progress bar for analysis
+            progress_bar = st.progress(0)
+            total_stocks = len(symbols_list)
+
+            # Analyze each stock
+            for idx, symbol in enumerate(symbols_list):
+                df, error = get_stock_data(symbol, period='3mo', interval='1d')
+                if error:
+                    continue
+
+                analysis = analyze_stock(symbol, df)
+                if analysis:
+                    recommendations.append(analysis)
+
+                # Update progress
+                progress_bar.progress((idx + 1) / total_stocks)
+
+            if recommendations:
+                # Convert to DataFrame
+                rec_df = pd.DataFrame(recommendations)
+
+                # Filter by confidence
+                confidence_levels = {'Low': 0, 'Medium': 1, 'High': 2}
+                min_conf_level = confidence_levels[min_confidence]
+                rec_df = rec_df[rec_df['confidence'].map(lambda x: confidence_levels[x]) >= min_conf_level]
+
+                # Sort by technical score
+                rec_df = rec_df.sort_values('technical_score', ascending=False)
+
+                # Display recommendations
+                st.subheader("Stock Recommendations")
+
+                # Format DataFrame for display
+                display_df = rec_df.copy()
+                display_df['price_change'] = display_df['price_change'].round(2).astype(str) + '%'
+                display_df['technical_score'] = display_df['technical_score'].round(2)
+
+                # Generate recommendation basis
+                basis_list = []
+                for _, row in display_df.iterrows():
+                    signals = []
+                    if row['technical_score'] > 50:
+                        signals.append("Strong technical indicators")
+                    if 'RSI' in row['signal_summary'] and row['signal_summary']['RSI'] == 'Oversold':
+                        signals.append("Oversold (RSI)")
+                    if 'MACD' in row['signal_summary'] and row['signal_summary']['MACD'] == 'Buy':
+                        signals.append("Bullish MACD crossover")
+                    if 'Moving Average' in row['signal_summary'] and row['signal_summary']['Moving Average'] == 'Bullish':
+                        signals.append("Above key moving averages")
+                    basis_list.append(", ".join(signals) if signals else "Multiple factors")
+
+                display_df['Basis'] = basis_list
+
+                # Color-code recommendations
+                def color_recommendations(val):
+                    if 'Strong Buy' in val:
+                        return 'background-color: #9fff9c'
+                    elif 'Buy' in val:
+                        return 'background-color: #c8ffc6'
+                    elif 'Strong Sell' in val:
+                        return 'background-color: #ffc6c6'
+                    elif 'Sell' in val:
+                        return 'background-color: #ffdede'
+                    return ''
+
+                # Display styled table
+                st.dataframe(
+                    display_df[['symbol', 'recommendation', 'confidence', 'technical_score', 
+                              'price_change', 'last_price', 'Basis']]
+                    .style
+                    .apply(lambda x: [color_recommendations(val) for val in x], axis=1, subset=['recommendation'])
+                    .format({'last_price': '₹{:.2f}'})
+                )
+
+                # Display analysis insights
+                st.subheader("Analysis Insights")
+                total_analyzed = len(recommendations)
+                buy_signals = len(rec_df[rec_df['recommendation'].isin(['Buy', 'Strong Buy'])])
+                sell_signals = len(rec_df[rec_df['recommendation'].isin(['Sell', 'Strong Sell'])])
+
+                col1, col2, col3 = st.columns(3)
+                col1.metric("Total Stocks Analyzed", total_analyzed)
+                col2.metric("Buy Signals", buy_signals)
+                col3.metric("Sell Signals", sell_signals)
+
+                # Display market sentiment
+                st.subheader("Market Sentiment")
+                buy_percentage = (buy_signals / total_analyzed) * 100
+                if buy_percentage > 60:
+                    sentiment = "Bullish"
+                    color = "green"
+                elif buy_percentage < 40:
+                    sentiment = "Bearish"
+                    color = "red"
+                else:
+                    sentiment = "Neutral"
+                    color = "gray"
+
+                st.markdown(f"Overall Market Sentiment: <span style='color: {color}'>{sentiment}</span>", 
+                          unsafe_allow_html=True)
+
+            else:
+                st.warning("No recommendations generated. Please try with different parameters.")
+
+if __name__ == "__main__":
+    recommendations_page()

pages/stock_analysis.py

@@ -0,0 +1,126 @@
+import streamlit as st
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pandas as pd
+
+from utils.stock_data import get_stock_data, get_company_info, format_number
+from utils.indicators import add_indicators
+from utils.signals import generate_signals, get_signal_summary
+
+def plot_stock_data(df, signals):
+    """Create interactive stock charts with indicators."""
+    fig = make_subplots(rows=3, cols=1, 
+                        shared_xaxes=True,
+                        vertical_spacing=0.05,
+                        row_heights=[0.6, 0.2, 0.2])
+
+    # Candlestick chart
+    fig.add_trace(go.Candlestick(
+        x=df.index,
+        open=df['Open'],
+        high=df['High'],
+        low=df['Low'],
+        close=df['Close'],
+        name='OHLC'
+    ), row=1, col=1)
+
+    # Add indicators
+    fig.add_trace(go.Scatter(x=df.index, y=df['SMA_20'], name='SMA 20', line=dict(color='blue')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=df.index, y=df['BB_Upper'], name='BB Upper', line=dict(color='gray', dash='dash')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=df.index, y=df['BB_Lower'], name='BB Lower', line=dict(color='gray', dash='dash')), row=1, col=1)
+
+    # MACD
+    fig.add_trace(go.Bar(x=df.index, y=df['MACD_Hist'], name='MACD Hist'), row=2, col=1)
+    fig.add_trace(go.Scatter(x=df.index, y=df['MACD'], name='MACD'), row=2, col=1)
+    fig.add_trace(go.Scatter(x=df.index, y=df['MACD_Signal'], name='MACD Signal'), row=2, col=1)
+
+    # RSI
+    fig.add_trace(go.Scatter(x=df.index, y=df['RSI'], name='RSI'), row=3, col=1)
+    fig.add_hline(y=70, line_dash="dash", line_color="red", row=3, col=1)
+    fig.add_hline(y=30, line_dash="dash", line_color="green", row=3, col=1)
+
+    # Update layout
+    fig.update_layout(
+        height=800,
+        xaxis_rangeslider_visible=False,
+        template='plotly_white',
+        showlegend=True,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1
+        )
+    )
+
+    # Update y-axis titles
+    fig.update_yaxes(title_text="Price", row=1, col=1)
+    fig.update_yaxes(title_text="MACD", row=2, col=1)
+    fig.update_yaxes(title_text="RSI", row=3, col=1)
+
+    return fig
+
+def stock_analysis_page():
+    st.title("Stock Technical Analysis")
+
+    # Load symbols from CSV
+    try:
+        # Read CSV file with no header, then assign column name
+        symbols = pd.read_csv("attached_assets/symbol.csv", names=['Symbol'], skiprows=1)
+        selected_symbol = st.selectbox("Select Stock", symbols['Symbol'].dropna())
+    except Exception as e:
+        st.error(f"Error loading symbols: {str(e)}")
+        return
+
+    col1, col2, col3 = st.columns(3)
+    timeframe = col1.selectbox("Timeframe", ['1mo', '3mo', '6mo', '1y', '2y', '5y'])
+    interval = col2.selectbox("Interval", ['1d', '5d', '1wk', '1mo'])
+
+    if col3.button("Analyze"):
+        with st.spinner("Fetching data..."):
+            df, error = get_stock_data(selected_symbol, timeframe, interval)
+
+            if error:
+                st.error(error)
+                return
+
+            # Calculate price change
+            current_price = df['Close'].iloc[-1]
+            prev_price = df['Close'].iloc[-2]
+            price_change = ((current_price / prev_price) - 1) * 100
+            price_change_color = "green" if price_change >= 0 else "red"
+
+            # Get company info
+            info = get_company_info(selected_symbol)
+
+            # Display company info with current price and change
+            st.subheader(info['name'])
+            cols = st.columns(6)
+            cols[0].metric("Sector", info['sector'])
+            cols[1].metric("Industry", info['industry'])
+            cols[2].metric("Market Cap", format_number(info['market_cap']))
+            cols[3].metric("Volume", format_number(info['volume']))
+            cols[4].metric("Current Price", f"₹{current_price:.2f}")
+            cols[5].metric("Day Change", f"{price_change:+.2f}%", 
+                         delta_color="normal" if price_change >= 0 else "inverse")
+
+            # Calculate indicators and signals
+            df = add_indicators(df)
+            signals = generate_signals(df)
+
+            # Plot charts
+            st.plotly_chart(plot_stock_data(df, signals), use_container_width=True)
+
+            # Display signals
+            st.subheader("Trading Signals")
+            signal_summary = get_signal_summary(signals)
+
+            signal_cols = st.columns(5)
+            for i, (indicator, signal) in enumerate(signal_summary.items()):
+                color = "green" if signal in ['Buy', 'Bullish', 'Oversold'] else "red" if signal in ['Sell', 'Bearish', 'Overbought'] else "gray"
+                signal_cols[i].markdown(f"**{indicator}**")
+                signal_cols[i].markdown(f"<p style='color: {color}'>{signal}</p>", unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    stock_analysis_page()

pages/stock_screener.py

@@ -0,0 +1,107 @@
+import streamlit as st
+import pandas as pd
+from utils.stock_data import get_stock_data
+from utils.indicators import add_indicators
+from utils.signals import generate_signals
+
+def screen_stocks(symbols, criteria):
+    """Screen stocks based on technical criteria."""
+    results = []
+
+    for symbol in symbols:
+        df, error = get_stock_data(symbol, period='1mo', interval='1d')
+        if error:
+            continue
+
+        df = add_indicators(df)
+        signals = generate_signals(df)
+        latest = df.iloc[-1]
+        signal_summary = signals.iloc[-1]
+
+        meets_criteria = True
+        for criterion in criteria:
+            if criterion == 'RSI_Oversold' and latest['RSI'] >= 30:
+                meets_criteria = False
+            elif criterion == 'RSI_Overbought' and latest['RSI'] <= 70:
+                meets_criteria = False
+            elif criterion == 'Above_SMA20' and latest['Close'] <= latest['SMA_20']:
+                meets_criteria = False
+            elif criterion == 'Below_SMA20' and latest['Close'] >= latest['SMA_20']:
+                meets_criteria = False
+            elif criterion == 'MACD_Bullish' and signal_summary['MACD_Signal'] != 'Buy':
+                meets_criteria = False
+            elif criterion == 'MACD_Bearish' and signal_summary['MACD_Signal'] != 'Sell':
+                meets_criteria = False
+
+        if meets_criteria:
+            results.append({
+                'Symbol': symbol,
+                'Close': latest['Close'],
+                'RSI': latest['RSI'],
+                'MACD_Signal': signal_summary['MACD_Signal'],
+                'MA_Signal': signal_summary['MA_Signal']
+            })
+
+    return pd.DataFrame(results)
+
+def stock_screener_page():
+    st.title("Stock Screener")
+
+    # Load symbols
+    try:
+        # Read CSV file with no header, then assign column name
+        symbols = pd.read_csv("attached_assets/symbol.csv", names=['Symbol'], skiprows=1)
+        symbols_list = symbols['Symbol'].dropna().tolist()
+    except Exception as e:
+        st.error(f"Error loading symbols: {str(e)}")
+        return
+
+    # Screening criteria
+    st.subheader("Select Screening Criteria")
+
+    col1, col2 = st.columns(2)
+
+    criteria = []
+
+    with col1:
+        if st.checkbox("RSI Conditions"):
+            if st.checkbox("Oversold (RSI < 30)"):
+                criteria.append('RSI_Oversold')
+            if st.checkbox("Overbought (RSI > 70)"):
+                criteria.append('RSI_Overbought')
+
+    with col2:
+        if st.checkbox("Moving Average Conditions"):
+            if st.checkbox("Price Above SMA20"):
+                criteria.append('Above_SMA20')
+            if st.checkbox("Price Below SMA20"):
+                criteria.append('Below_SMA20')
+
+    if st.checkbox("MACD Conditions"):
+        col3, col4 = st.columns(2)
+        with col3:
+            if st.checkbox("Bullish MACD Crossover"):
+                criteria.append('MACD_Bullish')
+        with col4:
+            if st.checkbox("Bearish MACD Crossover"):
+                criteria.append('MACD_Bearish')
+
+    if st.button("Run Screener"):
+        if not criteria:
+            st.warning("Please select at least one screening criterion")
+            return
+
+        with st.spinner("Screening stocks..."):
+            results = screen_stocks(symbols_list, criteria)
+
+            if results.empty:
+                st.info("No stocks found matching the selected criteria")
+            else:
+                st.subheader("Screening Results")
+                st.dataframe(results.style.format({
+                    'Close': '{:.2f}',
+                    'RSI': '{:.2f}'
+                }))
+
+if __name__ == "__main__":
+    stock_screener_page()

pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "feedparser>=6.0.11",
+    "numpy>=2.2.3",
+    "pandas>=2.2.3",
+    "plotly>=6.0.0",
+    "pytz>=2025.1",
+    "streamlit>=1.43.1",
+    "yfinance>=0.2.54",
+]

replit.nix

@@ -0,0 +1,5 @@
+{pkgs}: {
+  deps = [
+    pkgs.glibcLocales
+  ];
+}

requirements.txt.rtf

@@ -0,0 +1,14 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2821
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+{\*\expandedcolortbl;;}
+\paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
+\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural\partightenfactor0
+
+\f0\fs24 \cf0 streamlit\
+pandas\
+numpy\
+plotly\
+yfinance\
+feedparser\
+pytz}

utils/indicators.py

@@ -0,0 +1,66 @@
+import pandas as pd
+import numpy as np
+
+def calculate_sma(data, period=20):
+    """Calculate Simple Moving Average."""
+    return data.rolling(window=period).mean()
+
+def calculate_ema(data, period=20):
+    """Calculate Exponential Moving Average."""
+    return data.ewm(span=period, adjust=False).mean()
+
+def calculate_rsi(data, period=14):
+    """Calculate Relative Strength Index."""
+    delta = data.diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
+    rs = gain / loss
+    return 100 - (100 / (1 + rs))
+
+def calculate_macd(data):
+    """Calculate MACD."""
+    exp1 = data.ewm(span=12, adjust=False).mean()
+    exp2 = data.ewm(span=26, adjust=False).mean()
+    macd = exp1 - exp2
+    signal = macd.ewm(span=9, adjust=False).mean()
+    hist = macd - signal
+    return pd.DataFrame({
+        'MACD': macd,
+        'Signal': signal,
+        'Histogram': hist
+    })
+
+def calculate_bollinger_bands(data, period=20, num_std=2):
+    """Calculate Bollinger Bands."""
+    sma = data.rolling(window=period).mean()
+    std = data.rolling(window=period).std()
+    upper = sma + (std * num_std)
+    lower = sma - (std * num_std)
+    return pd.DataFrame({
+        'Upper': upper,
+        'Middle': sma,
+        'Lower': lower
+    })
+
+def add_indicators(df):
+    """Add all technical indicators to the dataframe."""
+    df = df.copy()
+
+    # Calculate indicators
+    df['SMA_20'] = calculate_sma(df['Close'], 20)
+    df['EMA_20'] = calculate_ema(df['Close'], 20)
+    df['RSI'] = calculate_rsi(df['Close'])
+
+    # MACD
+    macd_data = calculate_macd(df['Close'])
+    df['MACD'] = macd_data['MACD']
+    df['MACD_Signal'] = macd_data['Signal']
+    df['MACD_Hist'] = macd_data['Histogram']
+
+    # Bollinger Bands
+    bbands = calculate_bollinger_bands(df['Close'])
+    df['BB_Upper'] = bbands['Upper']
+    df['BB_Middle'] = bbands['Middle']
+    df['BB_Lower'] = bbands['Lower']
+
+    return df

utils/recommendation_engine.py

@@ -0,0 +1,95 @@
+import pandas as pd
+import numpy as np
+from utils.indicators import add_indicators
+from utils.signals import generate_signals, get_signal_summary
+
+def calculate_technical_score(df):
+    """Calculate technical analysis score based on multiple indicators."""
+    score = 0
+    latest = df.iloc[-1]
+    
+    # RSI Analysis (0-100)
+    rsi = latest['RSI']
+    if rsi < 30:  # Oversold
+        score += 20
+    elif rsi > 70:  # Overbought
+        score -= 20
+    else:  # Neutral
+        score += 10
+    
+    # MACD Analysis
+    if latest['MACD'] > latest['MACD_Signal']:  # Bullish crossover
+        score += 20
+    elif latest['MACD'] < latest['MACD_Signal']:  # Bearish crossover
+        score -= 20
+        
+    # Moving Average Analysis
+    if latest['Close'] > latest['SMA_20']:  # Above MA
+        score += 15
+    else:  # Below MA
+        score -= 15
+        
+    # Bollinger Bands Analysis
+    if latest['Close'] < latest['BB_Lower']:  # Oversold
+        score += 15
+    elif latest['Close'] > latest['BB_Upper']:  # Overbought
+        score -= 15
+        
+    # Volume Analysis
+    vol_sma = df['Volume'].rolling(window=20).mean().iloc[-1]
+    if latest['Volume'] > vol_sma * 1.5:  # High volume
+        score += 10
+        
+    return max(min(score, 100), -100)  # Normalize between -100 and 100
+
+def get_recommendation(score):
+    """Convert technical score to recommendation."""
+    if score >= 50:
+        return 'Strong Buy'
+    elif score >= 20:
+        return 'Buy'
+    elif score <= -50:
+        return 'Strong Sell'
+    elif score <= -20:
+        return 'Sell'
+    else:
+        return 'Hold'
+
+def get_confidence_level(score):
+    """Calculate confidence level based on absolute score."""
+    abs_score = abs(score)
+    if abs_score >= 70:
+        return 'High'
+    elif abs_score >= 40:
+        return 'Medium'
+    else:
+        return 'Low'
+
+def analyze_stock(symbol, df):
+    """Generate comprehensive stock analysis and recommendation."""
+    try:
+        # Add technical indicators
+        df = add_indicators(df)
+        
+        # Generate signals
+        signals = generate_signals(df)
+        signal_summary = get_signal_summary(signals)
+        
+        # Calculate technical score
+        tech_score = calculate_technical_score(df)
+        
+        # Generate recommendation
+        recommendation = get_recommendation(tech_score)
+        confidence = get_confidence_level(tech_score)
+        
+        return {
+            'symbol': symbol,
+            'recommendation': recommendation,
+            'technical_score': tech_score,
+            'confidence': confidence,
+            'signal_summary': signal_summary,
+            'last_price': df['Close'].iloc[-1],
+            'price_change': ((df['Close'].iloc[-1] / df['Close'].iloc[-2]) - 1) * 100
+        }
+    except Exception as e:
+        return None

utils/signals.py

@@ -0,0 +1,52 @@
+import numpy as np
+import pandas as pd
+
+def generate_signals(df):
+    """Generate trading signals based on technical indicators."""
+    signals = pd.DataFrame(index=df.index)
+    
+    # RSI Signals
+    signals['RSI_Signal'] = 'Neutral'
+    signals.loc[df['RSI'] < 30, 'RSI_Signal'] = 'Oversold'
+    signals.loc[df['RSI'] > 70, 'RSI_Signal'] = 'Overbought'
+    
+    # MACD Signals
+    signals['MACD_Signal'] = 'Neutral'
+    signals.loc[df['MACD'] > df['MACD_Signal'], 'MACD_Signal'] = 'Buy'
+    signals.loc[df['MACD'] < df['MACD_Signal'], 'MACD_Signal'] = 'Sell'
+    
+    # Bollinger Bands Signals
+    signals['BB_Signal'] = 'Neutral'
+    signals.loc[df['Close'] < df['BB_Lower'], 'BB_Signal'] = 'Oversold'
+    signals.loc[df['Close'] > df['BB_Upper'], 'BB_Signal'] = 'Overbought'
+    
+    # Moving Average Signals
+    signals['MA_Signal'] = 'Neutral'
+    signals.loc[df['Close'] > df['SMA_20'], 'MA_Signal'] = 'Bullish'
+    signals.loc[df['Close'] < df['SMA_20'], 'MA_Signal'] = 'Bearish'
+    
+    return signals
+
+def get_signal_summary(signals):
+    """Generate a summary of current signals."""
+    latest_signals = signals.iloc[-1]
+    
+    summary = {
+        'RSI': latest_signals['RSI_Signal'],
+        'MACD': latest_signals['MACD_Signal'],
+        'Bollinger': latest_signals['BB_Signal'],
+        'Moving Average': latest_signals['MA_Signal']
+    }
+    
+    # Overall sentiment
+    bullish_count = sum(1 for signal in summary.values() if signal in ['Buy', 'Bullish', 'Oversold'])
+    bearish_count = sum(1 for signal in summary.values() if signal in ['Sell', 'Bearish', 'Overbought'])
+    
+    if bullish_count > bearish_count:
+        summary['Overall'] = 'Bullish'
+    elif bearish_count > bullish_count:
+        summary['Overall'] = 'Bearish'
+    else:
+        summary['Overall'] = 'Neutral'
+    
+    return summary

utils/stock_data.py

@@ -0,0 +1,50 @@
+import yfinance as yf
+import pandas as pd
+from datetime import datetime, timedelta
+
+def get_stock_data(symbol, period='1y', interval='1d'):
+    """Fetch stock data from yfinance."""
+    try:
+        # Add .NS suffix for NSE stocks
+        ticker = yf.Ticker(f"{symbol}.NS")
+        df = ticker.history(period=period, interval=interval)
+        
+        if df.empty:
+            return None, "No data available for this symbol"
+        
+        return df, None
+    except Exception as e:
+        return None, f"Error fetching data: {str(e)}"
+
+def get_company_info(symbol):
+    """Get company information."""
+    try:
+        ticker = yf.Ticker(f"{symbol}.NS")
+        info = ticker.info
+        return {
+            'name': info.get('longName', symbol),
+            'sector': info.get('sector', 'N/A'),
+            'industry': info.get('industry', 'N/A'),
+            'market_cap': info.get('marketCap', 'N/A'),
+            'volume': info.get('volume', 'N/A')
+        }
+    except:
+        return {
+            'name': symbol,
+            'sector': 'N/A',
+            'industry': 'N/A',
+            'market_cap': 'N/A',
+            'volume': 'N/A'
+        }
+
+def format_number(number):
+    """Format large numbers to readable format."""
+    if not isinstance(number, (int, float)) or pd.isna(number):
+        return 'N/A'
+    
+    if number >= 1e9:
+        return f'₹{number/1e9:.2f}B'
+    elif number >= 1e6:
+        return f'₹{number/1e6:.2f}M'
+    else:
+        return f'₹{number:,.2f}'