added new files

files to run the AI analyser

.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
+stock_trading.db filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ReadMe.md

@@ -0,0 +1,112 @@
+# 📈 StockSignalAI
+
+AI-powered stock analysis and signal generation tool using Streamlit.
+
+---
+
+## 🚀 Features
+
+- Live stock data via Yahoo Finance
+- Technical indicators (e.g., RSI, MACD, EMA)
+- ML-based trading signal generator
+- Model training and evaluation
+- Interactive UI with Streamlit
+- SQLite-based data storage
+
+---
+
+## ⚙️ Setup Instructions
+
+### 1. Clone the Repository
+
+```bash
+git clone https://github.com/yourusername/StockSignalAI.git
+cd StockSignalAI
+
+
+## 2. Create Virtual Environment (optional but recommended)
+
+python3 -m venv venv
+source venv/bin/activate   # For macOS/Linux
+venv\Scripts\activate      # For Windows
+3. Install Dependencies
+
+pip install -r requirements.txt
+If you don’t have a requirements.txt, you can create one:
+
+txt
+Copy
+Edit
+yfinance
+pandas
+numpy
+matplotlib
+scikit-learn
+streamlit
+ta
+Save the above as requirements.txt, then run:
+
+
+pip install -r requirements.txt
+🖥️ Run the App
+Use Streamlit, not Python directly:
+
+
+streamlit run app.py
+💡 If Port 8501 is Busy
+
+streamlit run app.py --server.port 8888
+🧠 Notes
+Session State Initialization
+Before using any Streamlit session state variables (like model), initialize them at the start of the app:
+
+
+if "model" not in st.session_state:
+    st.session_state.model = None
+Add similar blocks for other keys like data, stock_symbol, etc.
+
+🗃️ Database Tables Used
+Your app uses the following tables:
+
+stock_data
+
+technical_indicators
+
+trading_signals
+
+model_metrics
+
+Ensure your SQLite DB or ORM setup creates them before use.
+
+🔧 Project Structure (Example)
+
+StockSignalAI/
+├── app.py
+├── requirements.txt
+├── data/
+│   └── stocks.db
+├── models/
+│   └── trained_models.pkl
+└── README.md
+📌 
+
+TODO / Future Enhancements
+Add backtesting module
+
+Save models per stock  - this is done 
+
+Upload and analyze user CSV data
+
+Add performance metrics dashboard
+
+Email/SMS alerts on new signals
+
+🙌 Acknowledgments
+yfinance
+
+ta-lib
+
+Streamlit
+
+scikit-learn
+

app.py

@@ -0,0 +1,534 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import yfinance as yf
+import pickle
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import os
+from datetime import datetime, timedelta
+import warnings
+warnings.filterwarnings('ignore')
+
+# Import custom modules
+from data_processor import DataProcessor
+from technical_indicators import TechnicalIndicators
+from model_trainer import ModelTrainer
+from database import DatabaseManager
+
+# Configure page
+st.set_page_config(
+    page_title="AI Stock Trading Signals",
+    page_icon="📈",
+    layout="wide"
+)
+
+# Initialize session state
+if 'model_trained' not in st.session_state:
+    st.session_state.model_trained = False
+if 'model' not in st.session_state:
+    st.session_state.model = None
+if 'feature_columns' not in st.session_state:
+    st.session_state.feature_columns = None
+if 'db_manager' not in st.session_state:
+    st.session_state.db_manager = DatabaseManager()
+
+def load_or_train_model(stock_symbol):
+    """Load existing model or train new one"""
+    model_file = f"model_{stock_symbol.replace('.', '_')}.pkl"
+    
+    if os.path.exists(model_file) and st.session_state.model is None:
+        try:
+            with open(model_file, 'rb') as f:
+                model_data = pickle.load(f)
+                st.session_state.model = model_data['model']
+                st.session_state.feature_columns = model_data['feature_columns']
+                st.session_state.model_trained = True
+                return True
+        except Exception as e:
+            st.error(f"Error loading model: {str(e)}")
+            return False
+    
+    return st.session_state.model_trained
+
+def train_new_model(stock_symbol):
+    """Train a new model for the selected stock"""
+    with st.spinner("Training AI model... This may take a few minutes."):
+        try:
+            # Initialize components
+            data_processor = DataProcessor()
+            tech_indicators = TechnicalIndicators()
+            model_trainer = ModelTrainer()
+            
+            # Download and process data
+            data = data_processor.download_stock_data(stock_symbol, period="1y")
+            if data is None or len(data) < 100:
+                st.error("Insufficient data for training. Please try another stock.")
+                return False
+            
+            # Save stock data to database
+            st.session_state.db_manager.save_stock_data(stock_symbol, data)
+            
+            # Calculate technical indicators
+            data_with_indicators = tech_indicators.calculate_all_indicators(data)
+            
+            # Save technical indicators to database
+            st.session_state.db_manager.save_technical_indicators(stock_symbol, data_with_indicators)
+            
+            # Prepare features and labels
+            features, labels = data_processor.prepare_features_and_labels(data_with_indicators)
+            
+            if len(features) == 0:
+                st.error("No valid features could be generated for training.")
+                return False
+            
+            # Train model
+            model, feature_columns, metrics = model_trainer.train_model(features, labels)
+            
+            # Save model performance to database
+            st.session_state.db_manager.save_model_metrics(
+                stock_symbol, 
+                "RandomForest", 
+                metrics['accuracy'], 
+                metrics['precision'], 
+                metrics['recall'],
+                len(feature_columns),
+                len(features)
+            )
+            
+            # Save model
+            model_file = f"model_{stock_symbol.replace('.', '_')}.pkl"
+            with open(model_file, 'wb') as f:
+                pickle.dump({
+                    'model': model,
+                    'feature_columns': feature_columns,
+                    'metrics': metrics
+                }, f)
+            
+            # Update session state
+            st.session_state.model = model
+            st.session_state.feature_columns = feature_columns
+            st.session_state.model_trained = True
+            
+            # Display training metrics
+            st.success("Model trained successfully!")
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Accuracy", f"{metrics['accuracy']:.3f}")
+            with col2:
+                st.metric("Precision", f"{metrics['precision']:.3f}")
+            with col3:
+                st.metric("Recall", f"{metrics['recall']:.3f}")
+            
+            return True
+            
+        except Exception as e:
+            st.error(f"Error training model: {str(e)}")
+            return False
+
+def get_live_price(stock_symbol):
+    """Get live stock price"""
+    try:
+        # Try to get live price using nsepython
+        try:
+            from nsepython import nsefetch
+            # Extract stock name without .NS suffix
+            stock_name = stock_symbol.replace('.NS', '')
+            url = f"https://www.nseindia.com/api/quote-equity?symbol={stock_name}"
+            live_data = nsefetch(url)
+            if live_data and 'priceInfo' in live_data and 'lastPrice' in live_data['priceInfo']:
+                return float(live_data['priceInfo']['lastPrice'])
+        except:
+            pass
+        
+        # Fallback to yfinance
+        ticker = yf.Ticker(stock_symbol)
+        data = ticker.history(period="1d", interval="1m")
+        if not data.empty:
+            return float(data['Close'].iloc[-1])
+        
+        return None
+    except Exception as e:
+        st.warning(f"Could not fetch live price: {str(e)}")
+        return None
+
+def predict_signal(stock_symbol):
+    """Predict trading signal for the stock"""
+    try:
+        # Initialize components
+        data_processor = DataProcessor()
+        tech_indicators = TechnicalIndicators()
+        
+        # Get recent data for prediction
+        data = data_processor.download_stock_data(stock_symbol, period="3mo")
+        if data is None or len(data) < 50:
+            return None, "Insufficient data for prediction"
+        
+        # Calculate technical indicators
+        data_with_indicators = tech_indicators.calculate_all_indicators(data)
+        
+        # Get latest features
+        latest_features = data_processor.get_latest_features(data_with_indicators, st.session_state.feature_columns)
+        
+        if latest_features is None:
+            return None, "Could not extract features from latest data"
+        
+        # Make prediction
+        prediction = st.session_state.model.predict([latest_features])[0]
+        prediction_proba = st.session_state.model.predict_proba([latest_features])[0]
+        
+        # Convert prediction to signal
+        signal_map = {-1: "SELL", 0: "HOLD", 1: "BUY"}
+        signal = signal_map.get(prediction, "HOLD")
+        confidence = max(prediction_proba)
+        
+        # Get current live price for saving to database
+        live_price = get_live_price(stock_symbol)
+        
+        # Save trading signal to database
+        if live_price and hasattr(st.session_state, 'db_manager') and st.session_state.db_manager:
+            try:
+                st.session_state.db_manager.save_trading_signal(
+                    stock_symbol, signal, confidence, live_price, model_version="v1.0"
+                )
+            except Exception as e:
+                print(f"Error saving trading signal: {str(e)}")
+        
+        return {
+            'signal': signal,
+            'confidence': confidence,
+            'prediction': prediction,
+            'probabilities': prediction_proba
+        }, None
+        
+    except Exception as e:
+        return None, f"Error making prediction: {str(e)}"
+
+def create_price_chart(stock_symbol):
+    """Create interactive price chart with technical indicators"""
+    try:
+        # Initialize components
+        data_processor = DataProcessor()
+        tech_indicators = TechnicalIndicators()
+        
+        # Get data for last 30 days
+        data = data_processor.download_stock_data(stock_symbol, period="2mo")
+        if data is None:
+            return None
+        
+        # Calculate technical indicators
+        data_with_indicators = tech_indicators.calculate_all_indicators(data)
+        
+        # Get last 30 days
+        data_chart = data_with_indicators.tail(30).copy()
+        
+        # Create subplots
+        fig = make_subplots(
+            rows=4, cols=1,
+           # shared_xaxis=True,
+            shared_xaxes=True,
+            vertical_spacing=0.03,
+            subplot_titles=('Price & Bollinger Bands', 'RSI', 'MACD', 'Volume'),
+            row_heights=[0.5, 0.2, 0.2, 0.1]
+        )
+        
+        # Price and Bollinger Bands
+        fig.add_trace(
+            go.Candlestick(
+                x=data_chart.index,
+                open=data_chart['Open'],
+                high=data_chart['High'],
+                low=data_chart['Low'],
+                close=data_chart['Close'],
+                name='Price'
+            ), row=1, col=1
+        )
+        
+        # Bollinger Bands
+        if 'BB_upper' in data_chart.columns:
+            fig.add_trace(
+                go.Scatter(x=data_chart.index, y=data_chart['BB_upper'], 
+                          name='BB Upper', line=dict(color='red', width=1)), row=1, col=1
+            )
+            fig.add_trace(
+                go.Scatter(x=data_chart.index, y=data_chart['BB_middle'], 
+                          name='BB Middle', line=dict(color='blue', width=1)), row=1, col=1
+            )
+            fig.add_trace(
+                go.Scatter(x=data_chart.index, y=data_chart['BB_lower'], 
+                          name='BB Lower', line=dict(color='red', width=1)), row=1, col=1
+            )
+        
+        # EMA
+        if 'EMA_20' in data_chart.columns:
+            fig.add_trace(
+                go.Scatter(x=data_chart.index, y=data_chart['EMA_20'], 
+                          name='EMA 20', line=dict(color='orange', width=2)), row=1, col=1
+            )
+        
+        # RSI
+        if 'RSI' in data_chart.columns:
+            fig.add_trace(
+                go.Scatter(x=data_chart.index, y=data_chart['RSI'], 
+                          name='RSI', line=dict(color='purple')), row=2, col=1
+            )
+            # RSI overbought/oversold lines
+            fig.add_hline(y=70, line_dash="dash", line_color="red", row=2, col=1)
+            fig.add_hline(y=30, line_dash="dash", line_color="green", row=2, col=1)
+        
+        # MACD
+        if 'MACD' in data_chart.columns:
+            fig.add_trace(
+                go.Scatter(x=data_chart.index, y=data_chart['MACD'], 
+                          name='MACD', line=dict(color='blue')), row=3, col=1
+            )
+            if 'MACD_signal' in data_chart.columns:
+                fig.add_trace(
+                    go.Scatter(x=data_chart.index, y=data_chart['MACD_signal'], 
+                              name='MACD Signal', line=dict(color='red')), row=3, col=1
+                )
+        
+        # Volume
+        fig.add_trace(
+            go.Bar(x=data_chart.index, y=data_chart['Volume'], 
+                   name='Volume', marker_color='lightblue'), row=4, col=1
+        )
+        
+        # Update layout
+        fig.update_layout(
+            title=f"{stock_symbol} - Price Chart with Technical Indicators",
+            xaxis_rangeslider_visible=False,
+            height=800,
+            showlegend=True
+        )
+        
+        # Update y-axis labels
+        fig.update_yaxes(title_text="Price (₹)", row=1, col=1)
+        fig.update_yaxes(title_text="RSI", row=2, col=1)
+        fig.update_yaxes(title_text="MACD", row=3, col=1)
+        fig.update_yaxes(title_text="Volume", row=4, col=1)
+        
+        return fig
+        
+    except Exception as e:
+        st.error(f"Error creating chart: {str(e)}")
+        return None
+
+def main():
+    st.title("📈 AI-Powered Stock Trading Signals")
+    st.markdown("### NSE Stock Analysis with Machine Learning")
+    
+    # Initialize database manager early
+    if 'db_manager' not in st.session_state:
+        try:
+            from database import DatabaseManager
+            st.session_state.db_manager = DatabaseManager()
+            st.success("Database initialized successfully")
+        except Exception as e:
+            st.error(f"Database initialization failed: {str(e)}")
+            st.session_state.db_manager = None
+    
+    # Sidebar for stock selection
+    st.sidebar.header("Stock Selection")
+    
+    # Expanded NSE stock options
+    stock_options = {
+        "Reliance Industries": "RELIANCE.NS",
+        "Tata Consultancy Services": "TCS.NS", 
+        "Infosys": "INFY.NS",
+        "HDFC Bank": "HDFCBANK.NS",
+        "ICICI Bank": "ICICIBANK.NS",
+        "State Bank of India": "SBIN.NS",
+        "ITC Limited": "ITC.NS",
+        "Hindustan Unilever": "HINDUNILVR.NS",
+        "Larsen & Toubro": "LT.NS",
+        "Axis Bank": "AXISBANK.NS",
+        "Kotak Mahindra Bank": "KOTAKBANK.NS",
+        "Wipro": "WIPRO.NS",
+        "Tech Mahindra": "TECHM.NS",
+        "Bharti Airtel": "BHARTIARTL.NS",
+        "Asian Paints": "ASIANPAINT.NS",
+        "Maruti Suzuki": "MARUTI.NS",
+        "Bajaj Finance": "BAJFINANCE.NS",
+        "NTPC": "NTPC.NS",
+        "Power Grid Corp": "POWERGRID.NS",
+        "Tata Steel": "TATASTEEL.NS"
+    }
+    
+    # Option to enter custom stock symbol
+    st.sidebar.subheader("Or Enter Custom Stock")
+    custom_stock = st.sidebar.text_input(
+        "Enter NSE stock symbol (e.g., ADANIPORTS.NS):",
+        placeholder="SYMBOL.NS"
+    )
+    
+    # Determine selected stock
+    if custom_stock and custom_stock.strip():
+        if not custom_stock.endswith('.NS'):
+            custom_stock += '.NS'
+        selected_stock = custom_stock.upper()
+        selected_stock_name = f"Custom: {selected_stock}"
+    else:
+        selected_stock_name = st.sidebar.selectbox(
+            "Choose a stock:",
+            list(stock_options.keys())
+        )
+        selected_stock = stock_options[selected_stock_name]
+    
+    # Model training section
+    st.sidebar.header("Model Management")
+    
+    # Check if model exists
+    model_exists = load_or_train_model(selected_stock)
+    
+    if not model_exists:
+        st.sidebar.warning("No trained model found for this stock.")
+        if st.sidebar.button("Train New Model"):
+            train_new_model(selected_stock)
+    else:
+        st.sidebar.success("Model loaded successfully!")
+        if st.sidebar.button("Retrain Model"):
+            st.session_state.model = None
+            st.session_state.model_trained = False
+            train_new_model(selected_stock)
+    
+    # Main content
+    if st.session_state.model_trained and st.session_state.model is not None:
+        
+        # Live price section
+        st.header("📊 Live Market Data")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("🔄 Get Live Price", type="primary"):
+                live_price = get_live_price(selected_stock)
+                if live_price:
+                    st.metric("Live Price (LTP)", f"₹{live_price:.2f}")
+                else:
+                    st.warning("Could not fetch live price")
+        
+        # Prediction section
+        st.header("🤖 AI Trading Signal")
+        
+        if st.button("🎯 Get Trading Signal", type="primary"):
+            prediction_result, error = predict_signal(selected_stock)
+            
+            if prediction_result:
+                signal = prediction_result['signal']
+                confidence = prediction_result['confidence']
+                
+                # Display signal with color coding
+                if signal == "BUY":
+                    st.success(f"🟢 **{signal}** Signal")
+                elif signal == "SELL":
+                    st.error(f"🔴 **{signal}** Signal")
+                else:
+                    st.info(f"🟡 **{signal}** Signal")
+                
+                # Display confidence and probabilities
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.metric("Confidence", f"{confidence:.1%}")
+                
+                with col2:
+                    prob_df = pd.DataFrame({
+                        'Signal': ['SELL', 'HOLD', 'BUY'],
+                        'Probability': prediction_result['probabilities']
+                    })
+                    st.dataframe(prob_df, hide_index=True)
+                
+            else:
+                st.error(f"Prediction failed: {error}")
+        
+        # Chart section
+        st.header("📈 Technical Analysis Chart")
+        
+        if st.button("📊 Generate Chart"):
+            chart = create_price_chart(selected_stock)
+            if chart:
+                st.plotly_chart(chart, use_container_width=True)
+        
+        # Additional information
+        st.header("ℹ️ Model Information")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.info("**Features Used:**\n- RSI, EMA, MACD\n- Bollinger Bands\n- SMA, Stochastic\n- Williams %R, ATR")
+        
+        with col2:
+            st.info("**Signal Criteria:**\n- BUY: Expected 2%+ gain\n- SELL: Expected 2%+ loss\n- HOLD: Neutral expectation")
+    
+    else:
+        st.info("👆 Please train a model first using the sidebar to get started with AI-powered trading signals.")
+        
+        # Show sample data while waiting
+        st.header("📊 Sample Stock Data")
+        try:
+            data_processor = DataProcessor()
+            sample_data = data_processor.download_stock_data(selected_stock, period="1mo")
+            if sample_data is not None:
+                st.dataframe(sample_data.tail(10))
+        except:
+            st.warning("Could not load sample data")
+    
+    # Database Information Section
+    st.sidebar.header("📊 Database Status")
+    
+    # Database Console Link
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("### 🗄️ Database Console")
+    st.sidebar.markdown("Access the SQLite database console:")
+    st.sidebar.markdown("**[Open Database Console](http://localhost:5001)**")
+    st.sidebar.markdown("*View tables, run SQL queries, analyze trading data*")
+    st.sidebar.markdown("*Database file: `stock_trading.db`*")
+    st.sidebar.markdown("---")
+    
+    try:
+        if hasattr(st.session_state, 'db_manager') and st.session_state.db_manager:
+            db_stats = st.session_state.db_manager.get_database_stats()
+            if db_stats:
+                st.sidebar.metric("Stock Records", db_stats.get('total_stock_records', 0))
+                st.sidebar.metric("Trading Signals", db_stats.get('total_signals', 0))
+                st.sidebar.metric("Active Models", db_stats.get('active_models', 0))
+                st.sidebar.metric("Symbols Tracked", db_stats.get('symbols_tracked', 0))
+            else:
+                st.sidebar.info("Database ready - no data yet")
+        else:
+            st.sidebar.info("Database initializing...")
+    except Exception as e:
+        st.sidebar.warning("Database tables will be created when first used")
+    
+    # Trading History Section
+    if st.session_state.model_trained and hasattr(st.session_state, 'db_manager') and st.session_state.db_manager:
+        st.header("📈 Trading History")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("View Signal History"):
+                try:
+                    signal_history = st.session_state.db_manager.get_trading_signals_history(selected_stock)
+                    if not signal_history.empty:
+                        st.dataframe(signal_history.head(10))
+                    else:
+                        st.info("No trading signals found in database")
+                except Exception as e:
+                    st.error(f"Error loading signal history: {str(e)}")
+        
+        with col2:
+            if st.button("Model Performance"):
+                try:
+                    model_perf = st.session_state.db_manager.get_model_performance(selected_stock)
+                    if model_perf:
+                        st.json(model_perf)
+                    else:
+                        st.info("No model performance data found")
+                except Exception as e:
+                    st.error(f"Error loading model performance: {str(e)}")
+                    
+        # Database Console Access
+        st.markdown("---")
+        st.info("💡 **Tip**: Use the Database Console in the sidebar to view all stored data, run SQL queries, and analyze trading patterns across all stocks.")
+
+if __name__ == "__main__":
+    main()

data_processor.py

@@ -0,0 +1,127 @@
+import pandas as pd
+import numpy as np
+import yfinance as yf
+from datetime import datetime, timedelta
+import warnings
+warnings.filterwarnings('ignore')
+
+class DataProcessor:
+    def __init__(self):
+        pass
+    
+    def download_stock_data(self, symbol, period="3mo", interval="1d"):
+        """Download stock data using yfinance"""
+        try:
+            ticker = yf.Ticker(symbol)
+            data = ticker.history(period=period, interval=interval)
+            
+            if data.empty:
+                return None
+            
+            # Clean column names
+            data.columns = [col.title() for col in data.columns]
+            
+            # Remove timezone info for consistency
+            if data.index.tz is not None:
+                data.index = data.index.tz_localize(None)
+            
+            return data
+            
+        except Exception as e:
+            print(f"Error downloading data for {symbol}: {str(e)}")
+            return None
+    
+    def prepare_features_and_labels(self, data, future_days=3, threshold=0.02):
+        """Prepare features and labels for machine learning"""
+        try:
+            # Calculate future returns for labeling
+            data = data.copy()
+            data['Future_Return'] = data['Close'].pct_change(periods=future_days).shift(-future_days)
+            
+            # Create labels based on future returns
+            # 1 = BUY (expected gain > threshold)
+            # -1 = SELL (expected loss > threshold) 
+            # 0 = HOLD (neutral)
+            conditions = [
+                data['Future_Return'] > threshold,
+                data['Future_Return'] < -threshold
+            ]
+            choices = [1, -1]
+            data['Label'] = np.select(conditions, choices, default=0)
+            
+            # Select feature columns (all technical indicators)
+            feature_columns = [col for col in data.columns if col not in 
+                             ['Open', 'High', 'Low', 'Close', 'Volume', 'Future_Return', 'Label']]
+            
+            # Remove rows with NaN values
+            clean_data = data.dropna()
+            
+            if len(clean_data) == 0:
+                return pd.DataFrame(), pd.Series()
+            
+            # Prepare features and labels
+            features = clean_data[feature_columns]
+            labels = clean_data['Label']
+            
+            return features, labels
+            
+        except Exception as e:
+            print(f"Error preparing features and labels: {str(e)}")
+            return pd.DataFrame(), pd.Series()
+    
+    def get_latest_features(self, data, feature_columns):
+        """Extract latest features for prediction"""
+        try:
+            if data.empty or not feature_columns:
+                return None
+            
+            # Get the latest row with all required features
+            latest_data = data[feature_columns].dropna()
+            
+            if latest_data.empty:
+                return None
+            
+            # Return the latest row as a list
+            return latest_data.iloc[-1].values.tolist()
+            
+        except Exception as e:
+            print(f"Error extracting latest features: {str(e)}")
+            return None
+    
+    def calculate_returns(self, data, periods=[1, 3, 5]):
+        """Calculate returns for different periods"""
+        try:
+            returns_data = data.copy()
+            
+            for period in periods:
+                returns_data[f'Return_{period}d'] = data['Close'].pct_change(periods=period)
+            
+            return returns_data
+            
+        except Exception as e:
+            print(f"Error calculating returns: {str(e)}")
+            return data
+    
+    def add_price_features(self, data):
+        """Add additional price-based features"""
+        try:
+            enhanced_data = data.copy()
+            
+            # Price position within daily range
+            enhanced_data['Price_Position'] = (data['Close'] - data['Low']) / (data['High'] - data['Low'])
+            enhanced_data['Price_Position'].fillna(0.5, inplace=True)
+            
+            # Gap from previous close
+            enhanced_data['Gap'] = (data['Open'] - data['Close'].shift(1)) / data['Close'].shift(1)
+            
+            # Intraday return
+            enhanced_data['Intraday_Return'] = (data['Close'] - data['Open']) / data['Open']
+            
+            # High-Low spread
+            enhanced_data['HL_Spread'] = (data['High'] - data['Low']) / data['Close']
+            
+            return enhanced_data
+            
+        except Exception as e:
+            print(f"Error adding price features: {str(e)}")
+            return data

database.py

@@ -0,0 +1,266 @@
+import sqlalchemy as sa
+from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, Text, Boolean, text
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from datetime import datetime
+import json
+import pandas as pd
+
+Base = declarative_base()
+
+class StockData(Base):
+    __tablename__ = 'stock_data'
+    
+    id = Column(Integer, primary_key=True)
+    symbol = Column(String(20), nullable=False)
+    date = Column(DateTime, nullable=False)
+    open_price = Column(Float)
+    high_price = Column(Float)
+    low_price = Column(Float)
+    close_price = Column(Float)
+    volume = Column(Integer)
+    created_at = Column(DateTime, default=datetime.now)
+
+class TechnicalIndicators(Base):
+    __tablename__ = 'technical_indicators'
+    
+    id = Column(Integer, primary_key=True)
+    symbol = Column(String(20), nullable=False)
+    date = Column(DateTime, nullable=False)
+    rsi = Column(Float)
+    macd = Column(Float)
+    macd_signal = Column(Float)
+    bb_upper = Column(Float)
+    bb_middle = Column(Float)
+    bb_lower = Column(Float)
+    ema_20 = Column(Float)
+    sma_20 = Column(Float)
+    sma_50 = Column(Float)
+    stoch_k = Column(Float)
+    williams_r = Column(Float)
+    atr = Column(Float)
+    created_at = Column(DateTime, default=datetime.now)
+
+class TradingSignals(Base):
+    __tablename__ = 'trading_signals'
+    
+    id = Column(Integer, primary_key=True)
+    symbol = Column(String(20), nullable=False)
+    signal_date = Column(DateTime, nullable=False)
+    signal = Column(String(10))  # BUY, SELL, HOLD
+    confidence = Column(Float)
+    live_price = Column(Float)
+    predicted_return = Column(Float)
+    model_version = Column(String(50))
+    created_at = Column(DateTime, default=datetime.now)
+
+class ModelMetrics(Base):
+    __tablename__ = 'model_metrics'
+    
+    id = Column(Integer, primary_key=True)
+    symbol = Column(String(20), nullable=False)
+    model_type = Column(String(50))
+    accuracy = Column(Float)
+    precision_score = Column(Float)
+    recall_score = Column(Float)
+    training_date = Column(DateTime, default=datetime.now)
+    feature_count = Column(Integer)
+    training_samples = Column(Integer)
+    is_active = Column(Boolean, default=True)
+
+class DatabaseManager:
+    def __init__(self):
+        # SQLite persistent database for better data retention
+        self.engine = create_engine('sqlite:///stock_trading.db', echo=False)
+        try:
+            # Create all tables
+            Base.metadata.create_all(self.engine)
+            Session = sessionmaker(bind=self.engine)
+            self.session = Session()
+            
+            # Verify tables were created
+            with self.engine.connect() as conn:
+                result = conn.execute(text("SELECT name FROM sqlite_master WHERE type='table'"))
+                tables = [row[0] for row in result]
+                print(f"Database tables available: {tables}")
+            
+        except Exception as e:
+            print(f"Database initialization error: {str(e)}")
+            raise e
+    
+    def save_stock_data(self, symbol, data_df):
+        """Save stock OHLCV data to database"""
+        try:
+            for index, row in data_df.iterrows():
+                stock_record = StockData(
+                    symbol=symbol,
+                    date=index,
+                    open_price=float(row['Open']),
+                    high_price=float(row['High']),
+                    low_price=float(row['Low']),
+                    close_price=float(row['Close']),
+                    volume=int(row['Volume'])
+                )
+                self.session.merge(stock_record)
+            self.session.commit()
+            return True
+        except Exception as e:
+            self.session.rollback()
+            print(f"Error saving stock data: {str(e)}")
+            return False
+    
+    def save_technical_indicators(self, symbol, indicators_df):
+        """Save technical indicators to database"""
+        try:
+            for index, row in indicators_df.iterrows():
+                indicator_record = TechnicalIndicators(
+                    symbol=symbol,
+                    date=index,
+                    rsi=float(row.get('RSI', 0)) if pd.notna(row.get('RSI', 0)) else None,
+                    macd=float(row.get('MACD', 0)) if pd.notna(row.get('MACD', 0)) else None,
+                    macd_signal=float(row.get('MACD_signal', 0)) if pd.notna(row.get('MACD_signal', 0)) else None,
+                    bb_upper=float(row.get('BB_upper', 0)) if pd.notna(row.get('BB_upper', 0)) else None,
+                    bb_middle=float(row.get('BB_middle', 0)) if pd.notna(row.get('BB_middle', 0)) else None,
+                    bb_lower=float(row.get('BB_lower', 0)) if pd.notna(row.get('BB_lower', 0)) else None,
+                    ema_20=float(row.get('EMA_20', 0)) if pd.notna(row.get('EMA_20', 0)) else None,
+                    sma_20=float(row.get('SMA_20', 0)) if pd.notna(row.get('SMA_20', 0)) else None,
+                    sma_50=float(row.get('SMA_50', 0)) if pd.notna(row.get('SMA_50', 0)) else None,
+                    stoch_k=float(row.get('Stoch_K', 0)) if pd.notna(row.get('Stoch_K', 0)) else None,
+                    williams_r=float(row.get('Williams_R', 0)) if pd.notna(row.get('Williams_R', 0)) else None,
+                    atr=float(row.get('ATR', 0)) if pd.notna(row.get('ATR', 0)) else None
+                )
+                self.session.merge(indicator_record)
+            self.session.commit()
+            return True
+        except Exception as e:
+            self.session.rollback()
+            print(f"Error saving technical indicators: {str(e)}")
+            return False
+    
+    def save_trading_signal(self, symbol, signal, confidence, live_price, predicted_return=None, model_version="v1.0"):
+        """Save trading signal to database"""
+        try:
+            signal_record = TradingSignals(
+                symbol=symbol,
+                signal_date=datetime.now(),
+                signal=signal,
+                confidence=confidence,
+                live_price=live_price,
+                predicted_return=predicted_return,
+                model_version=model_version
+            )
+            self.session.add(signal_record)
+            self.session.commit()
+            return True
+        except Exception as e:
+            self.session.rollback()
+            print(f"Error saving trading signal: {str(e)}")
+            return False
+    
+    def save_model_metrics(self, symbol, model_type, accuracy, precision, recall, feature_count, training_samples):
+        """Save model performance metrics to database"""
+        try:
+            # Deactivate old models for this symbol
+            old_models = self.session.query(ModelMetrics).filter_by(symbol=symbol, is_active=True).all()
+            for model in old_models:
+                model.is_active = False
+            
+            # Add new model metrics
+            metrics_record = ModelMetrics(
+                symbol=symbol,
+                model_type=model_type,
+                accuracy=accuracy,
+                precision_score=precision,
+                recall_score=recall,
+                feature_count=feature_count,
+                training_samples=training_samples,
+                is_active=True
+            )
+            self.session.add(metrics_record)
+            self.session.commit()
+            return True
+        except Exception as e:
+            self.session.rollback()
+            print(f"Error saving model metrics: {str(e)}")
+            return False
+    
+    def get_latest_stock_data(self, symbol, limit=100):
+        """Get latest stock data from database"""
+        try:
+            records = self.session.query(StockData).filter_by(symbol=symbol)\
+                     .order_by(StockData.date.desc()).limit(limit).all()
+            
+            data = []
+            for record in records:
+                data.append({
+                    'Date': record.date,
+                    'Open': record.open_price,
+                    'High': record.high_price,
+                    'Low': record.low_price,
+                    'Close': record.close_price,
+                    'Volume': record.volume
+                })
+            
+            return pd.DataFrame(data).set_index('Date').sort_index()
+        except Exception as e:
+            print(f"Error getting stock data: {str(e)}")
+            return pd.DataFrame()
+    
+    def get_trading_signals_history(self, symbol, limit=50):
+        """Get trading signals history for a symbol"""
+        try:
+            records = self.session.query(TradingSignals).filter_by(symbol=symbol)\
+                     .order_by(TradingSignals.signal_date.desc()).limit(limit).all()
+            
+            signals = []
+            for record in records:
+                signals.append({
+                    'Date': record.signal_date,
+                    'Signal': record.signal,
+                    'Confidence': record.confidence,
+                    'Live Price': record.live_price,
+                    'Model Version': record.model_version
+                })
+            
+            return pd.DataFrame(signals)
+        except Exception as e:
+            print(f"Error getting trading signals: {str(e)}")
+            return pd.DataFrame()
+    
+    def get_model_performance(self, symbol):
+        """Get current model performance metrics"""
+        try:
+            record = self.session.query(ModelMetrics).filter_by(symbol=symbol, is_active=True).first()
+            if record:
+                return {
+                    'model_type': record.model_type,
+                    'accuracy': record.accuracy,
+                    'precision': record.precision_score,
+                    'recall': record.recall_score,
+                    'training_date': record.training_date,
+                    'feature_count': record.feature_count,
+                    'training_samples': record.training_samples
+                }
+            return None
+        except Exception as e:
+            print(f"Error getting model performance: {str(e)}")
+            return None
+    
+    def get_database_stats(self):
+        """Get database statistics"""
+        try:
+            stats = {
+                'total_stock_records': self.session.query(StockData).count(),
+                'total_indicators': self.session.query(TechnicalIndicators).count(),
+                'total_signals': self.session.query(TradingSignals).count(),
+                'active_models': self.session.query(ModelMetrics).filter_by(is_active=True).count(),
+                'symbols_tracked': len(self.session.query(StockData.symbol).distinct().all())
+            }
+            return stats
+        except Exception as e:
+            print(f"Error getting database stats: {str(e)}")
+            return {}
+    
+    def close(self):
+        """Close database connection"""
+        self.session.close()

database_console.py

@@ -0,0 +1,344 @@
+import streamlit as st
+import pandas as pd
+from database import DatabaseManager
+from sqlalchemy import text
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+
+def database_console():
+    """Database console interface for viewing and managing stock data"""
+    st.title("📊 Database Console - Stock Trading Data")
+    st.markdown("### SQLite Database Management")
+    
+    # Show database file location
+    st.info("Database file: stock_trading.db (persistent storage)")
+    
+    # Initialize database
+    try:
+        if 'console_db' not in st.session_state:
+            from database import DatabaseManager
+            st.session_state.console_db = DatabaseManager()
+        db = st.session_state.console_db
+        st.success("Database connection established")
+        
+        # Show database file size if it exists
+        import os
+        if os.path.exists('stock_trading.db'):
+            size = os.path.getsize('stock_trading.db')
+            st.metric("Database Size", f"{size / 1024:.1f} KB")
+            
+    except Exception as e:
+        st.error(f"Database connection failed: {str(e)}")
+        return
+    
+    # Sidebar navigation
+    st.sidebar.header("Database Navigation")
+    section = st.sidebar.selectbox(
+        "Select Section:",
+        ["Overview", "Stock Data", "Technical Indicators", "Trading Signals", "Model Metrics", "SQL Query"]
+    )
+    
+    if section == "Overview":
+        show_database_overview(db)
+    elif section == "Stock Data":
+        show_stock_data(db)
+    elif section == "Technical Indicators":
+        show_technical_indicators(db)
+    elif section == "Trading Signals":
+        show_trading_signals(db)
+    elif section == "Model Metrics":
+        show_model_metrics(db)
+    elif section == "SQL Query":
+        show_sql_interface(db)
+
+def show_database_overview(db):
+    """Show database overview and statistics"""
+    st.header("Database Overview")
+    
+    col1, col2, col3, col4 = st.columns(4)
+    
+    try:
+        # Get table counts
+        stock_count = db.session.execute(text("SELECT COUNT(*) FROM stock_data")).scalar()
+        indicator_count = db.session.execute(text("SELECT COUNT(*) FROM technical_indicators")).scalar()
+        signal_count = db.session.execute(text("SELECT COUNT(*) FROM trading_signals")).scalar()
+        model_count = db.session.execute(text("SELECT COUNT(*) FROM model_metrics")).scalar()
+        
+        with col1:
+            st.metric("Stock Records", stock_count)
+        with col2:
+            st.metric("Technical Indicators", indicator_count)
+        with col3:
+            st.metric("Trading Signals", signal_count)
+        with col4:
+            st.metric("Model Records", model_count)
+            
+    except Exception as e:
+        st.warning(f"Error getting counts: {str(e)}")
+        # Initialize tables if they don't exist
+        if st.button("Initialize Database Tables"):
+            initialize_database_tables(db)
+    
+    # Recent activity
+    st.subheader("Recent Activity")
+    try:
+        recent_signals = pd.read_sql("""
+            SELECT symbol, signal, confidence, live_price, created_at 
+            FROM trading_signals 
+            ORDER BY created_at DESC 
+            LIMIT 10
+        """, db.engine)
+        
+        if not recent_signals.empty:
+            st.dataframe(recent_signals)
+        else:
+            st.info("No recent trading signals found")
+            
+    except Exception as e:
+        st.info("No trading signals table found yet")
+
+def show_stock_data(db):
+    """Show stock OHLCV data"""
+    st.header("Stock Data (OHLCV)")
+    
+    # Stock selection
+    symbol = st.selectbox(
+        "Select Stock Symbol:",
+        ["RELIANCE.NS", "TCS.NS", "INFY.NS", "HDFCBANK.NS", "ICICIBANK.NS"]
+    )
+    
+    try:
+        # Get stock data
+        query = """
+            SELECT * FROM stock_data 
+            WHERE symbol = :symbol 
+            ORDER BY date DESC 
+            LIMIT 100
+        """
+        stock_data = pd.read_sql(query, db.engine, params={"symbol": symbol})
+        
+        if not stock_data.empty:
+            st.dataframe(stock_data)
+            
+            # Create price chart
+            fig = go.Figure()
+            fig.add_trace(go.Candlestick(
+                x=stock_data['date'],
+                open=stock_data['open_price'],
+                high=stock_data['high_price'],
+                low=stock_data['low_price'],
+                close=stock_data['close_price'],
+                name=symbol
+            ))
+            fig.update_layout(title=f"{symbol} - Price Chart", xaxis_title="Date", yaxis_title="Price (₹)")
+            st.plotly_chart(fig, use_container_width=True)
+            
+        else:
+            st.info(f"No stock data found for {symbol}")
+            if st.button(f"Load {symbol} Data"):
+                load_sample_data(db, symbol)
+                
+    except Exception as e:
+        st.error(f"Error loading stock data: {str(e)}")
+
+def show_technical_indicators(db):
+    """Show technical indicators data"""
+    st.header("Technical Indicators")
+    
+    symbol = st.selectbox(
+        "Select Stock:",
+        ["RELIANCE.NS", "TCS.NS", "INFY.NS", "HDFCBANK.NS", "ICICIBANK.NS"],
+        key="tech_symbol"
+    )
+    
+    try:
+        query = """
+            SELECT * FROM technical_indicators 
+            WHERE symbol = :symbol 
+            ORDER BY date DESC 
+            LIMIT 50
+        """
+        tech_data = pd.read_sql(query, db.engine, params={"symbol": symbol})
+        
+        if not tech_data.empty:
+            st.dataframe(tech_data)
+            
+            # Create indicators chart
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                if 'rsi' in tech_data.columns:
+                    fig_rsi = px.line(tech_data, x='date', y='rsi', title='RSI')
+                    st.plotly_chart(fig_rsi, use_container_width=True)
+            
+            with col2:
+                if 'macd' in tech_data.columns:
+                    fig_macd = px.line(tech_data, x='date', y='macd', title='MACD')
+                    st.plotly_chart(fig_macd, use_container_width=True)
+                    
+        else:
+            st.info(f"No technical indicators found for {symbol}")
+            
+    except Exception as e:
+        st.error(f"Error loading technical indicators: {str(e)}")
+
+def show_trading_signals(db):
+    """Show trading signals"""
+    st.header("Trading Signals")
+    
+    try:
+        # Get all signals
+        signals_data = pd.read_sql("""
+            SELECT * FROM trading_signals 
+            ORDER BY signal_date DESC 
+            LIMIT 100
+        """, db.engine)
+        
+        if not signals_data.empty:
+            st.dataframe(signals_data)
+            
+            # Signal distribution
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                signal_counts = signals_data['signal'].value_counts()
+                fig_pie = px.pie(values=signal_counts.values, names=signal_counts.index, 
+                               title="Signal Distribution")
+                st.plotly_chart(fig_pie, use_container_width=True)
+            
+            with col2:
+                fig_conf = px.histogram(signals_data, x='confidence', title="Confidence Distribution")
+                st.plotly_chart(fig_conf, use_container_width=True)
+                
+        else:
+            st.info("No trading signals found")
+            
+    except Exception as e:
+        st.error(f"Error loading trading signals: {str(e)}")
+
+def show_model_metrics(db):
+    """Show model performance metrics"""
+    st.header("Model Performance Metrics")
+    
+    try:
+        metrics_data = pd.read_sql("""
+            SELECT * FROM model_metrics 
+            ORDER BY training_date DESC
+        """, db.engine)
+        
+        if not metrics_data.empty:
+            st.dataframe(metrics_data)
+            
+            # Performance charts
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                fig_acc = px.bar(metrics_data, x='symbol', y='accuracy', 
+                               title="Model Accuracy by Symbol")
+                st.plotly_chart(fig_acc, use_container_width=True)
+            
+            with col2:
+                fig_prec = px.bar(metrics_data, x='symbol', y='precision_score', 
+                                title="Model Precision by Symbol")
+                st.plotly_chart(fig_prec, use_container_width=True)
+                
+        else:
+            st.info("No model metrics found")
+            
+    except Exception as e:
+        st.error(f"Error loading model metrics: {str(e)}")
+
+def show_sql_interface(db):
+    """SQL query interface"""
+    st.header("SQL Query Interface")
+    
+    # Predefined queries
+    st.subheader("Quick Queries")
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if st.button("Show All Tables"):
+            try:
+                tables = db.engine.execute(text("SELECT name FROM sqlite_master WHERE type='table'")).fetchall()
+                st.write("Tables:", [table[0] for table in tables])
+            except Exception as e:
+                st.error(f"Error: {str(e)}")
+    
+    with col2:
+        if st.button("Latest Signals"):
+            try:
+                result = pd.read_sql("SELECT * FROM trading_signals ORDER BY created_at DESC LIMIT 5", db.engine)
+                st.dataframe(result)
+            except Exception as e:
+                st.error(f"Error: {str(e)}")
+    
+    with col3:
+        if st.button("Stock Summary"):
+            try:
+                result = pd.read_sql("""
+                    SELECT symbol, COUNT(*) as records, 
+                           MIN(date) as first_date, MAX(date) as last_date 
+                    FROM stock_data 
+                    GROUP BY symbol
+                """, db.engine)
+                st.dataframe(result)
+            except Exception as e:
+                st.error(f"Error: {str(e)}")
+    
+    # Custom SQL query
+    st.subheader("Custom SQL Query")
+    sql_query = st.text_area(
+        "Enter SQL Query:",
+        value="SELECT * FROM trading_signals LIMIT 10;",
+        height=100
+    )
+    
+    if st.button("Execute Query"):
+        try:
+            if sql_query.strip():
+                result = pd.read_sql(sql_query, db.engine)
+                st.dataframe(result)
+                st.success(f"Query executed successfully. {len(result)} rows returned.")
+        except Exception as e:
+            st.error(f"Query error: {str(e)}")
+
+def initialize_database_tables(db):
+    """Initialize database tables with sample data"""
+    try:
+        from database import Base
+        Base.metadata.create_all(db.engine)
+        st.success("Database tables initialized successfully")
+        st.rerun()
+    except Exception as e:
+        st.error(f"Error initializing tables: {str(e)}")
+
+def load_sample_data(db, symbol):
+    """Load sample data for testing"""
+    try:
+        import yfinance as yf
+        from technical_indicators import TechnicalIndicators
+        
+        # Download stock data
+        ticker = yf.Ticker(symbol)
+        data = ticker.history(period="1mo")
+        
+        if not data.empty:
+            # Save stock data
+            db.save_stock_data(symbol, data)
+            
+            # Calculate and save technical indicators
+            tech = TechnicalIndicators()
+            data_with_indicators = tech.calculate_all_indicators(data)
+            db.save_technical_indicators(symbol, data_with_indicators)
+            
+            st.success(f"Sample data loaded for {symbol}")
+            st.rerun()
+        else:
+            st.error(f"Could not fetch data for {symbol}")
+            
+    except Exception as e:
+        st.error(f"Error loading sample data: {str(e)}")
+
+if __name__ == "__main__":
+    database_console()

db_console.py

@@ -0,0 +1,290 @@
+import streamlit as st
+import pandas as pd
+import sqlite3
+import plotly.express as px
+import plotly.graph_objects as go
+import os
+
+def main():
+    st.set_page_config(page_title="Stock Trading Database Console", layout="wide")
+    
+    st.title("📊 Stock Trading Database Console")
+    st.markdown("### SQLite Database Management & Analytics")
+    
+    # Database file info
+    db_file = "stock_trading.db"
+    if os.path.exists(db_file):
+        size = os.path.getsize(db_file)
+        st.success(f"Database: {db_file} ({size/1024:.1f} KB)")
+    else:
+        st.warning(f"Database file {db_file} not found. Data will be created when you use the main app.")
+        return
+    
+    # Connect to database
+    try:
+        conn = sqlite3.connect(db_file)
+        st.success("Database connection established")
+    except Exception as e:
+        st.error(f"Database connection failed: {str(e)}")
+        return
+    
+    # Sidebar navigation
+    st.sidebar.header("Database Navigation")
+    section = st.sidebar.selectbox(
+        "Select Section:",
+        ["Overview", "Tables", "Stock Data", "Trading Signals", "Model Metrics", "SQL Query"]
+    )
+    
+    if section == "Overview":
+        show_overview(conn)
+    elif section == "Tables":
+        show_tables(conn)
+    elif section == "Stock Data":
+        show_stock_data(conn)
+    elif section == "Trading Signals":
+        show_trading_signals(conn)
+    elif section == "Model Metrics":
+        show_model_metrics(conn)
+    elif section == "SQL Query":
+        show_sql_interface(conn)
+    
+    conn.close()
+
+def show_overview(conn):
+    """Show database overview"""
+    st.header("Database Overview")
+    
+    # Get table information
+    tables_query = "SELECT name FROM sqlite_master WHERE type='table'"
+    tables = pd.read_sql(tables_query, conn)
+    
+    if not tables.empty:
+        st.subheader("Available Tables")
+        st.dataframe(tables)
+        
+        # Table statistics
+        col1, col2, col3, col4 = st.columns(4)
+        
+        try:
+            stock_count = pd.read_sql("SELECT COUNT(*) as count FROM stock_data", conn).iloc[0]['count']
+            with col1:
+                st.metric("Stock Records", stock_count)
+        except:
+            with col1:
+                st.metric("Stock Records", 0)
+        
+        try:
+            signals_count = pd.read_sql("SELECT COUNT(*) as count FROM trading_signals", conn).iloc[0]['count']
+            with col2:
+                st.metric("Trading Signals", signals_count)
+        except:
+            with col2:
+                st.metric("Trading Signals", 0)
+        
+        try:
+            indicators_count = pd.read_sql("SELECT COUNT(*) as count FROM technical_indicators", conn).iloc[0]['count']
+            with col3:
+                st.metric("Technical Indicators", indicators_count)
+        except:
+            with col3:
+                st.metric("Technical Indicators", 0)
+        
+        try:
+            models_count = pd.read_sql("SELECT COUNT(*) as count FROM model_metrics", conn).iloc[0]['count']
+            with col4:
+                st.metric("Model Metrics", models_count)
+        except:
+            with col4:
+                st.metric("Model Metrics", 0)
+    else:
+        st.info("No tables found. Use the main app to generate data.")
+
+def show_tables(conn):
+    """Show table schemas"""
+    st.header("Table Schemas")
+    
+    # Get all tables
+    tables_query = "SELECT name FROM sqlite_master WHERE type='table'"
+    tables = pd.read_sql(tables_query, conn)
+    
+    for table_name in tables['name']:
+        st.subheader(f"Table: {table_name}")
+        
+        # Get table schema
+        schema_query = f"PRAGMA table_info({table_name})"
+        schema = pd.read_sql(schema_query, conn)
+        st.dataframe(schema)
+        
+        # Get sample data
+        try:
+            sample_query = f"SELECT * FROM {table_name} LIMIT 3"
+            sample = pd.read_sql(sample_query, conn)
+            if not sample.empty:
+                st.write("Sample Data:")
+                st.dataframe(sample)
+        except:
+            st.write("No sample data available")
+        
+        st.markdown("---")
+
+def show_stock_data(conn):
+    """Show stock OHLCV data"""
+    st.header("Stock Data Analysis")
+    
+    try:
+        # Get unique symbols
+        symbols_query = "SELECT DISTINCT symbol FROM stock_data ORDER BY symbol"
+        symbols = pd.read_sql(symbols_query, conn)
+        
+        if not symbols.empty:
+            selected_symbol = st.selectbox("Select Stock Symbol:", symbols['symbol'].tolist())
+            
+            # Get data for selected symbol
+            data_query = f"""
+                SELECT * FROM stock_data 
+                WHERE symbol = '{selected_symbol}' 
+                ORDER BY date DESC 
+                LIMIT 100
+            """
+            stock_data = pd.read_sql(data_query, conn)
+            
+            if not stock_data.empty:
+                st.dataframe(stock_data)
+                
+                # Create candlestick chart
+                fig = go.Figure(data=go.Candlestick(
+                    x=stock_data['date'],
+                    open=stock_data['open_price'],
+                    high=stock_data['high_price'],
+                    low=stock_data['low_price'],
+                    close=stock_data['close_price']
+                ))
+                fig.update_layout(title=f"{selected_symbol} - Candlestick Chart")
+                st.plotly_chart(fig, use_container_width=True)
+                
+                # Volume chart
+                fig_vol = px.bar(stock_data, x='date', y='volume', title=f"{selected_symbol} - Volume")
+                st.plotly_chart(fig_vol, use_container_width=True)
+            else:
+                st.info(f"No data found for {selected_symbol}")
+        else:
+            st.info("No stock data available. Train a model in the main app to generate data.")
+    except Exception as e:
+        st.error(f"Error loading stock data: {str(e)}")
+
+def show_trading_signals(conn):
+    """Show trading signals"""
+    st.header("Trading Signals Analysis")
+    
+    try:
+        signals_query = "SELECT * FROM trading_signals ORDER BY signal_date DESC LIMIT 100"
+        signals = pd.read_sql(signals_query, conn)
+        
+        if not signals.empty:
+            st.dataframe(signals)
+            
+            # Signal distribution
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                signal_counts = signals['signal'].value_counts()
+                fig_pie = px.pie(values=signal_counts.values, names=signal_counts.index, 
+                               title="Signal Distribution")
+                st.plotly_chart(fig_pie, use_container_width=True)
+            
+            with col2:
+                fig_conf = px.histogram(signals, x='confidence', title="Confidence Distribution")
+                st.plotly_chart(fig_conf, use_container_width=True)
+            
+            # Signals by symbol
+            if 'symbol' in signals.columns:
+                symbol_signals = signals.groupby('symbol')['signal'].count().reset_index()
+                fig_bar = px.bar(symbol_signals, x='symbol', y='signal', title="Signals by Symbol")
+                st.plotly_chart(fig_bar, use_container_width=True)
+        else:
+            st.info("No trading signals found. Generate signals in the main app.")
+    except Exception as e:
+        st.error(f"Error loading trading signals: {str(e)}")
+
+def show_model_metrics(conn):
+    """Show model performance metrics"""
+    st.header("Model Performance Metrics")
+    
+    try:
+        metrics_query = "SELECT * FROM model_metrics ORDER BY training_date DESC"
+        metrics = pd.read_sql(metrics_query, conn)
+        
+        if not metrics.empty:
+            st.dataframe(metrics)
+            
+            # Performance charts
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                fig_acc = px.bar(metrics, x='symbol', y='accuracy', title="Model Accuracy")
+                st.plotly_chart(fig_acc, use_container_width=True)
+            
+            with col2:
+                fig_prec = px.bar(metrics, x='symbol', y='precision_score', title="Model Precision")
+                st.plotly_chart(fig_prec, use_container_width=True)
+        else:
+            st.info("No model metrics found. Train models in the main app.")
+    except Exception as e:
+        st.error(f"Error loading model metrics: {str(e)}")
+
+def show_sql_interface(conn):
+    """SQL query interface"""
+    st.header("SQL Query Interface")
+    
+    # Quick queries
+    st.subheader("Quick Queries")
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if st.button("Show All Tables"):
+            query = "SELECT name FROM sqlite_master WHERE type='table'"
+            result = pd.read_sql(query, conn)
+            st.dataframe(result)
+    
+    with col2:
+        if st.button("Latest Signals"):
+            try:
+                query = "SELECT * FROM trading_signals ORDER BY created_at DESC LIMIT 10"
+                result = pd.read_sql(query, conn)
+                st.dataframe(result)
+            except Exception as e:
+                st.error(f"Error: {str(e)}")
+    
+    with col3:
+        if st.button("Stock Summary"):
+            try:
+                query = """
+                    SELECT symbol, COUNT(*) as records, 
+                           MIN(date) as first_date, MAX(date) as last_date 
+                    FROM stock_data 
+                    GROUP BY symbol
+                """
+                result = pd.read_sql(query, conn)
+                st.dataframe(result)
+            except Exception as e:
+                st.error(f"Error: {str(e)}")
+    
+    # Custom SQL
+    st.subheader("Custom SQL Query")
+    sql_query = st.text_area(
+        "Enter SQL Query:",
+        value="SELECT * FROM sqlite_master WHERE type='table';",
+        height=100
+    )
+    
+    if st.button("Execute Query"):
+        try:
+            if sql_query.strip():
+                result = pd.read_sql(sql_query, conn)
+                st.dataframe(result)
+                st.success(f"Query executed successfully. {len(result)} rows returned.")
+        except Exception as e:
+            st.error(f"Query error: {str(e)}")
+
+if __name__ == "__main__":
+    main()

model_trainer.py

@@ -0,0 +1,187 @@
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, precision_score, recall_score
+from sklearn.preprocessing import StandardScaler
+import xgboost as xgb
+import warnings
+warnings.filterwarnings('ignore')
+
+class ModelTrainer:
+    def __init__(self):
+        self.scaler = StandardScaler()
+        
+    def train_model(self, features, labels, model_type='random_forest'):
+        """Train machine learning model for trading signals"""
+        try:
+            if len(features) == 0 or len(labels) == 0:
+                raise ValueError("No data available for training")
+            
+            # Handle infinite and NaN values
+            features = features.replace([np.inf, -np.inf], np.nan)
+            features = features.fillna(features.mean())
+            
+            # Split data
+            X_train, X_test, y_train, y_test = train_test_split(
+                features, labels, test_size=0.2, random_state=42, stratify=labels
+            )
+            
+            # Scale features
+            X_train_scaled = self.scaler.fit_transform(X_train)
+            X_test_scaled = self.scaler.transform(X_test)
+            
+            # Train model
+            if model_type == 'random_forest':
+                model = self.train_random_forest(X_train_scaled, y_train)
+            elif model_type == 'xgboost':
+                model = self.train_xgboost(X_train_scaled, y_train)
+            else:
+                raise ValueError(f"Unsupported model type: {model_type}")
+            
+            # Evaluate model
+            metrics = self.evaluate_model(model, X_test_scaled, y_test)
+            
+            # Feature importance
+            feature_importance = self.get_feature_importance(model, features.columns)
+            
+            # Create final model pipeline that includes scaling
+            final_model = ModelPipeline(self.scaler, model)
+            
+            return final_model, features.columns.tolist(), metrics
+            
+        except Exception as e:
+            print(f"Error training model: {str(e)}")
+            raise e
+    
+    def train_random_forest(self, X_train, y_train):
+        """Train Random Forest model with hyperparameter tuning"""
+        try:
+            # Define parameter grid for tuning
+            param_grid = {
+                'n_estimators': [100, 200],
+                'max_depth': [10, 15, None],
+                'min_samples_split': [2, 5],
+                'min_samples_leaf': [1, 2]
+            }
+            
+            # Create base model
+            rf = RandomForestClassifier(random_state=42, class_weight='balanced')
+            
+            # Grid search with cross-validation
+            grid_search = GridSearchCV(
+                rf, param_grid, cv=5, scoring='accuracy', n_jobs=-1
+            )
+            
+            grid_search.fit(X_train, y_train)
+            
+            return grid_search.best_estimator_
+            
+        except Exception as e:
+            print(f"Error training Random Forest: {str(e)}")
+            # Fallback to basic model
+            return RandomForestClassifier(
+                n_estimators=100, random_state=42, class_weight='balanced'
+            ).fit(X_train, y_train)
+    
+    def train_xgboost(self, X_train, y_train):
+        """Train XGBoost model"""
+        try:
+            # Convert labels to ensure compatibility
+            label_mapping = {-1: 0, 0: 1, 1: 2}
+            y_train_mapped = np.array([label_mapping[label] for label in y_train])
+            
+            model = xgb.XGBClassifier(
+                n_estimators=100,
+                max_depth=6,
+                learning_rate=0.1,
+                random_state=42,
+                eval_metric='mlogloss'
+            )
+            
+            model.fit(X_train, y_train_mapped)
+            
+            # Wrap model to handle label mapping
+            return XGBoostWrapper(model, label_mapping)
+            
+        except Exception as e:
+            print(f"Error training XGBoost: {str(e)}")
+            raise e
+    
+    def evaluate_model(self, model, X_test, y_test):
+        """Evaluate model performance"""
+        try:
+            y_pred = model.predict(X_test)
+            
+            # Calculate metrics
+            accuracy = accuracy_score(y_test, y_pred)
+            precision = precision_score(y_test, y_pred, average='weighted', zero_division=0)
+            recall = recall_score(y_test, y_pred, average='weighted', zero_division=0)
+            
+            metrics = {
+                'accuracy': accuracy,
+                'precision': precision,
+                'recall': recall,
+                'classification_report': classification_report(y_test, y_pred, zero_division=0),
+                'confusion_matrix': confusion_matrix(y_test, y_pred).tolist()
+            }
+            
+            return metrics
+            
+        except Exception as e:
+            print(f"Error evaluating model: {str(e)}")
+            return {'accuracy': 0.0, 'precision': 0.0, 'recall': 0.0}
+    
+    def get_feature_importance(self, model, feature_names):
+        """Get feature importance from trained model"""
+        try:
+            if hasattr(model, 'feature_importances_'):
+                importance = model.feature_importances_
+            elif hasattr(model, 'model') and hasattr(model.model, 'feature_importances_'):
+                importance = model.model.feature_importances_
+            else:
+                return {}
+            
+            feature_importance = dict(zip(feature_names, importance))
+            
+            # Sort by importance
+            sorted_importance = dict(sorted(feature_importance.items(), 
+                                          key=lambda x: x[1], reverse=True))
+            
+            return sorted_importance
+            
+        except Exception as e:
+            print(f"Error getting feature importance: {str(e)}")
+            return {}
+
+class ModelPipeline:
+    """Pipeline that combines scaling and model prediction"""
+    def __init__(self, scaler, model):
+        self.scaler = scaler
+        self.model = model
+    
+    def predict(self, X):
+        """Make predictions with scaling"""
+        X_scaled = self.scaler.transform(X)
+        return self.model.predict(X_scaled)
+    
+    def predict_proba(self, X):
+        """Make probability predictions with scaling"""
+        X_scaled = self.scaler.transform(X)
+        return self.model.predict_proba(X_scaled)
+
+class XGBoostWrapper:
+    """Wrapper for XGBoost to handle label mapping"""
+    def __init__(self, model, label_mapping):
+        self.model = model
+        self.label_mapping = label_mapping
+        self.reverse_mapping = {v: k for k, v in label_mapping.items()}
+    
+    def predict(self, X):
+        """Predict with label remapping"""
+        pred_mapped = self.model.predict(X)
+        return np.array([self.reverse_mapping[pred] for pred in pred_mapped])
+    
+    def predict_proba(self, X):
+        """Predict probabilities"""
+        return self.model.predict_proba(X)

pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "h2>=4.2.0",
+    "nsepython>=2.97",
+    "numpy>=2.3.0",
+    "pandas>=2.3.0",
+    "plotly>=6.1.2",
+    "scikit-learn>=1.7.0",
+    "sqlalchemy>=2.0.41",
+    "streamlit>=1.46.0",
+    "ta>=0.11.0",
+    "xgboost>=3.0.2",
+    "yfinance>=0.2.63",
+]

requirements.txt

@@ -0,0 +1,10 @@
+streamlit>=1.30.0
+pandas>=2.0.0
+numpy>=1.23.0
+yfinance>=0.2.36
+plotly>=5.18.0
+scikit-learn>=1.2.0
+ta>=0.11.0
+sqlalchemy>=2.0.0
+joblib>=1.2.0
+matplotlib>=3.7.0  # If you're plotting manually outside of plotly

run_app.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+export LD_LIBRARY_PATH="/nix/store/055bzdrski1dwqa4km1gxpcjhpn73mng-gcc-10.3.0-lib/lib:/nix/store/026hln0aq1hyshaxsdvhg0kmcm6yf45r-zlib-1.2.13/lib:$LD_LIBRARY_PATH"
+streamlit run app.py --server.port 5005

simple_app.py

@@ -0,0 +1,219 @@
+import streamlit as st
+import yfinance as yf
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import warnings
+warnings.filterwarnings('ignore')
+
+# Configure page
+st.set_page_config(
+    page_title="AI Stock Trading Signals",
+    page_icon="📈",
+    layout="wide"
+)
+
+def get_stock_data(symbol, period="3mo"):
+    """Get stock data using yfinance"""
+    try:
+        ticker = yf.Ticker(symbol)
+        data = ticker.history(period=period)
+        return data
+    except Exception as e:
+        st.error(f"Error fetching data: {str(e)}")
+        return None
+
+def get_live_price(stock_symbol):
+    """Get live stock price"""
+    try:
+        # Try nsepython first
+        try:
+            import nsepython as nse
+            stock_name = stock_symbol.replace('.NS', '')
+            live_data = nse.equity_quote(stock_name)
+            if live_data and 'lastPrice' in live_data:
+                return float(live_data['lastPrice'])
+        except:
+            pass
+        
+        # Fallback to yfinance
+        ticker = yf.Ticker(stock_symbol)
+        data = ticker.history(period="1d", interval="1m")
+        if not data.empty:
+            return float(data['Close'].iloc[-1])
+        
+        return None
+    except Exception as e:
+        st.warning(f"Could not fetch live price: {str(e)}")
+        return None
+
+def create_simple_chart(stock_symbol):
+    """Create simple price chart"""
+    try:
+        data = get_stock_data(stock_symbol, period="1mo")
+        if data is None or data.empty:
+            return None
+        
+        # Get last 30 days
+        data = data.tail(30)
+        
+        fig = go.Figure()
+        
+        # Add candlestick chart
+        fig.add_trace(go.Candlestick(
+            x=data.index,
+            open=data['Open'],
+            high=data['High'],
+            low=data['Low'],
+            close=data['Close'],
+            name='Price'
+        ))
+        
+        # Add simple moving averages
+        sma_20 = data['Close'].rolling(window=20).mean()
+        sma_50 = data['Close'].rolling(window=50).mean()
+        
+        fig.add_trace(go.Scatter(
+            x=data.index, 
+            y=sma_20, 
+            name='SMA 20',
+            line=dict(color='orange', width=2)
+        ))
+        
+        fig.add_trace(go.Scatter(
+            x=data.index, 
+            y=sma_50, 
+            name='SMA 50',
+            line=dict(color='blue', width=2)
+        ))
+        
+        fig.update_layout(
+            title=f"{stock_symbol} - Price Chart",
+            xaxis_rangeslider_visible=False,
+            height=600,
+            yaxis_title="Price (₹)"
+        )
+        
+        return fig
+        
+    except Exception as e:
+        st.error(f"Error creating chart: {str(e)}")
+        return None
+
+def simple_trading_signal(stock_symbol):
+    """Generate simple trading signal based on moving averages"""
+    try:
+        data = get_stock_data(stock_symbol, period="3mo")
+        if data is None or data.empty:
+            return None, "No data available"
+        
+        # Calculate simple moving averages
+        current_price = data['Close'].iloc[-1]
+        sma_20 = data['Close'].rolling(window=20).mean().iloc[-1]
+        sma_50 = data['Close'].rolling(window=50).mean().iloc[-1]
+        
+        # Simple signal logic
+        if current_price > sma_20 and sma_20 > sma_50:
+            signal = "BUY"
+            confidence = 0.75
+        elif current_price < sma_20 and sma_20 < sma_50:
+            signal = "SELL"
+            confidence = 0.75
+        else:
+            signal = "HOLD"
+            confidence = 0.60
+        
+        return {
+            'signal': signal,
+            'confidence': confidence,
+            'current_price': current_price,
+            'sma_20': sma_20,
+            'sma_50': sma_50
+        }, None
+        
+    except Exception as e:
+        return None, f"Error generating signal: {str(e)}"
+
+def main():
+    st.title("📈 Stock Trading Signals App")
+    st.markdown("### NSE Stock Analysis (Simplified Version)")
+    
+    # Sidebar for stock selection
+    st.sidebar.header("Stock Selection")
+    
+    # Stock options
+    stock_options = {
+        "Reliance Industries": "RELIANCE.NS",
+        "Tata Consultancy Services": "TCS.NS",
+        "Infosys": "INFY.NS"
+    }
+    
+    selected_stock_name = st.sidebar.selectbox(
+        "Choose a stock:",
+        list(stock_options.keys())
+    )
+    
+    selected_stock = stock_options[selected_stock_name]
+    
+    # Main content
+    st.header("📊 Live Market Data")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("🔄 Get Live Price", type="primary"):
+            live_price = get_live_price(selected_stock)
+            if live_price:
+                st.metric("Live Price (LTP)", f"₹{live_price:.2f}")
+            else:
+                st.warning("Could not fetch live price")
+    
+    # Trading signal section
+    st.header("🎯 Trading Signal")
+    
+    if st.button("📈 Get Signal", type="primary"):
+        signal_result, error = simple_trading_signal(selected_stock)
+        
+        if signal_result:
+            signal = signal_result['signal']
+            confidence = signal_result['confidence']
+            
+            # Display signal with color coding
+            if signal == "BUY":
+                st.success(f"🟢 **{signal}** Signal")
+            elif signal == "SELL":
+                st.error(f"🔴 **{signal}** Signal")
+            else:
+                st.info(f"🟡 **{signal}** Signal")
+            
+            # Display metrics
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Confidence", f"{confidence:.1%}")
+            with col2:
+                st.metric("Current Price", f"₹{signal_result['current_price']:.2f}")
+            with col3:
+                st.metric("SMA 20", f"₹{signal_result['sma_20']:.2f}")
+            
+        else:
+            st.error(f"Signal generation failed: {error}")
+    
+    # Chart section
+    st.header("📈 Price Chart")
+    
+    if st.button("📊 Show Chart"):
+        chart = create_simple_chart(selected_stock)
+        if chart:
+            st.plotly_chart(chart, use_container_width=True)
+    
+    # Information section
+    st.header("ℹ️ About This App")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.info("**Signal Logic:**\n- BUY: Price > SMA20 > SMA50\n- SELL: Price < SMA20 < SMA50\n- HOLD: Mixed signals")
+    
+    with col2:
+        st.info("**Data Source:**\n- Yahoo Finance (yfinance)\n- NSE Python for live prices\n- 3 months historical data")
+
+if __name__ == "__main__":
+    main()

stock_trading.db

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

technical_indicators.py

@@ -0,0 +1,225 @@
+import pandas as pd
+import numpy as np
+import ta
+from ta.utils import dropna
+import warnings
+warnings.filterwarnings('ignore')
+
+class TechnicalIndicators:
+    def __init__(self):
+        pass
+    
+    def calculate_all_indicators(self, data):
+        """Calculate comprehensive set of technical indicators"""
+        try:
+            df = data.copy()
+            
+            # Ensure we have required columns
+            if not all(col in df.columns for col in ['Open', 'High', 'Low', 'Close', 'Volume']):
+                print("Missing required OHLCV columns")
+                return df
+            
+            # Clean data and ensure sufficient data points
+            df = df.dropna()
+            
+            if len(df) < 30:  # Reduced minimum for testing
+                print(f"Insufficient data: {len(df)} rows, need at least 30")
+                return df
+            
+            print(f"Calculating indicators for {len(df)} data points...")
+            
+            # Basic Moving Averages
+            df = self.add_moving_averages(df)
+            
+            # RSI
+            df = self.add_rsi(df)
+            
+            # MACD
+            df = self.add_macd(df)
+            
+            # Bollinger Bands
+            df = self.add_bollinger_bands(df)
+            
+            # Stochastic Oscillator
+            df = self.add_stochastic(df)
+            
+            # Williams %R
+            df = self.add_williams_r(df)
+            
+            # Average True Range (ATR)
+            df = self.add_atr(df)
+            
+            # Additional indicators
+            df = self.add_additional_indicators(df)
+            
+            # Volume indicators
+            df = self.add_volume_indicators(df)
+            
+            # Count new indicators added
+            original_cols = ['Open', 'High', 'Low', 'Close', 'Volume', 'Dividends', 'Stock Splits']
+            new_indicators = [col for col in df.columns if col not in original_cols]
+            print(f"Successfully calculated {len(new_indicators)} technical indicators")
+            
+            return df
+            
+        except Exception as e:
+            print(f"Error calculating technical indicators: {str(e)}")
+            return data
+    
+    def add_moving_averages(self, df):
+        """Add various moving averages"""
+        try:
+            # Simple Moving Averages using pandas rolling
+            df['SMA_10'] = df['Close'].rolling(window=10).mean()
+            df['SMA_20'] = df['Close'].rolling(window=20).mean()
+            df['SMA_50'] = df['Close'].rolling(window=50).mean()
+            
+            # Exponential Moving Averages using pandas ewm
+            df['EMA_12'] = df['Close'].ewm(span=12).mean()
+            df['EMA_20'] = df['Close'].ewm(span=20).mean()
+            df['EMA_26'] = df['Close'].ewm(span=26).mean()
+            
+            return df
+        except Exception as e:
+            print(f"Error adding moving averages: {str(e)}")
+            return df
+    
+    def add_rsi(self, df, window=14):
+        """Add Relative Strength Index"""
+        try:
+            # Calculate RSI manually
+            delta = df['Close'].diff()
+            gain = (delta.where(delta > 0, 0)).rolling(window=window).mean()
+            loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()
+            rs = gain / loss
+            df['RSI'] = 100 - (100 / (1 + rs))
+            return df
+        except Exception as e:
+            print(f"Error adding RSI: {str(e)}")
+            return df
+    
+    def add_macd(self, df):
+        """Add MACD indicators"""
+        try:
+            # Calculate MACD manually
+            ema_12 = df['Close'].ewm(span=12).mean()
+            ema_26 = df['Close'].ewm(span=26).mean()
+            df['MACD'] = ema_12 - ema_26
+            df['MACD_signal'] = df['MACD'].ewm(span=9).mean()
+            df['MACD_histogram'] = df['MACD'] - df['MACD_signal']
+            return df
+        except Exception as e:
+            print(f"Error adding MACD: {str(e)}")
+            return df
+    
+    def add_bollinger_bands(self, df, window=20, std=2):
+        """Add Bollinger Bands"""
+        try:
+            # Calculate Bollinger Bands manually
+            df['BB_middle'] = df['Close'].rolling(window=window).mean()
+            bb_std = df['Close'].rolling(window=window).std()
+            df['BB_upper'] = df['BB_middle'] + (bb_std * std)
+            df['BB_lower'] = df['BB_middle'] - (bb_std * std)
+            df['BB_width'] = (df['BB_upper'] - df['BB_lower']) / df['BB_middle']
+            df['BB_position'] = (df['Close'] - df['BB_lower']) / (df['BB_upper'] - df['BB_lower'])
+            return df
+        except Exception as e:
+            print(f"Error adding Bollinger Bands: {str(e)}")
+            return df
+    
+    def add_stochastic(self, df, k_window=14, d_window=3):
+        """Add Stochastic Oscillator"""
+        try:
+            stoch = ta.momentum.StochasticOscillator(df['High'], df['Low'], df['Close'], 
+                                                   window=k_window, smooth_window=d_window)
+            df['Stoch_K'] = stoch.stoch()
+            df['Stoch_D'] = stoch.stoch_signal()
+            return df
+        except Exception as e:
+            print(f"Error adding Stochastic: {str(e)}")
+            return df
+    
+    def add_williams_r(self, df, window=14):
+        """Add Williams %R"""
+        try:
+            df['Williams_R'] = ta.momentum.williams_r(df['High'], df['Low'], df['Close'], window=window)
+            return df
+        except Exception as e:
+            print(f"Error adding Williams %R: {str(e)}")
+            return df
+    
+    def add_atr(self, df, window=14):
+        """Add Average True Range"""
+        try:
+            df['ATR'] = ta.volatility.average_true_range(df['High'], df['Low'], df['Close'], window=window)
+            df['ATR_ratio'] = df['ATR'] / df['Close']  # Normalized ATR
+            return df
+        except Exception as e:
+            print(f"Error adding ATR: {str(e)}")
+            return df
+    
+    def add_additional_indicators(self, df):
+        """Add additional technical indicators"""
+        try:
+            # Commodity Channel Index
+            df['CCI'] = ta.trend.cci(df['High'], df['Low'], df['Close'], window=20)
+            
+            # Rate of Change
+            df['ROC'] = ta.momentum.roc(df['Close'], window=12)
+            
+            # Money Flow Index
+            df['MFI'] = ta.volume.money_flow_index(df['High'], df['Low'], df['Close'], df['Volume'], window=14)
+            
+            # Parabolic SAR
+            df['PSAR'] = ta.trend.psar_down(df['High'], df['Low'], df['Close'])
+            
+            # Aroon indicators
+            aroon = ta.trend.AroonIndicator(df['High'], df['Low'], window=25)
+            df['Aroon_Up'] = aroon.aroon_up()
+            df['Aroon_Down'] = aroon.aroon_down()
+            
+            return df
+        except Exception as e:
+            print(f"Error adding additional indicators: {str(e)}")
+            return df
+    
+    def add_volume_indicators(self, df):
+        """Add volume-based indicators"""
+        try:
+            # Volume Moving Average
+            df['Volume_SMA'] = ta.volume.volume_sma(df['Close'], df['Volume'], window=20)
+            
+            # Volume Weighted Average Price (VWAP)
+            df['VWAP'] = ta.volume.volume_weighted_average_price(df['High'], df['Low'], df['Close'], df['Volume'])
+            
+            # On Balance Volume
+            df['OBV'] = ta.volume.on_balance_volume(df['Close'], df['Volume'])
+            
+            # Accumulation/Distribution Line
+            df['ADL'] = ta.volume.acc_dist_index(df['High'], df['Low'], df['Close'], df['Volume'])
+            
+            # Chaikin Money Flow
+            df['CMF'] = ta.volume.chaikin_money_flow(df['High'], df['Low'], df['Close'], df['Volume'], window=20)
+            
+            return df
+        except Exception as e:
+            print(f"Error adding volume indicators: {str(e)}")
+            return df
+    
+    def get_indicator_summary(self, df):
+        """Get summary of all calculated indicators"""
+        try:
+            indicator_columns = [col for col in df.columns if col not in ['Open', 'High', 'Low', 'Close', 'Volume']]
+            
+            summary = {
+                'total_indicators': len(indicator_columns),
+                'trend_indicators': [col for col in indicator_columns if any(x in col for x in ['SMA', 'EMA', 'MACD', 'PSAR', 'Aroon'])],
+                'momentum_indicators': [col for col in indicator_columns if any(x in col for x in ['RSI', 'Stoch', 'Williams', 'ROC', 'CCI'])],
+                'volatility_indicators': [col for col in indicator_columns if any(x in col for x in ['BB', 'ATR'])],
+                'volume_indicators': [col for col in indicator_columns if any(x in col for x in ['Volume', 'VWAP', 'OBV', 'ADL', 'CMF', 'MFI'])]
+            }
+            
+            return summary
+        except Exception as e:
+            print(f"Error getting indicator summary: {str(e)}")
+            return {}