Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,193 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+data_cache/*
+data_upload/*
+# C extensions
+*.so
+
+# other files
+fmp_historical_chart_5min_QQQ_*
+test_replay.py
+test_download*.py
+todo.md
+
+# Claude
+.claude/
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+.DS_Store
+
+# Ignore Crew engineering team output
+3_crew/engineering_team/output/
+
+# Ignore Accounts database in capstone project
+6_mcp/accounts.db
+6_mcp/memory/*.db

.python-version

@@ -0,0 +1 @@
+3.12

README.md

@@ -1,12 +1,245 @@
 ---
 title: StrategyGenerator
-emoji: 💻
-colorFrom: yellow
-colorTo: blue
-sdk: gradio
-sdk_version: 6.2.0
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 5.47.2
 ---
+# Financial Strategy Generator
+
+A Gradio web application that generates Python trading strategies from natural language descriptions using Large Language Models (LLMs). The generated strategies can be instantly backtested using the Backtrader library with real market data from Yahoo Finance.
+
+## Overview
+
+This application allows you to:
+- **Describe trading strategies in plain English** (e.g., "Buy when 10-day SMA crosses above 100-day SMA")
+- **Generate Python code automatically** using state-of-the-art LLMs
+- **Backtest strategies immediately** in the GUI with configurable parameters
+- **Visualize results** with interactive charts and detailed transaction logs
+- **Export data** for further analysis
+
+## Key Features
+
+- 🤖 **Multi-LLM Support**: Choose from GPT, Claude, Deepseek, Gemini, or Grok4
+- 📊 **Financial Indicators**: Supports SMA, MACD, RSI, ATR, and more via Backtrader
+- 📈 **Interactive Backtesting**: Real-time strategy testing with Yahoo Finance data
+- 💾 **Data Caching**: Automatic caching to avoid redundant downloads
+- 📉 **Visual Analytics**: Charts, transaction tables, and trade performance metrics
+- ⚙️ **Configurable Parameters**: Customize capital, commission, slippage, and more
+- 🎯 **Multiple Timeframes**: Support for 1m, 5m, 15m, 1h, 1d intervals
+- 📥 **Export Capabilities**: Download generated code and CSV reports
+
+## Requirements
+
+- **Python 3.12**
+- Dependencies listed in `requirements.txt`.
+
+## Installation & Setup
+
+### 1. Clone the Repository
+
+```bash
+git clone <repository-url>
+cd LLM-fintech
+```
+
+### 2. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Environment Variables
+
+Create a `.env` file in the project root with your LLM API keys:
+
+```env
+OPENAI_API_KEY=your_openai_key_here
+ANTHROPIC_API_KEY=your_anthropic_key_here
+DEEPSEEK_API_KEY=your_deepseek_key_here
+GOOGLE_API_KEY=your_google_key_here
+XAI_API_KEY=your_grok_key_here
+
+# Optional: For HuggingFace local mode
+HF_TOKEN=your_huggingface_token_here
+
+# Optional: Override default models (see config/var_dev.yaml for defaults)
+OPENAI_MODEL=gpt-4
+CLAUDE_MODEL=claude-sonnet-4-20250514
+DEEPSEEK_MODEL=deepseek-reasoner
+GEMINI_MODEL=gemini-2.5-flash
+GROK4_MODEL=grok-4-fast-reasoning
+```
+
+### 4. Configuration
+
+The application uses `config/var_dev.yaml` for default settings:
+- Market/ticker mappings (e.g., "S&P 500 ETF" → "SPY")
+- Default LLM model names
+- Backtesting parameters (initial capital, commission, slippage)
+- Data intervals and periods
+
+You can modify this file to customize defaults without changing code.
+
+## Running Locally
+
+### Start the Application
+
+```bash
+python app.py
+```
+
+The Gradio interface will automatically open in your default browser. The app runs on `http://127.0.0.1:7860` by default.
+
+### Using the Interface
+
+1. **Generate Strategy**: 
+   - Select your preferred LLM model from the dropdown
+   - Enter a natural language description of your trading strategy
+   - Click "Generate Strategy" to create Python code
+
+2. **Configure Backtesting**:
+   - Choose a stock/ETF or enter a custom ticker symbol
+   - Set initial capital, commission, and slippage
+   - Select date range and data interval
+   - Optionally enable adjusted prices (for dividends/splits)
+
+3. **Run Backtest**:
+   - Click "Run Python Code" to execute the strategy
+   - View results in the Python result panel
+   - Check the "Charts" tab for visualizations
+   - Review "Transactions" and "Trades" tabs for detailed logs
+
+4. **Export Results**:
+   - Download generated strategy code as a `.py` file
+   - Export transaction and trade data as CSV files
+
+## Gradio Deployment
+
+To deploy this application to Gradio's hosting service:
+
+### 1. Install `uv`
+
+```bash
+# On macOS/Linux
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# On Windows
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+
+# Or via pip
+pip install uv
+```
+
+### 2. Deploy
+
+```bash
+uv gradio deploy
+```
+
+This command will:
+- Package your application
+- Upload it to Gradio's servers
+- Provide a public URL for your deployed app
+
+**Note**: Make sure your `.env` file is configured properly, or set environment variables in your deployment environment for API keys.
+
+For more deployment options and configurations, refer to [Gradio Deployment Documentation](https://www.gradio.app/guides/deploying-your-app).
+
+## Project Structure
+
+```
+LLM-fintech/
+├── app.py                 # Main Gradio application interface
+├── strategy_generator.py  # LLM integration and strategy code generation
+├── bt_utils.py           # Backtesting engine, data fetching, and plotting
+├── bt_strategies.py      # Example strategy classes (reference implementations)
+├── bt_testing.py         # Standalone backtesting script (for testing)
+├── utils.py              # Helper functions (validation, file operations)
+├── config/
+│   └── var_dev.yaml      # Configuration file (markets, models, defaults)
+├── data_cache/           # Cached Yahoo Finance data (auto-generated)
+├── requirements.txt      # Python dependencies
+└── README.md            # This file
+```
+
+## Configuration Details
+
+### Market/Ticker Mappings
+
+The `config/var_dev.yaml` file contains mappings between friendly names and ticker symbols. You can:
+- Use predefined markets from the dropdown (e.g., "S&P 500 ETF")
+- Enter any valid Yahoo Finance ticker symbol directly
+- Add custom mappings by editing the YAML file
+
+### Supported Data Intervals
+
+- **Intraday**: `1m`, `2m`, `5m`, `15m`, `30m`, `1h`
+- **Daily**: `1d`
+
+Note: Intraday data has limitations on historical range (Yahoo Finance restrictions).
+
+### Backtesting Parameters
+
+- **Initial Capital**: Starting portfolio value (default: $10,000)
+- **Commission**: Per-share trading commission (default: $0.005)
+- **Slippage**: Percentage of price applied as slippage (default: 0.01%)
+- **Adjusted Prices**: Use dividend/split-adjusted prices (recommended: enabled)
+
+## Supported Financial Indicators
+
+The generated strategies can use any Backtrader indicator, including:
+- **Moving Averages**: SMA, EMA, WMA
+- **Momentum**: RSI, Stochastic, MACD
+- **Volatility**: ATR, Bollinger Bands
+- **Volume**: Volume indicators
+- **Custom Indicators**: Any Backtrader-compatible indicator
+
+Example strategy descriptions:
+- "Go long when RSI crosses above 30 and 10-day SMA is above 50-day SMA"
+- "Buy when MACD line crosses above signal line, exit when it crosses below"
+- "Use ATR for position sizing, enter on golden cross with RSI confirmation"
+
+## Data Caching
+
+The application automatically caches downloaded market data in the `data_cache/` directory. This:
+- Speeds up subsequent backtests
+- Reduces API calls to Yahoo Finance
+- Caches are keyed by ticker, interval, date range, and adjustment settings
+
+Cache files are automatically managed and will be re-downloaded if parameters change.
+
+## Troubleshooting
+
+### Common Issues
+
+1. **API Key Errors**: Ensure all required API keys are set in your `.env` file
+2. **No Data Available**: Check that your ticker symbol is valid and date range is appropriate
+3. **Code Generation Fails**: Try a different LLM model or refine your strategy description
+4. **Chart Not Displaying**: Ensure matplotlib backend is set correctly (handled automatically)
+
+### Browser Compatibility
+
+The Gradio interface works best on modern browsers (Chrome, Firefox, Safari, Edge). If charts don't display, try:
+- Clearing browser cache
+- Using a different browser
+- Checking browser console for errors
+
+## Notes
+
+- Generated code follows Backtrader's strategy pattern and best practices
+- Strategies must inherit from `bt.Strategy` and implement `__init__` and `next()` methods
+- The app automatically wraps generated code with backtesting execution logic
+- Data is fetched from Yahoo Finance with automatic handling of market hours and holidays
+
+## Version
+0.0.2: added FMP extraction, replay mode and database reading for intraday
+
+0.0.1: First working version
+
+
+## License
+Needs to be done
+
+## Contributing
+Next Steps
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

StrategyGeneratorJupyter.ipynb

@@ -0,0 +1,616 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fa14ed7f",
+   "metadata": {},
+   "source": [
+    "# Strategy Generator"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88b42b38",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "80806d52",
+   "metadata": {},
+   "source": [
+    " Using as API  `backtrader`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "02a959b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "import os\n",
+    "import io\n",
+    "import sys\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.dates as mdates\n",
+    "from datetime import datetime\n",
+    "import backtrader as bt\n",
+    "import pandas as pd\n",
+    "import yfinance as yf\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.ticker import FuncFormatter\n",
+    "from dotenv import load_dotenv\n",
+    "from openai import OpenAI\n",
+    "import anthropic\n",
+    "import huggingface_hub \n",
+    "from huggingface_hub import InferenceClient\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "import gradio as gr\n",
+    "import subprocess\n",
+    "\n",
+    "# Environment\n",
+    "load_dotenv(override=True)\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')\n",
+    "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY')\n",
+    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
+    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
+    "grok_api_key = os.getenv(\"XAI_API_KEY\")\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "810ba72f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Init variables\n",
+    "# Market name mapping\n",
+    "TICKER_TO_MARKET = {\n",
+    "    'AAPL': 'Apple Inc.',\n",
+    "    'GOOGL': 'Alphabet/Google',\n",
+    "    'AMZN': 'Amazon.com',\n",
+    "    'TSLA': 'Tesla Inc.',\n",
+    "    'JPM': 'JPMorgan Chase & Co.',\n",
+    "    'V': 'Visa Inc.',\n",
+    "    'SPY': 'S&P 500 ETF',\n",
+    "    'QQQ': 'Nasdaq 100 ETF',\n",
+    "    'MSFT': 'Microsoft Corp.',\n",
+    "    'NVDA': 'NVIDIA Corp.',\n",
+    "    'META': 'Meta Platforms',\n",
+    "    'BRK-B': 'Berkshire Hathaway',\n",
+    "    'UNH': 'UnitedHealth Group',\n",
+    "    'XOM': 'Exxon Mobil Corp.'\n",
+    "}\n",
+    "MARKET_TO_TICKER = {\n",
+    "    'Apple Inc.': 'AAPL',\n",
+    "    'Alphabet/Google': 'GOOGL',\n",
+    "    'Amazon.com': 'AMZN',\n",
+    "    'Tesla Inc.': 'TSLA',\n",
+    "    'JPMorgan Chase & Co.': 'JPM',\n",
+    "    'Visa Inc.': 'V',\n",
+    "    'S&P 500 ETF': 'SPY',\n",
+    "    'Nasdaq 100 ETF': 'QQQ',\n",
+    "    'Microsoft Corp.': 'MSFT',\n",
+    "    'NVIDIA Corp.': 'NVDA',\n",
+    "    'Meta Platforms': 'META',\n",
+    "    'Berkshire Hathaway': 'BRK-B',\n",
+    "    'UnitedHealth Group': 'UNH',\n",
+    "    'Exxon Mobil Corp.': 'XOM'\n",
+    "}\n",
+    "# Variable that will get later with Gradio\n",
+    "current_date = datetime.now().strftime('%Y-%m-%d')\n",
+    "MARKET = 'AAPL'\n",
+    "API_FIN = 'backtrader'\n",
+    "DATE={'start':'1990-01-01', 'end':current_date}\n",
+    "INTERVAL='2m'\n",
+    "AUTO_PERIOD= True\n",
+    "PERIOD='60d'\n",
+    "# LLMsP\n",
+    "OPENAI_MODEL = \"gpt-5-nano\"\n",
+    "CLAUDE_MODEL = \"claude-sonnet-4-20250514\"\n",
+    "GIMINI_MODEL =  \"gemini-2.5-flash\"\n",
+    "DEEPSEEK_MODEL = \"deepseek-reasoner\"\n",
+    "QWEN3_MODEL = \"Qwen/Qwen3-Coder-480B-A35B-Instruct\"\n",
+    "QWEN2_MODEL = \"Qwen/Qwen2.5-Coder-32B-Instruct\"\n",
+    "SAVE_PLT= True\n",
+    "GROK4_MODEL = \"grok-4-fast-reasoning\"\n",
+    "LOCAL=True\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4a0713ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Initialize clients\n",
+    "openai = OpenAI()\n",
+    "deepseek_api= OpenAI(\n",
+    "        api_key=deepseek_api_key, \n",
+    "        base_url=\"https://api.deepseek.com\"\n",
+    "        )\n",
+    "gemini_api = OpenAI(\n",
+    "        api_key=google_api_key, \n",
+    "        base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\"\n",
+    "        )\n",
+    "grok_api = OpenAI(api_key=grok_api_key, base_url=\"https://api.x.ai/v1\")\n",
+    "claude = anthropic.Anthropic()\n",
+    "client = InferenceClient()     # For HuggingFace Inference API"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3bbe4f90",
+   "metadata": {},
+   "source": [
+    "## Prompt "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ea6649c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import inspect\n",
+    "from bt_strategies import SmaCross\n",
+    "import re\n",
+    "# VERSION not working\n",
+    "def format_class(strategy):\n",
+    "    def replace_docstring(match):\n",
+    "    # Replace with cleaned docstring\n",
+    "        if remaining_doc:\n",
+    "            return f'\"\"\"\\n{remaining_doc}\\n    \"\"\"'\n",
+    "        else:\n",
+    "            return '\"\"\"\"\"\"'  # Empty docstring\n",
+    "    source_code = inspect.getsource(strategy)\n",
+    "    #print(source_code)\n",
+    "    docstring = SmaCross.__doc__\n",
+    "    user_prompt_match = re.search(r'User prompt:\\s*\"([^\"]+)\"', docstring)\n",
+    "    user_prompt = user_prompt_match.group(1) if user_prompt_match else \"No user prompt found.\"\n",
+    "\n",
+    "    call_match = re.search(r'Call:\\s*(.+)', docstring)\n",
+    "    call_line = call_match.group(1) if call_match else \"cerebro.addstrategy(NotFoundStrategy)\"\n",
+    "    \n",
+    "    # Clean docstring\n",
+    "    remaining_doc = re.sub(r'User prompt:\\s*\"[^\"]+\"\\s*\\n?', '', docstring)\n",
+    "    remaining_doc = re.sub(r'Call:\\s*.+\\s*\\n?', '', remaining_doc)\n",
+    "    remaining_doc = remaining_doc.strip()\n",
+    "    \n",
+    "    pattern = r'(\"\"\".*?\"\"\"|\\'\\'\\'.*?\\'\\'\\')'\n",
+    "    clean_source = re.sub(pattern, replace_docstring, source_code, count=1, flags=re.DOTALL)\n",
+    "\n",
+    "\n",
+    "    # ✅ Final formatted output\n",
+    "    final_output = f'''\n",
+    "# User prompt:\n",
+    "# \"{user_prompt}\"\n",
+    "\n",
+    "# Generated Python code:\n",
+    "import backtrader as bt\n",
+    "{clean_source}\n",
+    "# Initialize Cerebro\n",
+    "cerebro = bt.Cerebro()\n",
+    "{call_line}\n",
+    "'''\n",
+    "    return final_output\n",
+    "\n",
+    "print (format_class(SmaCross))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "104360db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "example_1= ''' \n",
+    "# User prompt:\n",
+    "# \"Go long when the 10-period SMA crosses above the 100-period SMA,\n",
+    "#  and exit when the 10-period SMA crosses below the 100-period SMA.\"\n",
+    "\n",
+    "# Generated Python code:\n",
+    "import backtrader as bt\n",
+    "class SmaCross(bt.Strategy):\n",
+    "    \"\"\"\n",
+    "    Simple moving average crossover strategy.\n",
+    "    Buy when fast SMA crosses above slow SMA.\n",
+    "    Sell when fast SMA crosses below slow SMA.\n",
+    "    \"\"\"\n",
+    "    params = dict(pfast=10, pslow=100)\n",
+    "\n",
+    "    def __init__(self):\n",
+    "        self.sma_fast = bt.ind.SMA(period=self.p.pfast)\n",
+    "        self.sma_slow = bt.ind.SMA(period=self.p.pslow)\n",
+    "        self.crossover = bt.ind.CrossOver(self.sma_fast, self.sma_slow)\n",
+    "\n",
+    "    def next(self):\n",
+    "        if not self.position:\n",
+    "            if self.crossover > 0:  # Golden cross\n",
+    "                self.buy()\n",
+    "        elif self.crossover < 0:   # Death cross\n",
+    "            self.close()\n",
+    "\n",
+    "# Initialize Cerebro\n",
+    "cerebro = bt.Cerebro()\n",
+    "cerebro.addstrategy(SmaCross, pfast=10, pslow=100)\n",
+    "'''\n",
+    "list_of_pyclasses = [example_1]\n",
+    "system_message = f'''\n",
+    "You are a financial assistant specialized in transforming natural language descriptions of trading strategies into clean, production-ready Python code.\n",
+    "\n",
+    "Guidelines:\n",
+    "- Use only the library {API_FIN}.\n",
+    "- Always create a class with the abreviation of the strategy with the form `NameOfStrategy(bt.Strategy)`.\n",
+    "- Implement strategy logic in `__init__` (indicators/signals) and `next()` (trade execution).\n",
+    "- Implement the strategy for this intervall of time {INTERVAL} \n",
+    "- Finish with initializing the strategy in Cerebro:\n",
+    "  cerebro = bt.Cerebro()\n",
+    "  cerebro.addstrategy(MyStrategy, param1=value, param2=value)\n",
+    "- Keep code minimal, clear, and follow Python best practices (PEP8, clear naming, modularity).\n",
+    "- If a strategy cannot be implemented with {API_FIN}, respond with: \"Unable to implement with {API_FIN}.\"\n",
+    "- If used any addional libraries, add it in the code: import MyUsedLibrary\n",
+    "- If you don't know the answer, just say that you don't know, don't try to make up an answer.\n",
+    "\n",
+    "Example(s) of transformation from user prompt to Python code: \\n\n",
+    "'''\n",
+    "for pyclass in list_of_pyclasses:\n",
+    "  system_message += pyclass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "f868548e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def user_prompt_for(user_msg):\n",
+    "    return f\"\"\"\n",
+    "Trading strategy description:\n",
+    "\\\"\\\"\\\"{user_msg}\\\"\\\"\\\"\n",
+    "\n",
+    "Task:\n",
+    "- Convert the description into executable Python code.\n",
+    "- Use only the library {API_FIN}.\n",
+    "- Respond only with valid Python code, following Python best practices\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "1589df2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Messages in Openai format \n",
+    "def messages_for(user_msg):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_message},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(user_msg)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2ac6d71d",
+   "metadata": {},
+   "source": [
+    "## LLMS executors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "f522a0de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_llms(user_msg, typ_llm=\"gpt\"):   \n",
+    "    messages = messages_for(user_msg)\n",
+    "    if typ_llm.lower() == \"deepseek\": \n",
+    "        stream = deepseek_api.chat.completions.create(\n",
+    "            model=\"deepseek-chat\",\n",
+    "            messages=messages,\n",
+    "            stream=True\n",
+    "        )\n",
+    "    elif typ_llm.lower() == \"gimini\":\n",
+    "        stream = gemini_api.chat.completions.create(\n",
+    "            model=\"gemini-2.5-flash\",\n",
+    "            messages=messages,\n",
+    "            stream=True\n",
+    "        )\n",
+    "    elif typ_llm.lower() == \"qween2\":\n",
+    "        stream = client.chat.completions.create(\n",
+    "            model=QWEN2_MODEL,\n",
+    "            messages=messages,\n",
+    "            stream= True\n",
+    "        )\n",
+    "    elif typ_llm.lower() == \"qween3\":\n",
+    "        stream = client.chat.completions.create(\n",
+    "            model=QWEN3_MODEL,\n",
+    "            messages=messages,\n",
+    "            stream= True\n",
+    "        )\n",
+    "    elif typ_llm.lower() == \"grok4\":\n",
+    "        stream = grok_api.chat.completions.create(\n",
+    "            model=GROK4_MODEL,\n",
+    "            messages=messages,\n",
+    "            stream= True\n",
+    "        )\n",
+    "    elif typ_llm.lower() == \"claude\":\n",
+    "        stream =  claude.messages.stream(\n",
+    "        model=CLAUDE_MODEL,\n",
+    "        max_tokens=2000,\n",
+    "        system=messages[0]['content'],\n",
+    "        messages=[messages[1]],\n",
+    "    )\n",
+    "    elif typ_llm.lower() == \"gpt\": \n",
+    "        stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages, stream=True)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unknown model\")\n",
+    "    \n",
+    "    reply = \"\"\n",
+    "    \n",
+    "    if typ_llm.lower() == \"claude\":\n",
+    "        with stream as stream_clde:\n",
+    "            for fragment in stream_clde.text_stream:\n",
+    "                reply += fragment\n",
+    "                #print(fragment, end='', flush=True)\n",
+    "                yield reply.replace(\"```python\\n\",\"\").replace(\"```\",\"\") \n",
+    "    else:\n",
+    "        for chunk in stream:\n",
+    "            if chunk and chunk.choices:\n",
+    "                fragment = chunk.choices[0].delta.content or \"\"\n",
+    "                reply += fragment\n",
+    "                #print(fragment, end='', flush=True)\n",
+    "                yield reply.replace(\"```python\\n\",\"\").replace(\"```\",\"\") \n",
+    "    #return reply"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "c0089d2b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_manager(user_msg, model):\n",
+    "    result = stream_llms(user_msg, model)\n",
+    "    for stream_so_far in result:\n",
+    "        yield stream_so_far"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "7792fa04",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write to python file\n",
+    "def write_output(code):\n",
+    "    with open(\"code.py\", \"w\") as f:\n",
+    "        f.write(code)\n",
+    "   \n",
+    "def execute_python(code, market_name, interval):\n",
+    "    tckr_symbl = MARKET_TO_TICKER[market_name] \n",
+    "    # For the moment executing this values here in order to put less complexity to users\n",
+    "    interval = interval\n",
+    "    period=PERIOD\n",
+    "    \n",
+    "    code = code.replace(\"```python\",\"\").replace(\"```\",\"\")\n",
+    "    output_code = f'''\n",
+    "from utils import run_bt\n",
+    "import backtrader as bt\n",
+    "{code}\n",
+    "\n",
+    "\n",
+    "_, _, tmp_img =run_bt(cerebro=cerebro, date={DATE}, market_name='{market_name}', save_img={SAVE_PLT}, tckr_symbl='{tckr_symbl}', interval='{interval}', auto_period='{AUTO_PERIOD}', period='{period}')\n",
+    "''' \n",
+    "    tmp_img = \"\"\n",
+    "    write_output(code)\n",
+    "    output = io.StringIO()\n",
+    "    sys_stdout = sys.stdout\n",
+    "    sys.stdout = output\n",
+    "    try:\n",
+    "        # Execute the code into its own namespace\n",
+    "        namespace = {}\n",
+    "        exec(output_code, namespace)\n",
+    "        tmp_img = namespace.get(\"tmp_img\", None)   # ✅ retrieve from namespace\n",
+    "    finally:\n",
+    "        sys.stdout = sys_stdout\n",
+    "\n",
+    "    return output.getvalue(), tmp_img"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e94c2b6b",
+   "metadata": {},
+   "source": [
+    "## Gradio interface"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "94dde64e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "market_list = list(MARKET_TO_TICKER.keys())\n",
+    "with gr.Blocks() as ui:\n",
+    "    gr.Markdown(\"## Convert Written Strategies into Python Code\")\n",
+    "    with gr.Row():\n",
+    "        strategy_msg = gr.Textbox( value=\"\", label=\"Enter the description of your strategy. \", lines=10)\n",
+    "        code = gr.Textbox(label=\"Python code:\", lines=10)\n",
+    "    with gr.Row():\n",
+    "         gen_strategy = gr.Button(\"Generate Strategy\")       \n",
+    "         run_py = gr.Button(\"Run Python Code \", visible=True)\n",
+    "    with gr.Row():\n",
+    "        with gr.Column():\n",
+    "            model = gr.Dropdown([\"GPT\", \"Claude\", \"Deepseek\", \"Gimini\",\"Qween2\", \"Qween3\", \"Grok4\"], label=\"Select model\", value=\"Deepseek\")\n",
+    "            market = gr.Dropdown(market_list, label=\"Stock Name\", value=\"S&P 500 ETF\")\n",
+    "            #date = gr.Textbox( value=\"2025-10-10\", label=\"End Date (yyyy-mm-dd)\", placeholder=\"yyyy-mm-dd\")\n",
+    "            interval = gr.Dropdown([\"1m\",\"2m\", \"5m\", \"15m\", \"30m\", \"1h\",\"1d\"], value=\"1d\", label=\"Interval\")\n",
+    "            #period = gr.Dropdown([\"30d\", \"10d\", \"60d\"], value=\"60d\", label=\"Period\")\n",
+    "        with gr.Row():\n",
+    "            py_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n",
+    "    with gr.Column():    \n",
+    "        #image_output = gr.Image(type=\"numpy\", label=\"Chart\")\n",
+    "        image_output = gr.Gallery(\n",
+    "            label=\"Charts\", \n",
+    "            show_label=True, \n",
+    "            elem_id=\"gallery\",\n",
+    "            columns=2, \n",
+    "            height=\"auto\"     # Height parameter\n",
+    "        )\n",
+    "\n",
+    "    # Select and send msg to create python outpu\n",
+    "    gen_strategy.click(stream_manager, inputs=[strategy_msg, model], outputs=[code])\n",
+    "    run_py.click(execute_python, inputs=[code, market, interval] , outputs=[py_out, image_output])\n",
+    "            \n",
+    "ui.launch(inbrowser=True, share=True, debug=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c3951dbd",
+   "metadata": {},
+   "source": [
+    "## On work\n",
+    "\n",
+    "Format backtrading strategies for doing multi prompt learning."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e82f32e8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import inspect\n",
+    "from bt_strategies import SmaCross\n",
+    "import re\n",
+    "# VERSION not working\n",
+    "def format_class(strategy):\n",
+    "    def replace_docstring(match):\n",
+    "    # Replace with cleaned docstring\n",
+    "        if remaining_doc:\n",
+    "            return f'\"\"\"\\n{remaining_doc}\\n    \"\"\"'\n",
+    "        else:\n",
+    "            return '\"\"\"\"\"\"'  # Empty docstring\n",
+    "    source_code = inspect.getsource(strategy)\n",
+    "    #print(source_code)\n",
+    "    docstring = SmaCross.__doc__\n",
+    "    user_prompt_match = re.search(r'User prompt:\\s*\"([^\"]+)\"', docstring)\n",
+    "    user_prompt = user_prompt_match.group(1) if user_prompt_match else \"No user prompt found.\"\n",
+    "\n",
+    "    call_match = re.search(r'Call:\\s*(.+)', docstring)\n",
+    "    call_line = call_match.group(1) if call_match else \"cerebro.addstrategy(NotFoundStrategy)\"\n",
+    "    \n",
+    "    # Clean docstring\n",
+    "    remaining_doc = re.sub(r'User prompt:\\s*\"[^\"]+\"\\s*\\n?', '', docstring)\n",
+    "    remaining_doc = re.sub(r'Call:\\s*.+\\s*\\n?', '', remaining_doc)\n",
+    "    remaining_doc = remaining_doc.strip()\n",
+    "    \n",
+    "    pattern = r'(\"\"\".*?\"\"\"|\\'\\'\\'.*?\\'\\'\\')'\n",
+    "    clean_source = re.sub(pattern, replace_docstring, source_code, count=1, flags=re.DOTALL)\n",
+    "\n",
+    "\n",
+    "    # ✅ Final formatted output\n",
+    "    final_output = f'''\n",
+    "# User prompt:\n",
+    "# \"{user_prompt}\"\n",
+    "\n",
+    "# Generated Python code:\n",
+    "import backtrader as bt\n",
+    "{clean_source}\n",
+    "# Initialize Cerebro\n",
+    "cerebro = bt.Cerebro()\n",
+    "{call_line}\n",
+    "'''\n",
+    "    return final_output\n",
+    "\n",
+    "print (format_class(SmaCross))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f2b9ef6e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import inspect\n",
+    "from bt_strategies import SmaCross\n",
+    "import re\n",
+    "\n",
+    "def format_class(strategy):\n",
+    "    source_code = inspect.getsource(strategy)\n",
+    "    #print(source_code)\n",
+    "    docstring = SmaCross.__doc__\n",
+    "    user_prompt_match = re.search(r'User prompt:\\s*\"([^\"]+)\"', docstring)\n",
+    "    user_prompt = user_prompt_match.group(1) if user_prompt_match else \"No user prompt found.\"\n",
+    "\n",
+    "    call_match = re.search(r'Call:\\s*(.+)', docstring)\n",
+    "    call_line = call_match.group(1) if call_match else \"cerebro.addstrategy(NotFoundStrategy)\"\n",
+    "\n",
+    "\n",
+    "    # ✅ Final formatted output\n",
+    "    final_output = f'''\n",
+    "    # User prompt:\n",
+    "    # \"{user_prompt}\"\n",
+    "\n",
+    "    # Generated Python code:\n",
+    "    import backtrader as bt\n",
+    "    {source_code}\n",
+    "    # Initialize Cerebro\n",
+    "    cerebro = bt.Cerebro()\n",
+    "    {call_line}\n",
+    "    '''\n",
+    "    return final_output\n",
+    "\n",
+    "print (format_class(SmaCross))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llms",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

app.py

@@ -0,0 +1,298 @@
+
+#%matplotlib inline
+import os
+os.environ.setdefault("MPLBACKEND", "Agg")
+import io
+import sys
+import tempfile
+from datetime import datetime, timedelta
+import pandas as pd
+import yfinance as yf
+from dotenv import load_dotenv
+import gradio as gr
+import yaml
+import traceback
+from strategy_generator import stream_manager
+from utils import (
+    write_output,
+    _to_float_or_default,
+    save_df_to_csv,
+    resolve_market_to_ticker,
+    validate_date_range,
+    validate_ticker_symbol,
+    save_strategy_to_file,
+    yf_interval_info,
+    YF_INTERVALS,
+    YF_TO_FMP_MAP,
+    REPLAY_MAP,
+    update_replay_intervals,
+)
+from data_utils import get_data
+
+# Environment
+load_dotenv(override=True)
+
+with open('config/var_dev.yaml', 'r') as f:
+    config = yaml.safe_load(f)
+
+current_date = datetime.now().strftime('%Y-%m-%d')
+DATE = {'start': '1990-01-01', 'end': current_date}
+
+market_to_ticker = config['market_to_ticker']   
+
+default_data_source = (config.get("data_source") or "fmp").lower()
+
+
+def execute_python(code, market_name, data_source, interval, start_date, end_date, initial_capital, commission, slippage_percent, adjust_prices, replay_enabled, progress=gr.Progress(track_tqdm=True)):
+    """
+    Execute user-provided Python code for backtesting a trading strategy.
+    """
+    # Determine if input is a market name or ticker symbol
+    tckr_symbl = resolve_market_to_ticker(market_name, market_to_ticker)
+    # For the moment executing this values here in order to put less complexity to users
+    interval = interval
+    period = config["period"]
+    selected_start = (start_date or "").strip() or DATE["start"]
+    selected_end = (end_date or "").strip() or current_date
+    date_range = {"start": selected_start, "end": selected_end}
+    # Validate dates
+    try:
+        validated_start, validated_end = validate_date_range(selected_start, selected_end, current_date)
+        date_range = {"start": validated_start, "end": validated_end}
+    except ValueError as e:
+        err = str(e)
+        return err, [], None, None, err
+
+    # Validate ticker symbol
+    try:
+        market_name = validate_ticker_symbol(tckr_symbl, data_source)
+    except ValueError as e:
+        err = str(e)
+        return err, [], None, None, err
+
+    capital_value = _to_float_or_default(initial_capital, config["initial_capital"])
+    commission_value = _to_float_or_default(commission, config["commission"])
+    slippage_percent_value = _to_float_or_default(slippage_percent, config["slippage_percent"])
+    adjust_prices_value = bool(adjust_prices) if adjust_prices is not None else bool(config.get("adjust_prices", True))
+
+    # Extract replay parameters and map intervals
+    replay_interval = interval
+    replay_compression = 1
+    source_lower = data_source.lower()
+
+    if replay_enabled and interval in REPLAY_MAP:
+        # Replay mode: use REPLAY_MAP
+        fmp_interval, yf_interval, compression = REPLAY_MAP[interval]
+        replay_interval = fmp_interval if source_lower == "fmp" else yf_interval
+        replay_compression = compression
+    elif source_lower == "fmp":
+        # FMP mode: map YF interval to FMP interval
+        fmp_interval = YF_TO_FMP_MAP.get(interval)
+        if fmp_interval is None:
+            err = f"❌ Interval '{interval}' not supported by FMP. Please switch to Yahoo data source."
+            return err, [], None, None
+        replay_interval = fmp_interval
+
+    # Fetch data once and pass to run_bt
+    status_msg = ""
+    progress(0, desc="Fetching data")
+    try:
+        print(f"Replay enabled: {replay_enabled}, interval: {interval}, mapped interval: {replay_interval}, compression: {replay_compression}")
+        df = get_data(
+            data_source=data_source,
+            tckr_symbl=tckr_symbl,
+            interval=replay_interval,
+            date=date_range,
+            adjust_prices=adjust_prices_value,
+            auto_period=config["auto_period"],
+            period=period,
+            upload_data=config.get("upload_data", False),
+            upload_data_path=config.get("upload_data_path"),
+            progress=progress
+        )
+        source_lower = data_source.lower()
+        show_range = (source_lower == "fmp") or (source_lower in ["yahoofinance", "yf", "yahoo"] and interval not in ["1m", "2m", "5m", "15m", "30m", "60m", "1h"])
+        status_msg = f"Data loaded: {len(df)} rows via {data_source} @ interval {interval}."
+        if show_range:
+            status_msg = f"{status_msg} Date range: {date_range['start']} → {date_range['end']}."
+        progress(0.6, desc="Data loaded")
+        if source_lower in ["yahoofinance", "yf", "yahoo"]:
+            extra = yf_interval_info(date_range, interval, config["auto_period"])
+            if extra:
+                status_msg = f"{status_msg}\n{extra}"
+    except Exception as e:
+        err = f"❌ Error loading data: {e}"
+        return err, [], None, None, err
+
+    code = code.replace("```python","").replace("```","")
+    # Extract dataframes from run_bt return values
+    progress(0.75, desc="Running strategy")
+    output_code = f'''
+from bt_utils import run_bt
+import backtrader as bt
+{code}
+
+
+final_value, total_return, tmp_img, df_trades, df_transactions = run_bt(
+    cerebro=cerebro,
+    market_name='{market_name}',
+    save_img={config["save_plt"]},
+    tckr_symbl='{tckr_symbl}',
+    initial_capital={capital_value},
+    commission={commission_value},
+    slippage_percent={slippage_percent_value},
+    df=df,
+    replay={replay_enabled},
+    replay_compression={replay_compression},
+    interval='{replay_interval}'
+)
+'''
+    tmp_img = ""
+    df_trades = None
+    df_transactions = None
+    write_output(code)
+    output = io.StringIO()
+    sys_stdout = sys.stdout
+    sys.stdout = output
+    error_msg = None
+    try:
+        # Execute the code into its own namespace
+        namespace = {"df": df}
+        exec(output_code, namespace)
+        tmp_img = namespace.get("tmp_img", None)
+        df_trades = namespace.get("df_trades", None)
+        df_transactions = namespace.get("df_transactions", None)
+    except Exception:
+        error_msg = "❌ Error executing strategy:\n" + traceback.format_exc()
+    finally:
+        sys.stdout = sys_stdout
+
+    if error_msg:
+        combined = (status_msg or "") + ("\n" if status_msg else "") + error_msg
+        return combined, [], None, None, combined
+    progress(1.0, desc="Done")
+    ui_status = status_msg or "Data fetched."
+    return ui_status + "\n" + output.getvalue(), tmp_img, df_trades, df_transactions, ui_status
+
+
+
+
+def run_gradio_app():
+    """ Run the Gradio app for strategy generation and backtesting. """
+    market_list = list[market_to_ticker](market_to_ticker.keys())
+    with gr.Blocks(title="StrategyGenerator", theme=gr.themes.Default(primary_hue="emerald")) as ui:
+        gr.Markdown("# Financial Strategy Generator for Python ")
+        with gr.Tab("Strategy Generator"):
+            with gr.Row():
+                strategy_msg = gr.Textbox( value="", label="Enter the description of your strategy: ", lines=10)
+                code = gr.Textbox(label="Python code:", lines=10)
+            with gr.Row():
+                gen_strategy = gr.Button("Generate Strategy", variant="primary")       
+                run_py = gr.Button("Run Python Code ", visible=True, variant="primary")
+            with gr.Row():
+                with gr.Row():
+                    with gr.Group("General Config"):
+                        with gr.Tab("Model Options"):
+                            with gr.Column():
+                                model = gr.Dropdown(["GPT", "Claude", "Deepseek", "Gemini", "Grok4"], label="Select model", value="Deepseek")
+                        with gr.Tab("Replay Config"):
+                            with gr.Column():
+                                replay_enabled = gr.Checkbox(label="Enable Replay Mode", value=False)
+                                initial_capital_in = gr.Number(label="Initial Capital ($)", value=config.get("initial_capital", 100000.0), precision=2)
+                                data_source = gr.Dropdown(["fmp", "yahoo"], value=default_data_source, label="Data Source")
+                                interval = gr.Dropdown(YF_INTERVALS, value="1d", label="Interval")
+                                start_date = gr.Textbox(value="2020-01-01", label="Start Date (YYYY-MM-DD)")
+                                end_date = gr.Textbox(value=current_date, label="End Date (YYYY-MM-DD, defaults to today)")
+                    with gr.Column():
+                        with gr.Group():
+                            with gr.Tab("ETFS/Stock Selection"):
+                                market = gr.Dropdown(market_list, label="Stock/ETFS (select or type ticker)", value="S&P 500 ETF", allow_custom_value=True)
+                                commission_in = gr.Number(label="Commission per share ($)", value=config.get("commission", 0.005), precision=6)
+                                slippage_percent_in = gr.Number(label="Slippage (% of price, e.g., 0.01 for 0.01%)", value=config.get("slippage_percent", 0.01), precision=6)
+                                adjust_prices_in = gr.Checkbox(label="Use adjusted (dividend/split) prices", value=config.get("adjust_prices", True))
+                    #period = gr.Dropdown(["30d", "10d", "60d"], value="60d", label="Period")
+                with gr.Row():
+                    with gr.Column(scale=6):
+                        py_out = gr.TextArea(label="Python result:", elem_classes=["python"])
+                    with gr.Column(scale=1):
+                        with gr.Group():
+                            download_strategy_btn = gr.DownloadButton("Download Strategy Code", variant="primary")
+                            strategy_file = gr.File(label="Strategy File", visible=True, interactive=False)
+        with gr.Tab("Charts"):
+            image_output = gr.Gallery(
+                label="Charts",
+                show_label=True,
+                elem_id="gallery",
+                columns=2,
+                height="auto"
+            )
+        with gr.Tab("Transactions"):
+            gr.Markdown("### Transaction Records (Buy/Sell Orders)")
+            transactions_df = gr.Dataframe(
+                label="All Transactions",
+                interactive=False,
+                wrap=True
+            )
+            with gr.Group():
+                download_transactions_btn = gr.Button("Generate CSV", variant="primary")
+                transactions_csv = gr.File(label="Download Transactions CSV", visible=True)
+
+        with gr.Tab("Trades"):
+            gr.Markdown("### Trade Records (Entry/Exit)")
+            trades_df = gr.Dataframe(
+                label="All Trades",
+                interactive=False,
+                wrap=True
+            )
+            with gr.Group():
+                download_trades_btn = gr.Button("Generate CSV", variant="primary")
+                trades_csv = gr.File(label="Download Trades CSV", visible=True)
+        # Connect generate strategy button
+        gen_strategy.click(stream_manager, inputs=[strategy_msg, model], outputs=[code])
+
+        replay_enabled.change(
+            fn=update_replay_intervals,
+            inputs=[replay_enabled],
+            outputs=[interval],
+        )
+
+        # Connect run button to execute strategy and update all outputs
+        run_py.click(
+            execute_python,
+            inputs=[
+                code,
+                market,
+                data_source,
+                interval,
+                start_date,
+                end_date,
+                initial_capital_in,
+                commission_in,
+                slippage_percent_in,
+                adjust_prices_in,
+                replay_enabled,
+            ],
+            outputs=[py_out, image_output, trades_df, transactions_df],
+        )
+
+        # Connect CSV download buttons
+        download_transactions_btn.click(
+            lambda df: save_df_to_csv(df, "transactions"),
+            inputs=[transactions_df],
+            outputs=[transactions_csv]
+        )
+
+        download_trades_btn.click(
+            lambda df: save_df_to_csv(df, "trades"),
+            inputs=[trades_df],
+            outputs=[trades_csv]
+        )
+        download_strategy_btn.click(
+            save_strategy_to_file,
+            inputs=[code],
+            outputs=[strategy_file]
+        )
+    ui.launch(inbrowser=True, share=False, debug=True)
+    
+if __name__ == "__main__":
+    run_gradio_app()

bt_strategies.py

@@ -0,0 +1,463 @@
+import backtrader as bt
+import pandas as pd
+
+
+class SmaCross(bt.Strategy):
+    """
+    Simple moving average crossover strategy.
+    Buy when fast SMA crosses above slow SMA.
+    Sell when fast SMA crosses below slow SMA.
+    
+    User prompt: "Go long when the 10-period SMA crosses above the 100-period SMA,
+    and exit when the 10-period SMA crosses below the 100-period SMA."
+    
+    Call: cerebro.addstrategy(SmaCross, pfast=10, pslow=100)
+    """
+    params = dict(pfast=10, pslow=100)
+
+    def __init__(self):
+        self.sma_fast = bt.ind.SMA(period=self.p.pfast)
+        self.sma_slow = bt.ind.SMA(period=self.p.pslow)
+        self.crossover = bt.ind.CrossOver(self.sma_fast, self.sma_slow)
+
+    def next(self):
+        if not self.position:
+            if self.crossover > 0:  # Golden cross
+                self.buy()
+        elif self.crossover < 0:   # Death cross
+            self.close()
+
+class TrendMomentumLongStrategy(bt.Strategy):
+    """
+    Multi-indicator strategy with trend following and momentum 
+    Long entries
+    """
+    params = dict(
+        sma_fast=5,# 20
+        sma_slow=30,# 50
+        rsi_period=14,
+        rsi_upper=90, # 70
+        rsi_lower=30,
+        atr_period=14,
+        atr_multiplier=2.0
+    )
+
+    def __init__(self):
+        # Trend indicators
+        self.sma_fast = bt.ind.SMA(period=self.p.sma_fast)
+        self.sma_slow = bt.ind.SMA(period=self.p.sma_slow)
+        self.trend = self.sma_fast - self.sma_slow
+        
+        # Momentum indicator
+        self.rsi = bt.ind.RSI(period=self.p.rsi_period)
+        
+        # Volatility for position sizing
+        self.atr = bt.ind.ATR(period=self.p.atr_period)
+        
+        # Crossovers focall_liner entry signals
+        self.crossover = bt.ind.CrossOver(self.sma_fast, self.sma_slow)
+
+    def next(self):
+        # Calculate position size based on volatility (1% risk per trade)
+        if self.atr[0] > 0:
+            risk_amount = self.broker.getvalue() * 0.01
+            size = risk_amount / (self.atr[0] * self.p.atr_multiplier)
+            size = int(size)
+        else:
+            size = 100  # Default size
+        
+        # Entry conditions: Golden cross + RSI not overbought
+        if not self.position:
+            if (self.crossover > 0 and 
+                self.rsi < self.p.rsi_upper and
+                self.trend > 0):
+                self.buy(size=size)
+        
+        # Exit conditions: Death cross OR RSI overbought
+        elif self.position:
+            if (self.crossover < 0 or 
+                self.rsi > self.p.rsi_upper or
+                self.trend < 0):
+                self.close()
+                
+                
+class TrendMomentumShortStrategy(bt.Strategy):
+    """
+    Multi-indicator strategy with trend following and momentum 
+    Short entries only
+    """
+    params = dict(
+        sma_fast=5,     # Fast SMA period
+        sma_slow=30,    # Slow SMA period
+        rsi_period=14,  # RSI period
+        rsi_upper=70,   # Overbought threshold
+        rsi_lower=10,   # Oversold threshold
+        atr_period=14,  # ATR period for volatility-based sizing
+        atr_multiplier=2.0
+    )
+
+    def __init__(self):
+        # Trend indicators
+        self.sma_fast = bt.ind.SMA(period=self.p.sma_fast)
+        self.sma_slow = bt.ind.SMA(period=self.p.sma_slow)
+        self.trend = self.sma_fast - self.sma_slow
+        
+        # Momentum indicator
+        self.rsi = bt.ind.RSI(period=self.p.rsi_period)
+        
+        # Volatility indicator
+        self.atr = bt.ind.ATR(period=self.p.atr_period)
+        
+        # Crossover signal
+        self.crossover = bt.ind.CrossOver(self.sma_fast, self.sma_slow)
+
+    def next(self):
+        # Volatility-based position sizing (1% risk per trade)
+        if self.atr[0] > 0:
+            risk_amount = self.broker.getvalue() * 0.01
+            size = risk_amount / (self.atr[0] * self.p.atr_multiplier)
+            size = int(size)
+        else:
+            size = 100  # Fallback default
+        
+        # Entry conditions: Death cross + RSI not oversold
+        if not self.position:
+            if (self.crossover < 0 and 
+                self.rsi > self.p.rsi_lower and
+                self.trend < 0):
+                self.sell(size=size)
+        
+        # Exit conditions: Golden cross OR RSI oversold
+        elif self.position:
+            if (self.crossover > 0 or 
+                self.rsi < self.p.rsi_lower or
+                self.trend > 0):
+                self.close()
+            
+                
+# Go long when the 10-period SMA crosses above the 100-period SMA, and exit when the 10-period SMA crosses below the 100-period SMA.
+# With logging
+class SmaCrossExtended(bt.Strategy):
+    '''
+    Follow two moving average lines on a stock chart to decide when to buy and sell.
+    '''
+    params = dict(pfast=10, pslow=100)
+    
+    def __init__(self):
+        self.sma1 = bt.ind.SMA(period=self.p.pfast)
+        self.sma2 = bt.ind.SMA(period=self.p.pslow)
+        self.crossover = bt.ind.CrossOver(self.sma1, self.sma2)
+        
+        # Initialize order tracking
+        self.order = None
+        
+    def log(self, txt, dt=None):
+        """Logging function for this strategy"""
+        dt = dt or self.datas[0].datetime.date(0)
+        print(f'{dt.isoformat()}: {txt}')
+    
+    def notify_order(self, order):
+        """Called when order status changes"""
+        if order.status in [order.Submitted, order.Accepted]:
+            # Order submitted/accepted - nothing to do
+            return
+        
+        # Order completed
+        if order.status in [order.Completed]:
+            if order.isbuy():
+                self.log(f'BUY EXECUTED - Price: {order.executed.price:.2f}, '
+                        f'Cost: {order.executed.value:.2f}, '
+                        f'Comm: {order.executed.comm:.2f}, '
+                        f'Size: {order.executed.size}')
+            else:
+                self.log(f'SELL EXECUTED - Price: {order.executed.price:.2f}, '
+                        f'Cost: {order.executed.value:.2f}, '
+                        f'Comm: {order.executed.comm:.2f}, '
+                        f'Size: {order.executed.size}')
+                        
+        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
+            self.log('Order Canceled/Margin/Rejected')
+        
+        # Reset order
+        self.order = None
+    
+    def notify_trade(self, trade):
+        """Called when a trade is closed"""
+        if not trade.isclosed:
+            return
+        
+        self.log(f'TRADE CLOSED - PnL: {trade.pnl:.2f}, PnL Net: {trade.pnlcomm:.2f}')
+    
+    def next(self):
+        # Check if we have a pending order
+        if self.order:
+            return
+        
+        if not self.position:  # not in market
+            if self.crossover > 0:  # Golden cross
+                self.log('BUY SIGNAL DETECTED')
+                self.order = self.buy()
+                
+        else:  # in market
+            if self.crossover < 0:  # Death cross
+                self.log('SELL SIGNAL DETECTED')
+                self.order = self.close()
+                
+
+import backtrader as bt
+
+class TrendMomentumLongStrategyTS(bt.Strategy):
+    """
+    Multi-indicator strategy with trend following and momentum 
+    Long entries with take profit and stop loss
+    """
+    params = dict(
+        sma_fast=5,
+        sma_slow=30,
+        rsi_period=14,
+        rsi_upper=90,
+        rsi_lower=30,
+        atr_period=14,
+        atr_multiplier=2.0,
+        stop_loss_pct=0.05,    # 5% stop loss
+        take_profit_pct=0.10   # 10% take profit
+    )
+
+    def __init__(self):
+        # Trend indicators
+        self.sma_fast = bt.ind.SMA(period=self.p.sma_fast)
+        self.sma_slow = bt.ind.SMA(period=self.p.sma_slow)
+        self.trend = self.sma_fast - self.sma_slow
+        
+        # Momentum indicator
+        self.rsi = bt.ind.RSI(period=self.p.rsi_period)
+        
+        # Volatility for position sizing
+        self.atr = bt.ind.ATR(period=self.p.atr_period)
+        
+        # Crossovers for entry signals
+        self.crossover = bt.ind.CrossOver(self.sma_fast, self.sma_slow)
+        
+        # Track entry price for stop loss and take profit
+        self.entry_price = None
+
+    def next(self):
+        # Calculate position size based on volatility (1% risk per trade)
+        if self.atr[0] > 0:
+            risk_amount = self.broker.getvalue() * 0.01
+            size = risk_amount / (self.atr[0] * self.p.atr_multiplier)
+            size = int(size)
+        else:
+            size = 100  # Default size
+        
+        # Entry conditions: Golden cross + RSI not overbought
+        if not self.position:
+            if (self.crossover > 0 and 
+                self.rsi < self.p.rsi_upper and
+                self.trend > 0):
+                self.buy(size=size)
+                self.entry_price = self.data.close[0]  # Track entry price
+        
+        # Exit conditions: Death cross OR RSI overbought OR stop loss/take profit
+        elif self.position:
+            current_price = self.data.close[0]
+            
+            # Calculate stop loss and take profit levels
+            stop_loss_price = self.entry_price * (1 - self.p.stop_loss_pct)
+            take_profit_price = self.entry_price * (1 + self.p.take_profit_pct)
+            
+            # Check exit conditions
+            if (self.crossover < 0 or 
+                self.rsi > self.p.rsi_upper or
+                self.trend < 0 or
+                current_price <= stop_loss_price or
+                current_price >= take_profit_price):
+                self.close()
+                self.entry_price = None  # Reset entry price
+
+
+
+class TrendMomentumShortStrategyTS(bt.Strategy):
+    """
+    Multi-indicator strategy with trend following and momentum 
+    Short entries only with take profit and stop loss
+    """
+    params = dict(
+        sma_fast=5,     # Fast SMA period
+        sma_slow=30,    # Slow SMA period
+        rsi_period=14,  # RSI period
+        rsi_upper=70,   # Overbought threshold
+        rsi_lower=10,   # Oversold threshold
+        atr_period=14,  # ATR period for volatility-based sizing
+        atr_multiplier=2.0,
+        stop_loss_pct=0.05,    # 5% stop loss
+        take_profit_pct=0.10   # 10% take profit
+    )
+
+    def __init__(self):
+        # Trend indicators
+        self.sma_fast = bt.ind.SMA(period=self.p.sma_fast)
+        self.sma_slow = bt.ind.SMA(period=self.p.sma_slow)
+        self.trend = self.sma_fast - self.sma_slow
+        
+        # Momentum indicator
+        self.rsi = bt.ind.RSI(period=self.p.rsi_period)
+        
+        # Volatility indicator
+        self.atr = bt.ind.ATR(period=self.p.atr_period)
+        
+        # Crossover signal
+        self.crossover = bt.ind.CrossOver(self.sma_fast, self.sma_slow)
+        # Entry price for stop loss and take profit
+        self.entry_price = None
+
+
+    def next(self):
+        # Volatility-based position sizing (1% risk per trade)
+        if self.atr[0] > 0:
+            risk_amount = self.broker.getvalue() * 0.01
+            size = risk_amount / (self.atr[0] * self.p.atr_multiplier)
+            size = int(size)
+        else:
+            size = 100  # Fallback default
+        
+        # Entry conditions: Death cross + RSI not oversold
+        if not self.position:
+            if (self.crossover < 0 and 
+                self.rsi > self.p.rsi_lower and
+                self.trend < 0):
+                self.sell(size=size)
+                self.entry_price = self.data.close[0]  # Track entry price
+        
+        # Exit conditions: Golden cross OR RSI oversold OR stop loss/take profit
+        elif self.position:
+            current_price = self.data.close[0]
+            
+            # Calculate stop loss and take profit levels
+            # For short positions:
+            # - Stop loss triggers when price goes UP (price > entry * (1 + stop_loss_pct))
+            # - Take profit triggers when price goes DOWN (price < entry * (1 - take_profit_pct))
+            stop_loss_price = self.entry_price * (1 + self.p.stop_loss_pct)    # Stop loss above entry
+            take_profit_price = self.entry_price * (1 - self.p.take_profit_pct) # Take profit below entry
+            
+            if (self.crossover > 0 or          # Golden cross
+                self.rsi < self.p.rsi_lower or # RSI oversold
+                self.trend > 0 or              # Trend turned positive
+                current_price >= stop_loss_price or    # Stop loss hit (price went up)
+                current_price <= take_profit_price):   # Take profit hit (price went down)
+                self.close()
+                self.entry_price = None  # Reset entry price
+
+
+class ScalpingBB(bt.Strategy):
+    """
+    Scalping strategy using Bollinger Bands with RSI during high volatility periods.
+    Only trades during specific time windows for 1-minute.
+    """
+    params = dict(
+        bb_period=20,
+        bb_dev=2.0,
+        rsi_period=14,
+        rsi_oversold=30,
+        rsi_overbought=70,
+        start_hour=9,  # 9:00 AM
+        end_hour=16,   # 4:00 PM
+        position_size=100
+    )
+    
+    def __init__(self):
+        # Bollinger Bands indicator
+        self.bb = bt.ind.BollingerBands(
+            period=self.p.bb_period,
+            devfactor=self.p.bb_dev
+        )
+        
+        # RSI indicator for confirmation
+        self.rsi = bt.ind.RSI(
+            period=self.p.rsi_period
+        )
+        
+        # Track current time
+        self.current_time = None
+        
+    def is_trading_hours(self):
+        """Check if current time is within trading hours"""
+        if self.current_time is None:
+            return False
+            
+        hour = self.current_time.hour
+        minute = self.current_time.minute
+        
+        # Check if within 9:00 AM to 4:00 PM
+        if hour < self.p.start_hour or hour >= self.p.end_hour:
+            return False
+            
+        return True
+    
+    def next(self):
+        # Get current datetime
+        self.current_time = self.data.datetime.datetime()
+        
+        # Only trade during specified hours
+        if not self.is_trading_hours():
+            if self.position:
+                self.close()
+            return
+        
+        # Check for buy signal (price touches lower band, RSI oversold)
+        if self.data.close[0] <= self.bb.lines.bot[0] and self.rsi[0] <= self.p.rsi_oversold:
+            if not self.position:
+                self.buy(size=self.p.position_size)
+        
+        # Check for sell signal (price touches upper band, RSI overbought)
+        elif self.data.close[0] >= self.bb.lines.top[0] and self.rsi[0] >= self.p.rsi_overbought:
+            if self.position:
+                self.sell(size=self.p.position_size)
+        
+        # Exit if price returns to middle band
+        elif self.position:
+            if abs(self.data.close[0] - self.bb.lines.mid[0]) < (self.bb.lines.top[0] - self.bb.lines.mid[0]) * 0.3:
+                self.close()
+
+class TripleMACross(bt.Strategy):
+    """
+    Triple moving average crossover strategy with 10% position sizing.
+    - Entry: Fast SMA (5) crosses above Medium SMA (10) and Medium SMA is above Slow SMA (20)
+    - Exit: Fast SMA crosses below Medium SMA OR Medium SMA crosses below Slow SMA
+    - Position sizing: 10% of portfolio per trade
+    """
+    params = (
+        ('fast_period', 5),
+        ('medium_period', 10),
+        ('slow_period', 20),
+    )
+
+    def __init__(self):
+        # Three moving averages
+        self.sma_fast = bt.indicators.SMA(period=self.p.fast_period)
+        self.sma_medium = bt.indicators.SMA(period=self.p.medium_period)
+        self.sma_slow = bt.indicators.SMA(period=self.p.slow_period)
+        
+        # Crossover indicators
+        self.cross_fast_medium = bt.indicators.CrossOver(self.sma_fast, self.sma_medium)
+        self.cross_medium_slow = bt.indicators.CrossOver(self.sma_medium, self.sma_slow)
+        
+        # Track position for conditional logic
+        self.position_open = False
+
+    def next(self):
+        # Entry condition: Fast crosses above Medium AND Medium > Slow (no existing position)
+        if not self.position:
+            if self.cross_fast_medium > 0 and self.sma_medium[0] > self.sma_slow[0]:
+                self.buy(size=self.get_target_size())  # Use dynamic sizing
+                self.position_open = True
+                
+        # Exit conditions: Fast crosses below Medium OR Medium crosses below Slow
+        elif self.position_open:
+            if self.cross_fast_medium < 0 or self.cross_medium_slow < 0:
+                self.close()
+                self.position_open = False
+
+    def get_target_size(self):
+        """Calculate 10% of current portfolio value"""
+        return int((self.broker.getvalue() * 0.90) / self.data.close[0])

bt_strategy.py

@@ -0,0 +1,49 @@
+# Model deepseek-reasoner
+import backtrader as bt
+
+class TripleMACross(bt.Strategy):
+    """
+    Triple moving average crossover strategy with 10% position sizing.
+    - Entry: Fast SMA (5) crosses above Medium SMA (10) and Medium SMA is above Slow SMA (20)
+    - Exit: Fast SMA crosses below Medium SMA OR Medium SMA crosses below Slow SMA
+    - Position sizing: 10% of portfolio per trade
+    """
+    params = (
+        ('fast_period', 5),
+        ('medium_period', 10),
+        ('slow_period', 20),
+    )
+
+    def __init__(self):
+        # Three moving averages
+        self.sma_fast = bt.indicators.SMA(period=self.p.fast_period)
+        self.sma_medium = bt.indicators.SMA(period=self.p.medium_period)
+        self.sma_slow = bt.indicators.SMA(period=self.p.slow_period)
+        
+        # Crossover indicators
+        self.cross_fast_medium = bt.indicators.CrossOver(self.sma_fast, self.sma_medium)
+        self.cross_medium_slow = bt.indicators.CrossOver(self.sma_medium, self.sma_slow)
+        
+        # Track position for conditional logic
+        self.position_open = False
+
+    def next(self):
+        # Entry condition: Fast crosses above Medium AND Medium > Slow (no existing position)
+        if not self.position:
+            if self.cross_fast_medium > 0 and self.sma_medium[0] > self.sma_slow[0]:
+                self.buy(size=self.get_target_size())  # Use dynamic sizing
+                self.position_open = True
+                
+        # Exit conditions: Fast crosses below Medium OR Medium crosses below Slow
+        elif self.position_open:
+            if self.cross_fast_medium < 0 or self.cross_medium_slow < 0:
+                self.close()
+                self.position_open = False
+
+    def get_target_size(self):
+        """Calculate 10% of current portfolio value"""
+        return int((self.broker.getvalue() * 0.90) / self.data.close[0])
+
+# Initialize Cerebro with strategy and sizer
+cerebro = bt.Cerebro()
+cerebro.addstrategy(TripleMACross, fast_period=5, medium_period=10, slow_period=20)

bt_testing.py

@@ -0,0 +1,86 @@
+from fsspec.core import conf
+import yaml
+from bt_strategies import *
+from bt_utils import run_bt
+from data_utils import get_data
+import backtrader as bt
+from datetime import datetime, timedelta
+import pandas as pd
+import matplotlib.dates as mdates
+from tqdm import tqdm
+from dotenv import load_dotenv
+# Environment
+load_dotenv(override=True)
+
+
+
+with open('config/var_dev.yaml', 'r') as f:
+    config = yaml.safe_load(f)
+if config["end_date"]=="current":
+    end = datetime.now().strftime('%Y-%m-%d')
+else:
+    end = config["end_date"]
+DATE= {'start': config["start_date"], 'end': end}
+
+
+cerebro = bt.Cerebro()
+cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe')
+cerebro.addanalyzer(bt.analyzers.DrawDown, _name='drawdown')
+cerebro.addstrategy(TripleMACross, fast_period=5, medium_period=10, slow_period=20)
+"""  
+cerebro.addstrategy(
+    ScalpingBB,
+    bb_period=20,
+    bb_dev=2.0,
+    rsi_period=14,
+    rsi_oversold=30,
+    rsi_overbought=70,
+    start_hour=14,
+    end_hour=21,
+    position_size=10
+)
+
+cerebro.addstrategy(SmaCross, pfast=5, pslow=50)
+cerebro.addstrategy(TrendMomentumLongStrategyTS,         
+                        sma_fast=2,# 20
+                        sma_slow=30,# 50
+                        rsi_period=14,
+                        rsi_upper=80, # 70
+                        rsi_lower=30,
+                        atr_period=14,
+                        atr_multiplier=1.0,
+                        stop_loss_pct=0.5,    # 5% stop loss
+                        take_profit_pct=0.5 )  # 10% take profit    
+   
+cerebro.addstrategy(TrendMomentumShortStrategyTS, sma_fast=10, sma_slow=50, rsi_period=24,  rsi_upper=65,  rsi_lower=40,  atr_period=14, atr_multiplier=2.0, stop_loss_pct=0.5, take_profit_pct=0.5)
+""" 
+ticker_to_market = config['ticker_to_market']
+tckr_symbl = config["market"]
+market_name = ticker_to_market.get(tckr_symbl, tckr_symbl)
+
+df = get_data(
+    data_source=config.get("data_source", "yahoofinance"),
+    tckr_symbl=tckr_symbl,
+    interval=config["interval"],
+    date=DATE,
+    adjust_prices=config.get("adjust_prices", True),
+    auto_period=config.get("auto_period", True),
+    period=config.get("period", "60d"),
+    upload_data=config.get("upload_data", False),
+    upload_data_path=config.get("upload_data_path"),
+)
+run_bt(
+    cerebro=cerebro,
+    market_name=market_name,
+    replay=config["replay"],
+    replay_compression=config["replay_compression"],
+    save_img=config["save_plt"],
+    interval=config["interval"],
+    tckr_symbl=tckr_symbl,
+    initial_capital=config["initial_capital"],
+    commission=config["commission"],
+    slippage_percent=config["slippage_percent"],
+    df=df,
+)
+
+

bt_utils.py

@@ -0,0 +1,261 @@
+import os
+os.environ.setdefault("MPLBACKEND", "Agg")
+from datetime import datetime, timedelta
+from io import BytesIO
+
+import backtrader as bt
+import matplotlib
+import matplotlib.pyplot as plt
+import pandas as pd
+
+matplotlib.use("Agg")  # Set the backend to non-interactive
+
+fmp_intervals_to_int = {"1min":1, "5min":5, "15min":15, "1hour":60, "4hour":240}
+class TransactionRecorder(bt.Analyzer):
+    """ Records all buy/sell transactions with details."""
+    def __init__(self):
+        self.records = []
+
+    def notify_order(self, order):
+        if order.status != order.Completed:
+            return
+
+        self.records.append({
+            'datetime': self.strategy.data.datetime.datetime(),
+            'type': 'BUY' if order.isbuy() else 'SELL',
+            'price': order.executed.price,
+            'size': order.executed.size,
+            'value': order.executed.value,
+            'commission': order.executed.comm,
+        })
+
+    def get_analysis(self):
+        return pd.DataFrame(self.records)
+
+class TradeRecorder(bt.Analyzer):
+    """ Records detailed trade information including entry/exit prices and PnL."""
+    def __init__(self):
+        self.records = []
+        self.trade_id = 0
+
+    def notify_trade(self, trade):
+        # RECORD ENTRY
+        if trade.isopen:
+            self.current_entry_price = trade.price
+            self.current_size = trade.size
+            return
+
+        # RECORD EXIT
+        if trade.isclosed:
+            self.trade_id += 1
+
+            # Backtrader clears trade.size to 0 on close, so restore saved size
+            size = self.current_size  
+
+            # Compute exit price from PnL formula:
+            # pnl = (exit - entry) * size
+            if size is not None and size != 0:
+                exit_price = self.current_entry_price + (trade.pnl / size)
+            else:
+                exit_price = None
+
+            self.records.append({
+                'trade_id': self.trade_id,
+                'size': size,
+                'entry_price': self.current_entry_price,
+                'exit_price': exit_price,
+                'bruto_profitloss': trade.pnl,
+                'neto_profitloss': trade.pnlcomm,
+                'date_open': self._format_dt(trade.dtopen),
+                'date_close': self._format_dt(trade.dtclose),
+            })
+
+            # Reset after close
+            self.current_entry_price = None
+            self.current_size = None
+
+    def get_analysis(self):
+        return pd.DataFrame(self.records)
+
+    def _format_dt(self, val):
+        """Convert a backtrader/matplotlib numeric datetime to a readable string."""
+        if val is None:
+            return None
+        try:
+            ord_day = int(val)
+            frac = val - ord_day
+            dt = datetime.fromordinal(ord_day) + timedelta(days=frac)
+            return dt.strftime("%Y-%m-%d %H:%M:%S")
+        except Exception as e:
+            return "Error formatting dt: " + str(e)
+
+
+def _fig_to_numpy(fig, dpi=150):
+    buf = BytesIO()
+    fig.savefig(buf, format="png", dpi=dpi, bbox_inches="tight")
+    buf.seek(0)
+    img = plt.imread(buf, format="png")
+    buf.close()
+    return img
+
+#TODO: Dates plotting not working
+def plot_bt(figs, symbol, market_name, save_img=True):
+    """
+    Plot backtrader results with market name in title
+    and readable date ticks on all x-axes.
+    """
+    images = []
+
+    plt.ioff()  # Turn off interactive mode
+    for i, fig_list in enumerate(figs):
+        for j, fig in enumerate(fig_list):
+            # Decorate titles
+            if fig.axes:
+                main_ax = fig.axes[0]
+                current_title = main_ax.get_title()
+                new_title = f"{market_name} ({symbol.upper()}) - {current_title or 'Price Chart'}"
+                main_ax.set_title(new_title, fontsize=8, fontweight="bold")
+                fig.suptitle(
+                    f"Trading Strategy Analysis: {market_name}",
+                    fontsize=10,
+                    fontweight="bold",
+                    y=0.98,
+                )
+
+            fig.set_size_inches(12, 6)
+            fig.autofmt_xdate()
+            fig.tight_layout(rect=[0, 0, 1, 0.95])
+            # Convert to numpy
+            img_data = _fig_to_numpy(fig)
+            images.append(img_data)
+
+            if save_img:
+                filename = f"plot_{symbol}_{i}_{j}.png"
+                fig.savefig(filename, dpi=300, bbox_inches="tight")
+                print(f"Chart saved as: {filename}")
+            
+            plt.close(fig)  # Close the figure to free memory
+    return images  
+
+def run_bt(cerebro, 
+           tckr_symbl="SPY", 
+           replay=False,
+           replay_compression=15,
+           save_img=False,
+           interval=None,
+           market_name = "Complete Market Name here",
+           initial_capital=10000.0,
+           commission=0.001,
+           slippage_percent=0.01,
+           df=None):
+    """
+    Run backtrader strategy with enhanced plotting
+    
+    Args:
+        strategy: Backtrader strategy class already init
+        tckr_symbl: Stock ticker symbol
+        save_img: Whether to save plot images
+        initial_capital: Starting capital for the broker
+        commission: Commission per share
+        slippage_percent: Percent (e.g., 0.01 for 0.01%) applied as slippage
+        df: pandas DataFrame with datetime index.
+    """
+
+    print(f"Running strategy on: {market_name} ({tckr_symbl.upper()})")
+    print("-" * 50)
+    print(f"Initial capital: {initial_capital}, Commission: {commission}, Slippage%: {slippage_percent}")
+    
+    if df is None:
+        raise ValueError("df is required. Load data with get_data before calling run_bt.")
+    
+    if replay:
+        print(f"Replaying data on: {market_name} ({tckr_symbl.upper()}) at interval {interval} with compression {replay_compression}")
+        data = bt.feeds.PandasData(dataname=df, timeframe=bt.TimeFrame.Minutes, compression=fmp_intervals_to_int[interval])
+        cerebro.replaydata(data, timeframe=bt.TimeFrame.Minutes, compression=replay_compression)
+    else:
+        data = bt.feeds.PandasData(dataname=df)
+        cerebro.adddata(data)
+    
+    # Set initial cash and commission
+    initial_cash = float(initial_capital)
+    cerebro.broker.setcash(initial_cash)
+    cerebro.broker.setcommission(commission=float(commission))
+    slippage_decimal = float(slippage_percent) / 100.0
+    cerebro.broker.set_slippage_perc(slippage_decimal)
+    
+    # Add analyzers for better performance metrics
+    cerebro.addanalyzer(bt.analyzers.Returns, _name='returns')
+    cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe')
+    cerebro.addanalyzer(bt.analyzers.DrawDown, _name='drawdown')
+    cerebro.addanalyzer(TransactionRecorder,  _name='transactions')
+    cerebro.addanalyzer(TradeRecorder, _name='trades')
+    
+    # Print starting conditions
+    print(f'Starting Portfolio Value: ${cerebro.broker.getvalue():,.2f}')
+    
+
+    # Run strategy
+    results = cerebro.run()
+    
+    # Calculate and display results
+    final_value = cerebro.broker.getvalue()
+    total_return = (final_value - initial_cash) / initial_cash * 100
+    
+    print(f'Final Portfolio Value: ${final_value:,.2f}')
+    print(f'Total Return: {total_return:.2f}%')
+    
+    # Print analyzer results
+    strat = results[0]
+    
+    try:
+        sharpe = strat.analyzers.sharpe.get_analysis().get('sharperatio', 'N/A')
+        if sharpe != 'N/A':
+            print(f'Sharpe Ratio: {sharpe:.3f}')
+        else:
+            print('Sharpe Ratio: N/A')
+    except:
+        print('Sharpe Ratio: N/A')
+    
+    try:
+        max_dd = strat.analyzers.drawdown.get_analysis()['max']['drawdown']
+        print(f'Max Drawdown: {max_dd:.2f}%')
+    except:
+        print('Max Drawdown: N/A')
+
+    # Trades and transaction tables
+    df_transactions = strat.analyzers.transactions.get_analysis()
+    df_trades = strat.analyzers.trades.get_analysis()
+    print(f"Number of Trades: {len(df_trades)}")
+    print("-" * 50)
+    if not df_transactions.empty:
+        print("Transactions logs generated")
+    else:
+        print("No transactions recorded.")
+    if not df_trades.empty:
+        print("Trades logs generated")
+    else:
+        print("No trades recorded.")
+    
+
+
+    
+    # Generate plot with market name (disable interactive plotting to avoid GUI in threads)
+    fig = []
+    try:
+        figs = cerebro.plot(
+            style='candlestick',
+            barstyle='candlestick',
+            subplot=True,
+            plotabove=False,
+            downsample=False,
+            plotstyle='multiple',
+            iplot=False,
+            show=False,
+            dpi=120,
+        )
+        print("How many charts where created: ", len(figs))
+        fig = plot_bt(figs, market_name, tckr_symbl, save_img)
+    except Exception as e:
+        print(f"Plot skipped due to error: {e}")
+    
+    return final_value, total_return, fig, df_trades, df_transactions

config/var_dev.yaml

@@ -0,0 +1,62 @@
+# Init variables for backtrader testing
+# Market name mapping
+market: 'SPY'
+api_fin: 'backtrader'
+
+# Upload data to the database 
+upload_data: false
+upload_data_path: 'data_upload/QQQ.csv'
+
+data_source: "fmp" 
+
+interval: '15min'
+auto_period: true
+period: '60d'
+replay: false
+replay_compression: 5  # in minutes
+initial_capital: 10000.0
+commission: 0.000
+slippage_percent: 0.00  # percent value (0.01% -> 0.01)
+adjust_prices: true
+start_date: "2025-05-01"
+end_date: "2025-12-31"  # not used in bt_testing
+# llms
+openai_model: "gpt-5-nano"
+claude_model: "claude-sonnet-4-20250514"
+gemini_model: "gemini-2.5-flash"
+deepseek_model: "deepseek-reasoner"
+save_plt: false
+grok4_model: "grok-4-fast-reasoning"
+local: false
+
+ticker_to_market:
+  AAPL: Apple Inc.
+  GOOGL: Alphabet/Google
+  AMZN: Amazon.com
+  TSLA: Tesla Inc.
+  JPM: JPMorgan Chase & Co.
+  V: Visa Inc.
+  SPY: S&P 500 ETF
+  QQQ: Nasdaq 100 ETF
+  MSFT: Microsoft Corp.
+  NVDA: NVIDIA Corp.
+  META: Meta Platforms
+  BRK-B: Berkshire Hathaway
+  UNH: UnitedHealth Group
+  XOM: Exxon Mobil Corp.
+
+market_to_ticker:
+  Apple Inc.: AAPL
+  Alphabet/Google: GOOGL
+  Amazon.com: AMZN
+  Tesla Inc.: TSLA
+  JPMorgan Chase & Co.: JPM
+  Visa Inc.: V
+  S&P 500 ETF: SPY
+  Nasdaq 100 ETF: QQQ
+  Microsoft Corp.: MSFT
+  NVIDIA Corp.: NVDA
+  Meta Platforms: META
+  Berkshire Hathaway: BRK-B
+  UnitedHealth Group: UNH
+  Exxon Mobil Corp.: XOM

data_utils.py

@@ -0,0 +1,281 @@
+import os
+os.environ.setdefault("MPLBACKEND", "Agg")
+from datetime import datetime, timedelta
+from typing import Optional
+
+import pandas as pd
+import yfinance as yf
+from fmp_python.fmp import FMP
+from tqdm import tqdm
+
+
+CACHE_DIR = "data_cache"
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+
+def _get_cache_filename_yf(tckr_symbl, interval, start_date, end_date, adjust_prices):
+    start_str = start_date.replace("-", "_")
+    end_str = end_date.replace("-", "_")
+    adjust_str = "adj" if adjust_prices else "raw"
+    return os.path.join(CACHE_DIR, f"{tckr_symbl}_{interval}_{start_str}_to_{end_str}_{adjust_str}.csv")
+
+
+def _get_cache_filename_fmp(tckr_symbl: str, interval: str) -> str:
+    return os.path.join(CACHE_DIR, f"{tckr_symbl}_{interval}_fmp.csv")
+
+
+def _is_valid_cache(df: pd.DataFrame) -> bool:
+    if df.empty or len(df) < 2:
+        return False
+    if not isinstance(df.index, pd.DatetimeIndex):
+        return False
+    required_upper = ["Open", "High", "Low", "Close", "Volume"]
+    required_lower = ["open", "high", "low", "close", "volume"]
+    has_upper = all(col in df.columns for col in required_upper)
+    has_lower = all(col in df.columns for col in required_lower)
+    if not (has_upper or has_lower):
+        return False
+    return True
+
+
+def _load_cached_data(cache_file: str) -> Optional[pd.DataFrame]:
+    if os.path.exists(cache_file):
+        try:
+            df = pd.read_csv(cache_file, index_col=0, parse_dates=True, header=0)
+            if isinstance(df.columns, pd.MultiIndex):
+                df.columns = df.columns.get_level_values(0)
+            if not isinstance(df.index, pd.DatetimeIndex):
+                try:
+                    df.index = pd.to_datetime(df.index)
+                except Exception as e:
+                    print(f"Could not parse dates in cache: {e}, will re-download")
+                    return None
+            expected_upper = ["Open", "High", "Low", "Close", "Volume"]
+            expected_lower = ["open", "high", "low", "close", "volume"]
+            actual_cols = list(df.columns)
+            has_upper = any(col in actual_cols for col in expected_upper)
+            has_lower = any(col in actual_cols for col in expected_lower)
+            if not (has_upper or has_lower):
+                print(f"Unexpected columns in cache: {actual_cols}, will re-download")
+                return None
+            print(f"Loaded cached data: {len(df)} rows, columns: {list(df.columns)} from {cache_file}")
+            return df
+        except Exception as e:
+            print(f"Error loading cache: {e}, will re-download")
+            import traceback
+            traceback.print_exc()
+            return None
+    return None
+
+
+def _save_cached_data(df: pd.DataFrame, cache_file: str):
+    try:
+        df.to_csv(cache_file)
+        print(f"Cached data saved: {cache_file}")
+    except Exception as e:
+        print(f"Error saving cache: {e}")
+
+
+# FMP interval -> max days per API chunk
+FMP_INTERVAL_DAYS = {"1min": 2, "5min": 7, "15min": 38, "1hour": 70, "4hour": 160}
+
+
+def _fetch_fmp_range(fmp, tckr_symbl, interval, start_dt, end_dt, progress=None):
+    """Download FMP data for a date range. Returns DataFrame with 'date' index."""
+    chunk_span = timedelta(days=FMP_INTERVAL_DAYS[interval])
+    frames = []
+
+    # Build chunk list
+    chunks = []
+    temp = start_dt
+    while temp <= end_dt:
+        chunks.append(temp)
+        temp = min(temp + chunk_span, end_dt) + timedelta(days=1)
+
+    # Download with progress
+    if progress:
+        chunk_iter = progress.tqdm(chunks, desc=f"FMP {interval}")
+    else:
+        chunk_iter = tqdm(chunks, desc=f"FMP {interval}")
+
+    for chunk_start in chunk_iter:
+        chunk_end = min(chunk_start + chunk_span, end_dt)
+        try:
+            chunk = fmp.get_historical_chart(
+                interval, tckr_symbl,
+                _from=chunk_start.strftime("%Y-%m-%d"),
+                _to=chunk_end.strftime("%Y-%m-%d")
+            )
+        except Exception as e:
+            raise ValueError(f"FMP download failed ({chunk_start.date()} to {chunk_end.date()}): {e}")
+
+        if chunk is not None and not chunk.empty:
+            chunk["date"] = pd.to_datetime(chunk["date"], errors="coerce")
+            chunk = chunk.dropna(subset=["date"])
+            if not chunk.empty:
+                frames.append(chunk)
+
+    if not frames:
+        return pd.DataFrame()
+
+    df = pd.concat(frames, ignore_index=True)
+    df["date"] = pd.to_datetime(df["date"], errors="coerce")
+    df = df.dropna(subset=["date"])
+
+    # Timezone handling
+    if not df.empty and df["date"].dt.tz is None:
+        df["date"] = df["date"].dt.tz_localize("America/New_York", nonexistent="shift_forward", ambiguous="NaT")
+    df["date"] = df["date"].dt.tz_convert("UTC").dt.tz_localize(None)
+
+    return df.sort_values("date").set_index("date")
+
+
+def _download_data_fmp(tckr_symbl, interval, date, progress=None, replay=False, compression=None):
+    if interval not in FMP_INTERVAL_DAYS:
+        raise ValueError(f"Unsupported FMP interval '{interval}'")
+
+    end_dt = datetime.strptime(date["end"], "%Y-%m-%d")
+    start_dt = datetime.strptime(date["start"], "%Y-%m-%d")
+
+    # Clamp to 15-year limit
+    max_lookback = end_dt - timedelta(days=15 * 365)
+    if start_dt < max_lookback:
+        print(f"Warning: start date clamped to {max_lookback.date()} (15y limit).")
+        start_dt = max_lookback
+
+    fmp = FMP(output_format="pandas", write_to_file=False)
+    cache_file = _get_cache_filename_fmp(tckr_symbl, interval)
+    cached_df = _load_cached_data(cache_file)
+
+    if cached_df is not None and _is_valid_cache(cached_df):
+        cache_start = cached_df.index.min().date()
+        cache_end = cached_df.index.max().date()
+        frames = []
+
+        # Download past data if needed
+        if start_dt.date() < cache_start:
+            past_end = datetime.combine(cache_start - timedelta(days=1), datetime.min.time())
+            print(f"Fetching past data: {start_dt.date()} to {past_end.date()}")
+            chunk_past = _fetch_fmp_range(fmp, tckr_symbl, interval, start_dt, past_end, progress)
+            if not chunk_past.empty:
+                frames.append(chunk_past)
+
+        frames.append(cached_df)
+
+        # Download current data if needed
+        if end_dt.date() > cache_end:
+            current_start = datetime.combine(cache_end + timedelta(days=1), datetime.min.time())
+            print(f"Fetching current data: {current_start.date()} to {end_dt.date()}")
+            chunk_current = _fetch_fmp_range(fmp, tckr_symbl, interval, current_start, end_dt, progress)
+            if not chunk_current.empty:
+                frames.append(chunk_current)
+
+        # Merge, dedupe, sort, save
+        if len(frames) > 1:
+            df = pd.concat(frames).sort_index()
+            df = df[~df.index.duplicated(keep='last')]
+            _save_cached_data(df, cache_file)
+        else:
+            df = cached_df
+            print(f"Using cached data: {len(df)} rows (no download needed)")
+    else:
+        # No cache - download full range
+        print(f"No cache, downloading: {start_dt.date()} to {end_dt.date()}")
+        df = _fetch_fmp_range(fmp, tckr_symbl, interval, start_dt, end_dt, progress)
+        if not df.empty:
+            _save_cached_data(df, cache_file)
+
+    if df.empty:
+        return df
+
+    # Filter to user's requested range
+    df = df[(df.index >= pd.Timestamp(start_dt)) & (df.index <= pd.Timestamp(end_dt))]
+    return df
+
+
+def _download_data_yf(tckr_symbl, interval, date, adjust_prices, auto_period=True, period="60d"):
+    try:
+        print("Interval: ", interval)
+        start_dt = datetime.strptime(date["start"], "%Y-%m-%d")
+        end_dt = datetime.strptime(date["end"], "%Y-%m-%d")
+
+        cache_file = _get_cache_filename_yf(tckr_symbl, interval, date["start"], date["end"], adjust_prices)
+        cached_df = _load_cached_data(cache_file)
+        if cached_df is not None and _is_valid_cache(cached_df):
+            df = cached_df
+            print(f"Using cached data: {len(df)} rows (no download needed)")
+        else:
+            print("No valid cache, downloading...")
+            if interval in ["1m", "2m", "5m", "15m", "30m", "60m", "1h"] and auto_period:
+                if interval in ["1m"]:
+                    max_days = 7
+                elif interval in ["2m", "5m", "15m", "30m"]:
+                    max_days = 60
+                else:
+                    max_days = 730
+                desired_days = max(1, (end_dt - start_dt).days or 1)
+                clamped_days = min(desired_days, max_days)
+                period = f"{clamped_days}d"
+                df = yf.download(tckr_symbl, period=period, interval=interval, auto_adjust=adjust_prices)
+                print(f"Downloaded {interval} data for {period}")
+            else:
+                df = yf.download(tckr_symbl, start=date["start"], end=date["end"], interval=interval, auto_adjust=adjust_prices)
+                print(f"Downloaded data from {date['start']} to {date['end']} with {interval} interval")
+
+            if isinstance(df.columns, pd.MultiIndex):
+                df.columns = df.columns.get_level_values(0)
+            _save_cached_data(df, cache_file)
+            if isinstance(df.columns, pd.MultiIndex):
+                df.columns = df.columns.get_level_values(0)
+            if df.empty:
+                raise ValueError("No data available for the specified parameters!")
+            if df.index.tz is not None:
+                df.index = df.index.tz_localize(None)
+            print(f"Data points: {len(df)}")
+        return df
+    except Exception as e:
+        raise ValueError(f"Error downloading data: {e}")
+
+
+def get_data(
+    data_source: str,
+    tckr_symbl: str,
+    interval: str,
+    date: dict,
+    adjust_prices: bool = True,
+    auto_period: bool = True,
+    period: str = "60d",
+    upload_data: bool = False,
+    upload_data_path: str = None,
+    progress=None,
+):
+    if upload_data:
+        if not upload_data_path:
+            raise ValueError("upload_data_path is required when upload_data is True.")
+        df = pd.read_csv(upload_data_path)
+        if df.shape[1] >= 2:
+            dt = pd.to_datetime(df.iloc[:, 0].astype(str) + " " + df.iloc[:, 1].astype(str), errors="coerce")
+            df = df.drop(columns=df.columns[:2])
+        else:
+            dt = pd.to_datetime(df.iloc[:, 0], errors="coerce")
+            df = df.drop(columns=df.columns[:1])
+        df.insert(0, "datetime", dt)
+        df = df.dropna(subset=["datetime"]).set_index("datetime")
+        expected_cols = ["open", "high", "low", "close", "volume"]
+        if len(df.columns) >= 5:
+            df.columns = list(expected_cols) + list(df.columns[len(expected_cols) :])
+        df.columns = [c.capitalize() for c in df.columns]
+        df.index = df.index.tz_localize(None)
+        return df
+
+    source = (data_source or "").lower()
+    loaders = {
+        "yahoofinance": lambda: _download_data_yf(tckr_symbl, interval, date, adjust_prices, auto_period, period),
+        "yf": lambda: _download_data_yf(tckr_symbl, interval, date, adjust_prices, auto_period, period),
+        "yahoo": lambda: _download_data_yf(tckr_symbl, interval, date, adjust_prices, auto_period, period),
+        "fmp": lambda: _download_data_fmp(tckr_symbl, interval, date, progress),
+    }
+    if source not in loaders:
+        raise ValueError(f"Invalid data source: {data_source}")
+    return loaders[source]()
+

requirements.txt

@@ -0,0 +1,13 @@
+backtrader
+yfinance
+pandas
+matplotlib
+python-dotenv
+gradio
+huggingface_hub
+openai
+anthropic
+ipython 
+opencv-python
+openpyxl
+fmp_python

strategy_generator.py

@@ -0,0 +1,189 @@
+from uu import Error
+import anthropic
+import os
+from dotenv import load_dotenv
+import yaml
+from openai import OpenAI
+from huggingface_hub import InferenceClient
+
+
+load_dotenv(override=True)
+os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')
+os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY')
+google_api_key = os.getenv('GOOGLE_API_KEY')
+deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')
+grok_api_key = os.getenv("XAI_API_KEY")
+
+with open('config/var_dev.yaml', 'r') as f:
+    config = yaml.safe_load(f)
+    
+
+# Logging stuff
+if config["local"]:
+        hf_token = os.getenv('HF_TOKEN') # Sign in to HuggingFace Hub
+else:
+        hf_token =  None
+#huggingface_hub.login(hf_token)
+# Initialize clients
+openai = OpenAI()
+deepseek_api= OpenAI(
+        api_key=deepseek_api_key, 
+        base_url="https://api.deepseek.com"
+        )
+gemini_api = OpenAI(
+        api_key=google_api_key, 
+        base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
+        )
+grok_api = OpenAI(api_key=grok_api_key, base_url="https://api.x.ai/v1")
+claude = anthropic.Anthropic()
+client = InferenceClient()     # For HuggingFace Inference API
+
+LLM_MODEL = None
+
+def user_prompt_for(user_msg):
+    return f"""
+Trading strategy description:
+\"\"\"{user_msg}\"\"\"
+
+Task:
+- Convert the description into executable Python code.
+- Use only the library {config["api_fin"]}.
+- Respond only with valid Python code, following Python best practices
+"""
+
+example_1= f''' 
+# User prompt:
+# "Go long when the 10-period SMA crosses above the 100-period SMA,
+#  and exit when the 10-period SMA crosses below the 100-period SMA."
+
+
+# Generated Python code:
+
+import backtrader as bt
+class SmaCross(bt.Strategy):
+    """
+    Simple moving average crossover strategy.
+    Buy when fast SMA crosses above slow SMA.
+    Sell when fast SMA crosses below slow SMA.
+    """
+    params = dict(pfast=10, pslow=100)
+
+    def __init__(self):
+        self.sma_fast = bt.ind.SMA(period=self.p.pfast)
+        self.sma_slow = bt.ind.SMA(period=self.p.pslow)
+        self.crossover = bt.ind.CrossOver(self.sma_fast, self.sma_slow)
+
+    def next(self):
+        if not self.position:
+            if self.crossover > 0:  # Golden cross
+                self.buy()
+        elif self.crossover < 0:   # Death cross
+            self.close()
+
+# Initialize Cerebro
+cerebro = bt.Cerebro()
+cerebro.addstrategy(SmaCross, pfast=10, pslow=100)
+'''
+list_of_pyclasses = [example_1]
+system_message = f'''
+You are a financial assistant specialized in transforming natural language descriptions of trading strategies into clean, production-ready Python code.
+
+Guidelines:
+- Use only the library {config["api_fin"]}.
+- Always create a class with the abreviation of the strategy with the form `NameOfStrategy(bt.Strategy)`.
+- Implement strategy logic in `__init__` (indicators/signals) and `next()` (trade execution).
+- Implement the strategy for this intervall of time {config["interval"]} 
+- Finish with initializing the strategy in Cerebro:
+  cerebro = bt.Cerebro()
+  cerebro.addstrategy(MyStrategy, param1=value, param2=value)
+- Keep code minimal, clear, and follow Java best practices (PEP8, clear naming, modularity).
+- If a strategy cannot be implemented with {config["api_fin"]}, respond with: "Unable to implement with {config["api_fin"]}."
+- If used any addional libraries, add it in the code: import MyUsedLibrary
+- If you don't know the answer, just say that you don't know, don't try to make up an answer.
+
+
+Example(s) of transformation from user prompt of Python code: \n
+'''
+for pyclass in list_of_pyclasses:
+  system_message += pyclass
+# Messages in Openai format 
+def messages_for(user_msg):
+    return [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": user_prompt_for(user_msg)}
+    ]
+    
+
+def stream_llms(user_msg, typ_llm="gpt"): 
+    """ Stream responses from different LLMs based on user message and selected model. """  
+    global LLM_MODEL
+    llm_key = typ_llm.lower()
+    model_overrides = {
+        "deepseek": ("DEEPSEEK_MODEL", config.get("deepseek_model")),
+        "gemini": ("GEMINI_MODEL", config.get("gemini_model")),
+        "grok4": ("GROK4_MODEL", config.get("grok4_model")),
+        "claude": ("CLAUDE_MODEL", config.get("claude_model")),
+        "gpt": ("OPENAI_MODEL", config.get("openai_model")),
+    }
+    if llm_key not in model_overrides:
+        raise ValueError(f"Name of model {llm_key} not in provided list")
+    env_var, default_model = model_overrides[llm_key]
+    if not default_model:
+        raise KeyError(f"Missing default model configuration for '{llm_key}'")
+    selected_model = os.getenv(env_var) or default_model
+    LLM_MODEL = selected_model
+    messages = messages_for(user_msg)
+    try: 
+        if llm_key == "deepseek": 
+            stream = deepseek_api.chat.completions.create(
+                model=selected_model,
+                messages=messages,
+                stream=True
+            )
+        elif llm_key == "gemini":
+            stream = gemini_api.chat.completions.create(
+                model=selected_model,
+                messages=messages,
+                stream=True
+            )
+        elif llm_key == "grok4":
+            stream = grok_api.chat.completions.create(
+                model=selected_model,
+                messages=messages,
+                stream= True
+            )
+        elif llm_key == "claude":
+            stream =  claude.messages.stream(
+            model=selected_model,
+            max_tokens=2000,
+            system=messages[0]['content'],
+            messages=[messages[1]],
+        )
+        elif llm_key == "gpt": 
+            stream = openai.chat.completions.create(model=selected_model, messages=messages, stream=True)
+    except Exception as e:
+        raise ValueError(f"Unknown model with error {e}")
+    
+    reply = f"# Model {LLM_MODEL}\n"
+    
+    if typ_llm.lower() == "claude":
+        with stream as stream_clde:
+            for fragment in stream_clde.text_stream:
+                reply += fragment
+                yield reply.replace("```python\n","").replace("```","") 
+
+    else:
+        for chunk in stream:
+            if chunk and chunk.choices:
+                fragment = chunk.choices[0].delta.content or ""
+                reply += fragment
+                yield reply.replace("```python\n","").replace("```","") 
+
+
+
+def stream_manager(user_msg, model):
+    """ Streaming manager for different LLMs based on user message and selected model. """
+    result = stream_llms(user_msg, model)
+    for stream_so_far in result:
+        yield stream_so_far
+

utils.py

@@ -0,0 +1,214 @@
+"""Utility helper functions used across the project.
+
+This module centralizes small helpers such as writing generated code to file,
+converting values to floats with defaults, and saving dataframe objects to CSV.
+"""
+from __future__ import annotations
+
+import os
+import tempfile
+from datetime import datetime, timedelta
+from typing import Any, Optional, Tuple
+
+import gradio as gr
+
+from fmp_python.fmp import FMP
+
+__all__ = [
+    "write_output",
+    "_to_float_or_default",
+    "save_df_to_csv",
+    "resolve_market_to_ticker",
+    "validate_date_range",
+    "validate_ticker_symbol",
+    "save_strategy_to_file",
+    "yf_interval_info",
+    "YF_INTERVALS",
+    "YF_TO_FMP_MAP",
+    "REPLAY_MAP",
+    "REPLAY_INTERVALS",
+    "update_replay_intervals",
+]
+
+def save_strategy_to_file(code_text: str):
+    """Persist generated strategy code into a temp file Gradio can expose."""
+    if not code_text:
+        return None
+    tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".py", prefix="strategy_")
+    tmp_file.write(code_text.encode("utf-8"))
+    tmp_file.flush()
+    tmp_file.close()
+    return tmp_file.name
+
+def write_output(code: str, filename: str = "bt_strategy.py") -> None:
+    """Write a string of code to a file.
+
+    Args:
+        code: The string content to write to disk.
+        filename: The filename to use (defaults to `code.py`).
+    """
+    with open(filename, "w") as f:
+        f.write(code)
+
+
+def _to_float_or_default(value: Any, default: Any) -> float:
+    """Convert a possibly-empty value to float or return a default.
+
+    This mirrors behavior in the application code: if the input is None or an
+    empty string it returns the provided default cast to float.
+    """
+    try:
+        if value is None or value == "":
+            raise ValueError
+        return float(value)
+    except (ValueError, TypeError):
+        return float(default)
+
+
+def resolve_market_to_ticker(market_name: str, market_to_ticker: dict) -> str:
+    """Return a ticker symbol for a market name or ticker string.
+
+    If market_name is a friendly name (in market_to_ticker), returns the mapped
+    ticker symbol; otherwise assumes the input is a ticker symbol and returns
+    the uppercased stripped version.
+    """
+    if market_name in list(market_to_ticker.keys()):
+        return market_to_ticker[market_name]
+    return market_name.upper().strip()
+
+
+def validate_date_range(selected_start: str, selected_end: str, current_date_str: str) -> Tuple[str, str]:
+    """Validate date strings in YYYY-MM-DD format and ensure start <= end <= today.
+
+    Returns a tuple (start, end) as strings. Raises ValueError with a user-facing
+    message on invalid input.
+    """
+    try:
+        start_dt = datetime.strptime(selected_start, "%Y-%m-%d")
+    except ValueError:
+        raise ValueError(f"❌ Error: Start Date must be in format YYYY-MM-DD. Got '{selected_start}'.")
+    try:
+        end_dt = datetime.strptime(selected_end, "%Y-%m-%d")
+    except ValueError:
+        raise ValueError(f"❌Error: End Date must be in format YYYY-MM-DD. Got '{selected_end}'.")
+    today_dt = datetime.strptime(current_date_str, "%Y-%m-%d")
+    if start_dt > end_dt:
+        raise ValueError("❌ Error: Start Date must be earlier than or equal to End Date.")
+    if end_dt > today_dt:
+        raise ValueError(f"❌ Error: End Date cannot be in the future. Today is {current_date_str}.")
+    return selected_start, selected_end
+
+
+def validate_ticker_symbol(tckr_symbl: str, data_source: str = "yahoofinance") -> str:
+    """Validate a ticker symbol using either FMP or yfinance based on the data source.
+    
+    Raises ValueError on invalid tickers or if the provider fails to respond.
+    """
+    source = (data_source or "").lower()
+    if source == "fmp":
+        try:
+            fmp = FMP()
+            result = fmp.get_quote(tckr_symbl)
+            if not result:
+               raise ValueError(f"❌ Error: Ticker {tckr_symbl} not found.")
+            else:
+                # If there's a valid quote, the ticker exists
+                print(f"{tckr_symbl} exists! Data:", result)
+        except Exception as e:
+            raise ValueError(f"❌ Error: Invalid ticker symbol '{tckr_symbl}' for FMP. {e}")
+    try:
+        import yfinance as yf
+
+        ticker_data = yf.Ticker(tckr_symbl)
+        info = ticker_data.info
+        if not info or "symbol" not in info:
+            raise ValueError(f"❌ Error: Invalid ticker symbol '{tckr_symbl}'.")
+        return info.get("longName") or info.get("shortName") or tckr_symbl
+    except ValueError:
+        raise
+    except Exception:
+        raise ValueError(f"❌ Error: Unable to validate ticker symbol '{tckr_symbl}'.")
+
+YF_INTERVALS = ["1m", "5m", "15m", "30m", "1h", "1d"]
+
+# Map YF intervals to FMP intervals (None = not supported)
+YF_TO_FMP_MAP = {
+    "1m": "1min",
+    "5m": "5min",
+    "15m": "15min",
+    "30m": None,
+    "1h": "1hour",
+    "1d": None,
+}
+
+# Replay mapping: key -> (fmp_interval, yf_interval, compression)
+REPLAY_MAP = {
+    "1min -> 5min": ("1min", "1m", 5),
+    "1min -> 15min": ("1min", "1m", 15),
+    "1min -> 30min": ("1min", "1m", 30),
+    "5min -> 15min": ("5min", "5m", 15),
+    "5min -> 30min": ("5min", "5m", 30),
+}
+REPLAY_INTERVALS = list(REPLAY_MAP.keys())
+
+
+def update_replay_intervals(replay_enabled: bool):
+    """Update interval dropdown based on replay checkbox."""
+    if replay_enabled:
+        return gr.update(choices=REPLAY_INTERVALS, value=REPLAY_INTERVALS[0])
+    else:
+        return gr.update(choices=YF_INTERVALS, value="1d")
+
+
+def yf_interval_info(date_range: dict, interval: str, auto_period: bool) -> str:
+    """Describe the effective yfinance download window for intraday intervals."""
+    intraday = ["1m", "2m", "5m", "15m", "30m", "60m", "1h"]
+    if not auto_period or interval not in intraday:
+        return ""
+    end_dt = datetime.strptime(date_range["end"], "%Y-%m-%d")
+    start_dt = datetime.strptime(date_range["start"], "%Y-%m-%d")
+    if interval == "1m":
+        max_days = 7
+    elif interval in ["2m", "5m", "15m", "30m"]:
+        max_days = 60
+    else:  # 60m/1h
+        max_days = 730
+    desired_days = max(1, (end_dt - start_dt).days or 1)
+    used_days = min(desired_days, max_days)
+    effective_start = (end_dt - timedelta(days=used_days - 1)).strftime("%Y-%m-%d")
+    return f"YFinance download window: {effective_start} → {date_range['end']} ({used_days}d) @ {interval}"
+
+
+def save_df_to_csv(df: Optional[Any], filename: str) -> Optional[str]:
+    """Save a pandas DataFrame (or df-like object) to CSV in the system temp dir.
+
+    Returns the full path to the saved file or None when the input could not be
+    converted into a non-empty DataFrame.
+    """
+    if df is None:
+        return None
+
+    try:
+        import pandas as pd
+    except Exception:
+        # pandas is required for this helper; if it's not installed return None to
+        # fail gracefully so callers can handle the absence (e.g. in limited
+        # environments where CSV exports aren't available).
+        return None
+
+    if isinstance(df, pd.DataFrame):
+        df_to_save = df
+    else:
+        try:
+            df_to_save = pd.DataFrame(df)
+        except Exception:
+            return None
+
+    if df_to_save.empty:
+        return None
+
+    out_dir = tempfile.gettempdir()
+    os.makedirs(out_dir, exist_ok=True)
+    filepath = os.path.join(out_dir, f"{filename}.csv")
+    df_to_save.to_csv(filepath, index=False)
+    return filepath

version.txt

@@ -0,0 +1 @@
+0.0.1