Initial commit: Enhanced Algorithmic Trading System with Synthetic Data Generation, Comprehensive Logging, and Extensive Testing

- Added synthetic data generator with realistic market data simulation
- Implemented comprehensive logging system with rotating log files
- Created extensive test suite with unit and integration tests
- Enhanced strategy agent with technical indicators (SMA, RSI, Bollinger Bands, MACD)
- Improved execution agent with realistic order simulation
- Added backtesting and live trading capabilities
- Updated configuration system with synthetic data and logging settings
- Created comprehensive documentation and demo script

.gitignore

@@ -0,0 +1,101 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# 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
+
+# Project specific
+logs/
+data/
+*.log
+*.csv
+*.json
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db 

README.md

@@ -0,0 +1,298 @@
+# Algorithmic Trading System
+
+A comprehensive algorithmic trading system with synthetic data generation, comprehensive logging, and extensive testing capabilities.
+
+## Features
+
+### Core Trading System
+- **Agent-based Architecture**: Modular design with separate strategy and execution agents
+- **Technical Analysis**: Built-in technical indicators (SMA, RSI, Bollinger Bands, MACD)
+- **Risk Management**: Position sizing and drawdown limits
+- **Order Execution**: Simulated broker integration with realistic execution delays
+
+### Synthetic Data Generation
+- **Realistic Market Data**: Generate OHLCV data using geometric Brownian motion
+- **Multiple Frequencies**: Support for 1min, 5min, 1H, and 1D data
+- **Market Scenarios**: Normal, volatile, trending, and crash market conditions
+- **Tick Data**: High-frequency tick data generation for testing
+- **Configurable Parameters**: Volatility, trend, noise levels, and base prices
+
+### Comprehensive Logging
+- **Multi-level Logging**: Console and file-based logging
+- **Rotating Log Files**: Automatic log rotation with size limits
+- **Specialized Loggers**: Separate loggers for trading, performance, and errors
+- **Structured Logging**: Detailed log messages with timestamps and context
+
+### Testing Framework
+- **Unit Tests**: Comprehensive tests for all components
+- **Integration Tests**: End-to-end workflow testing
+- **Test Coverage**: Code coverage reporting with HTML and XML outputs
+- **Mock Testing**: Isolated testing with mocked dependencies
+
+## Installation
+
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd algorithmic_trading
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+## Configuration
+
+The system is configured via `config.yaml`:
+
+```yaml
+# Data source configuration
+data_source:
+  type: 'synthetic'  # or 'csv'
+  path: 'data/market_data.csv'
+
+# Trading parameters
+trading:
+  symbol: 'AAPL'
+  timeframe: '1min'
+  capital: 100000
+
+# Risk management
+risk:
+  max_position: 100
+  max_drawdown: 0.05
+
+# Order execution
+execution:
+  broker_api: 'paper'
+  order_size: 10
+  delay_ms: 100
+  success_rate: 0.95
+
+# Synthetic data generation
+synthetic_data:
+  base_price: 150.0
+  volatility: 0.02
+  trend: 0.001
+  noise_level: 0.005
+  generate_data: true
+  data_path: 'data/synthetic_market_data.csv'
+
+# Logging configuration
+logging:
+  log_level: 'INFO'
+  log_dir: 'logs'
+  enable_console: true
+  enable_file: true
+  max_file_size_mb: 10
+  backup_count: 5
+```
+
+## Usage
+
+### Standard Trading Mode
+```bash
+python -m agentic_ai_system.main
+```
+
+### Backtest Mode
+```bash
+python -m agentic_ai_system.main --mode backtest --start-date 2024-01-01 --end-date 2024-12-31
+```
+
+### Live Trading Mode
+```bash
+python -m agentic_ai_system.main --mode live --duration 60
+```
+
+### Custom Configuration
+```bash
+python -m agentic_ai_system.main --config custom_config.yaml
+```
+
+## Running Tests
+
+### All Tests
+```bash
+pytest
+```
+
+### Unit Tests Only
+```bash
+pytest -m unit
+```
+
+### Integration Tests Only
+```bash
+pytest -m integration
+```
+
+### With Coverage Report
+```bash
+pytest --cov=agentic_ai_system --cov-report=html
+```
+
+### Specific Test File
+```bash
+pytest tests/test_synthetic_data_generator.py
+```
+
+## System Architecture
+
+### Components
+
+1. **SyntheticDataGenerator**: Generates realistic market data for testing
+2. **DataIngestion**: Loads and validates market data from various sources
+3. **StrategyAgent**: Analyzes market data and generates trading signals
+4. **ExecutionAgent**: Executes trading orders with broker simulation
+5. **Orchestrator**: Coordinates the entire trading workflow
+6. **LoggerConfig**: Manages comprehensive logging throughout the system
+
+### Data Flow
+
+```
+Synthetic Data Generator → Data Ingestion → Strategy Agent → Execution Agent
+                              ↓
+                         Logging System
+```
+
+## Synthetic Data Generation
+
+### Features
+- **Geometric Brownian Motion**: Realistic price movement simulation
+- **OHLCV Data**: Complete market data with open, high, low, close, and volume
+- **Market Scenarios**: Different market conditions for testing
+- **Configurable Parameters**: Adjustable volatility, trend, and noise levels
+
+### Usage Examples
+
+```python
+from agentic_ai_system.synthetic_data_generator import SyntheticDataGenerator
+
+# Initialize generator
+generator = SyntheticDataGenerator(config)
+
+# Generate OHLCV data
+data = generator.generate_ohlcv_data(
+    symbol='AAPL',
+    start_date='2024-01-01',
+    end_date='2024-12-31',
+    frequency='1min'
+)
+
+# Generate tick data
+tick_data = generator.generate_tick_data(
+    symbol='AAPL',
+    duration_minutes=60,
+    tick_interval_ms=1000
+)
+
+# Generate market scenarios
+crash_data = generator.generate_market_scenarios('crash')
+volatile_data = generator.generate_market_scenarios('volatile')
+```
+
+## Logging System
+
+### Log Files
+- `logs/trading_system.log`: General system logs
+- `logs/trading.log`: Trading-specific logs
+- `logs/performance.log`: Performance metrics
+- `logs/errors.log`: Error logs
+
+### Log Levels
+- **DEBUG**: Detailed debugging information
+- **INFO**: General information about system operation
+- **WARNING**: Warning messages for potential issues
+- **ERROR**: Error messages for failed operations
+- **CRITICAL**: Critical system failures
+
+### Usage Examples
+
+```python
+import logging
+from agentic_ai_system.logger_config import setup_logging, get_logger
+
+# Setup logging
+setup_logging(config)
+
+# Get logger for specific module
+logger = get_logger(__name__)
+
+# Log messages
+logger.info("Trading signal generated")
+logger.warning("High volatility detected")
+logger.error("Order execution failed", exc_info=True)
+```
+
+## Testing
+
+### Test Structure
+```
+tests/
+├── __init__.py
+├── test_synthetic_data_generator.py
+├── test_strategy_agent.py
+├── test_execution_agent.py
+├── test_data_ingestion.py
+└── test_integration.py
+```
+
+### Test Categories
+- **Unit Tests**: Test individual components in isolation
+- **Integration Tests**: Test complete workflows
+- **Performance Tests**: Test system performance and scalability
+- **Error Handling Tests**: Test error conditions and edge cases
+
+### Running Specific Tests
+
+```bash
+# Run tests with specific markers
+pytest -m unit
+pytest -m integration
+pytest -m slow
+
+# Run tests with coverage
+pytest --cov=agentic_ai_system --cov-report=html
+
+# Run tests in parallel
+pytest -n auto
+
+# Run tests with verbose output
+pytest -v
+```
+
+## Performance Monitoring
+
+The system includes comprehensive performance monitoring:
+
+- **Execution Time Tracking**: Monitor workflow execution times
+- **Trade Statistics**: Track successful vs failed trades
+- **Performance Metrics**: Calculate returns and drawdowns
+- **Resource Usage**: Monitor memory and CPU usage
+
+## Error Handling
+
+The system includes robust error handling:
+
+- **Graceful Degradation**: System continues operation despite component failures
+- **Error Logging**: Comprehensive error logging with stack traces
+- **Fallback Mechanisms**: Automatic fallback to synthetic data when CSV files are missing
+- **Validation**: Data validation at multiple levels
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass
+5. Submit a pull request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Disclaimer
+
+This is a simulation system for educational and testing purposes. It is not intended for real trading and should not be used with real money. Always test thoroughly before using any trading system with real funds. 

agentic_ai_system/agent_base.py

@@ -0,0 +1,23 @@
+import abc
+import logging
+from typing import Dict, Any
+
+class Agent(abc.ABC):
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.logger.info(f"Initialized {self.__class__.__name__}")
+
+    @abc.abstractmethod
+    def act(self, data: Any) -> Dict[str, Any]:
+        """Produce an action given input data"""
+        pass
+    
+    def log_action(self, action: Dict[str, Any]) -> None:
+        """Log the action taken by the agent"""
+        self.logger.info(f"Action taken: {action}")
+    
+    def log_error(self, error: Exception, context: str = "") -> None:
+        """Log errors with context"""
+        self.logger.error(f"Error in {self.__class__.__name__}: {error}", 
+                         exc_info=True, extra={'context': context})

agentic_ai_system/data_ingestion.py

@@ -0,0 +1,149 @@
+import pandas as pd
+import logging
+import os
+from typing import Dict, Any
+from .synthetic_data_generator import SyntheticDataGenerator
+
+logger = logging.getLogger(__name__)
+
+def load_data(config: Dict[str, Any]) -> pd.DataFrame:
+    """
+    Load market data from file or generate synthetic data if needed.
+    
+    Args:
+        config: Configuration dictionary
+        
+    Returns:
+        DataFrame with market data
+    """
+    logger.info("Starting data ingestion process")
+    
+    try:
+        data_source = config['data_source']
+        data_type = data_source['type']
+        
+        if data_type == 'csv':
+            return _load_csv_data(config)
+        elif data_type == 'synthetic':
+            return _generate_synthetic_data(config)
+        else:
+            raise ValueError(f"Unsupported data source type: {data_type}")
+            
+    except Exception as e:
+        logger.error(f"Error in data ingestion: {e}", exc_info=True)
+        raise
+
+def _load_csv_data(config: Dict[str, Any]) -> pd.DataFrame:
+    """Load data from CSV file"""
+    path = config['data_source']['path']
+    
+    if not os.path.exists(path):
+        logger.warning(f"CSV file not found at {path}, generating synthetic data instead")
+        return _generate_synthetic_data(config)
+    
+    logger.info(f"Loading data from CSV: {path}")
+    df = pd.read_csv(path)
+    
+    # Validate data
+    required_columns = ['timestamp', 'open', 'high', 'low', 'close', 'volume']
+    missing_columns = [col for col in required_columns if col not in df.columns]
+    
+    if missing_columns:
+        logger.warning(f"Missing columns in CSV: {missing_columns}")
+        logger.info("Generating synthetic data instead")
+        return _generate_synthetic_data(config)
+    
+    # Convert timestamp to datetime
+    df['timestamp'] = pd.to_datetime(df['timestamp'])
+    
+    logger.info(f"Successfully loaded {len(df)} data points from CSV")
+    return df
+
+def _generate_synthetic_data(config: Dict[str, Any]) -> pd.DataFrame:
+    """Generate synthetic data using the SyntheticDataGenerator"""
+    logger.info("Generating synthetic market data")
+    
+    try:
+        # Create data directory if it doesn't exist
+        data_path = config['synthetic_data']['data_path']
+        os.makedirs(os.path.dirname(data_path), exist_ok=True)
+        
+        # Initialize synthetic data generator
+        generator = SyntheticDataGenerator(config)
+        
+        # Generate OHLCV data
+        df = generator.generate_ohlcv_data(
+            symbol=config['trading']['symbol'],
+            start_date='2024-01-01',
+            end_date='2024-12-31',
+            frequency=config['trading']['timeframe']
+        )
+        
+        # Save to CSV if configured
+        if config['synthetic_data'].get('generate_data', True):
+            generator.save_to_csv(df, data_path)
+            logger.info(f"Saved synthetic data to {data_path}")
+        
+        return df
+        
+    except Exception as e:
+        logger.error(f"Error generating synthetic data: {e}", exc_info=True)
+        raise
+
+def validate_data(df: pd.DataFrame) -> bool:
+    """
+    Validate the loaded data for required fields and data quality.
+    
+    Args:
+        df: DataFrame to validate
+        
+    Returns:
+        True if data is valid, False otherwise
+    """
+    logger.info("Validating data quality")
+    
+    try:
+        # Check for required columns
+        required_columns = ['timestamp', 'open', 'high', 'low', 'close', 'volume']
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        
+        if missing_columns:
+            logger.error(f"Missing required columns: {missing_columns}")
+            return False
+        
+        # Check for null values
+        null_counts = df[required_columns].isnull().sum()
+        if null_counts.sum() > 0:
+            logger.warning(f"Found null values: {null_counts.to_dict()}")
+        
+        # Check for negative prices
+        price_columns = ['open', 'high', 'low', 'close']
+        negative_prices = df[price_columns].lt(0).any().any()
+        if negative_prices:
+            logger.error("Found negative prices in data")
+            return False
+        
+        # Check for negative volumes
+        if (df['volume'] < 0).any():
+            logger.error("Found negative volumes in data")
+            return False
+        
+        # Check OHLC consistency
+        invalid_ohlc = (
+            (df['high'] < df['low']) |
+            (df['open'] > df['high']) |
+            (df['open'] < df['low']) |
+            (df['close'] > df['high']) |
+            (df['close'] < df['low'])
+        )
+        
+        if invalid_ohlc.any():
+            logger.error(f"Found {invalid_ohlc.sum()} rows with invalid OHLC data")
+            return False
+        
+        logger.info("Data validation passed")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error during data validation: {e}", exc_info=True)
+        return False

agentic_ai_system/execution_agent.py

@@ -0,0 +1,206 @@
+import logging
+import time
+from typing import Dict, Any, Optional
+from .agent_base import Agent
+
+class ExecutionAgent(Agent):
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(config)
+        self.broker_api = config['execution']['broker_api']
+        self.order_size = config['execution']['order_size']
+        self.execution_delay = config.get('execution', {}).get('delay_ms', 100)
+        self.success_rate = config.get('execution', {}).get('success_rate', 0.95)
+        self.logger.info(f"Execution agent initialized with {self.broker_api} broker")
+    
+    def act(self, signal: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute trading signal by sending order to broker.
+        
+        Args:
+            signal: Dictionary containing trading signal
+            
+        Returns:
+            Dictionary containing execution result
+        """
+        try:
+            self.logger.info(f"Processing execution signal: {signal['action']} {signal['quantity']} {signal['symbol']}")
+            
+            # Validate signal
+            if not self._validate_signal(signal):
+                self.logger.warning("Invalid signal received, skipping execution")
+                return self._generate_execution_result(signal, success=False, error="Invalid signal")
+            
+            # Simulate order execution
+            execution_result = self._execute_order(signal)
+            
+            # Log execution result
+            self.log_action(execution_result)
+            
+            return execution_result
+            
+        except Exception as e:
+            self.log_error(e, "Error in order execution")
+            return self._generate_execution_result(signal, success=False, error=str(e))
+    
+    def _validate_signal(self, signal: Dict[str, Any]) -> bool:
+        """Validate trading signal"""
+        try:
+            required_fields = ['action', 'symbol', 'quantity']
+            
+            # Check required fields
+            for field in required_fields:
+                if field not in signal:
+                    self.logger.error(f"Missing required field: {field}")
+                    return False
+            
+            # Validate action
+            if signal['action'] not in ['buy', 'sell', 'hold']:
+                self.logger.error(f"Invalid action: {signal['action']}")
+                return False
+            
+            # Validate quantity
+            if signal['quantity'] <= 0 and signal['action'] != 'hold':
+                self.logger.error(f"Invalid quantity: {signal['quantity']}")
+                return False
+            
+            # Validate symbol
+            if not signal['symbol'] or not isinstance(signal['symbol'], str):
+                self.logger.error(f"Invalid symbol: {signal['symbol']}")
+                return False
+            
+            return True
+            
+        except Exception as e:
+            self.log_error(e, "Error validating signal")
+            return False
+    
+    def _execute_order(self, signal: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute order with broker simulation"""
+        try:
+            # Simulate execution delay
+            time.sleep(self.execution_delay / 1000.0)
+            
+            # Simulate execution success/failure
+            import random
+            success = random.random() < self.success_rate
+            
+            if signal['action'] == 'hold':
+                success = True  # Hold actions always succeed
+            
+            if success:
+                return self._simulate_successful_execution(signal)
+            else:
+                return self._simulate_failed_execution(signal)
+                
+        except Exception as e:
+            self.log_error(e, "Error in order execution simulation")
+            return self._generate_execution_result(signal, success=False, error=str(e))
+    
+    def _simulate_successful_execution(self, signal: Dict[str, Any]) -> Dict[str, Any]:
+        """Simulate successful order execution"""
+        try:
+            # Generate execution details
+            execution_price = signal.get('price', 0)
+            if execution_price == 0:
+                # Simulate price slippage
+                import random
+                slippage = random.uniform(-0.001, 0.001)  # ±0.1% slippage
+                execution_price = signal.get('price', 100) * (1 + slippage)
+            
+            execution_time = time.time()
+            
+            # Calculate fees (simplified)
+            commission = self._calculate_commission(signal)
+            
+            result = {
+                'order_id': self._generate_order_id(),
+                'status': 'filled',
+                'action': signal['action'],
+                'symbol': signal['symbol'],
+                'quantity': signal['quantity'],
+                'price': round(execution_price, 4),
+                'execution_time': execution_time,
+                'commission': commission,
+                'total_value': round(signal['quantity'] * execution_price, 2),
+                'success': True,
+                'error': None
+            }
+            
+            self.logger.info(f"Order executed successfully: {result['order_id']} - "
+                           f"{result['action']} {result['quantity']} {result['symbol']} @ {result['price']}")
+            
+            return result
+            
+        except Exception as e:
+            self.log_error(e, "Error in successful execution simulation")
+            return self._generate_execution_result(signal, success=False, error=str(e))
+    
+    def _simulate_failed_execution(self, signal: Dict[str, Any]) -> Dict[str, Any]:
+        """Simulate failed order execution"""
+        error_reasons = [
+            "Insufficient funds",
+            "Market closed",
+            "Invalid order",
+            "Network timeout",
+            "Broker error"
+        ]
+        
+        import random
+        error_reason = random.choice(error_reasons)
+        
+        result = self._generate_execution_result(signal, success=False, error=error_reason)
+        
+        self.logger.warning(f"Order execution failed: {error_reason}")
+        
+        return result
+    
+    def _generate_execution_result(self, signal: Dict[str, Any], success: bool, error: Optional[str] = None) -> Dict[str, Any]:
+        """Generate execution result"""
+        return {
+            'order_id': self._generate_order_id() if success else None,
+            'status': 'filled' if success else 'rejected',
+            'action': signal.get('action', 'unknown'),
+            'symbol': signal.get('symbol', 'unknown'),
+            'quantity': signal.get('quantity', 0),
+            'price': signal.get('price', 0) if success else 0,  # Price is 0 for failed executions
+            'execution_time': time.time(),
+            'commission': 0,
+            'total_value': 0,
+            'success': success,
+            'error': error
+        }
+    
+    def _calculate_commission(self, signal: Dict[str, Any]) -> float:
+        """Calculate commission for the order"""
+        try:
+            # Simple commission calculation
+            base_commission = 1.0  # $1 base commission
+            per_share_commission = 0.01  # $0.01 per share
+            
+            if signal['action'] == 'hold':
+                return 0.0
+            
+            commission = base_commission + (signal['quantity'] * per_share_commission)
+            return round(commission, 2)
+            
+        except Exception as e:
+            self.log_error(e, "Error calculating commission")
+            return 0.0
+    
+    def _generate_order_id(self) -> str:
+        """Generate unique order ID"""
+        import uuid
+        return f"ORD_{uuid.uuid4().hex[:8].upper()}"
+    
+    def get_execution_statistics(self) -> Dict[str, Any]:
+        """Get execution statistics"""
+        # This would typically track real execution statistics
+        # For now, return placeholder data
+        return {
+            'total_orders': 0,
+            'successful_orders': 0,
+            'failed_orders': 0,
+            'success_rate': 0.0,
+            'average_execution_time': 0.0,
+            'total_commission': 0.0
+        }

agentic_ai_system/logger_config.py

@@ -0,0 +1,142 @@
+import logging
+import logging.handlers
+import os
+from datetime import datetime
+from typing import Dict, Optional
+
+def setup_logging(config: Dict, log_level: str = 'INFO') -> None:
+    """
+    Set up comprehensive logging for the trading system.
+    
+    Args:
+        config: Configuration dictionary
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    """
+    # Create logs directory if it doesn't exist
+    log_dir = config.get('logging', {}).get('log_dir', 'logs')
+    os.makedirs(log_dir, exist_ok=True)
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(getattr(logging, log_level.upper()))
+    
+    # Clear any existing handlers
+    root_logger.handlers.clear()
+    
+    # Create formatters
+    detailed_formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s'
+    )
+    
+    simple_formatter = logging.Formatter(
+        '%(asctime)s - %(levelname)s - %(message)s'
+    )
+    
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    console_handler.setFormatter(simple_formatter)
+    root_logger.addHandler(console_handler)
+    
+    # File handler for all logs
+    all_logs_file = os.path.join(log_dir, 'trading_system.log')
+    file_handler = logging.handlers.RotatingFileHandler(
+        all_logs_file,
+        maxBytes=10*1024*1024,  # 10MB
+        backupCount=5
+    )
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(detailed_formatter)
+    root_logger.addHandler(file_handler)
+    
+    # Error log file
+    error_log_file = os.path.join(log_dir, 'errors.log')
+    error_handler = logging.handlers.RotatingFileHandler(
+        error_log_file,
+        maxBytes=5*1024*1024,  # 5MB
+        backupCount=3
+    )
+    error_handler.setLevel(logging.ERROR)
+    error_handler.setFormatter(detailed_formatter)
+    root_logger.addHandler(error_handler)
+    
+    # Trading-specific log file
+    trading_log_file = os.path.join(log_dir, 'trading.log')
+    trading_handler = logging.handlers.RotatingFileHandler(
+        trading_log_file,
+        maxBytes=10*1024*1024,  # 10MB
+        backupCount=5
+    )
+    trading_handler.setLevel(logging.INFO)
+    trading_handler.setFormatter(detailed_formatter)
+    
+    # Create trading logger
+    trading_logger = logging.getLogger('trading')
+    trading_logger.addHandler(trading_handler)
+    trading_logger.setLevel(logging.INFO)
+    trading_logger.propagate = False
+    
+    # Performance log file
+    performance_log_file = os.path.join(log_dir, 'performance.log')
+    performance_handler = logging.handlers.RotatingFileHandler(
+        performance_log_file,
+        maxBytes=5*1024*1024,  # 5MB
+        backupCount=3
+    )
+    performance_handler.setLevel(logging.INFO)
+    performance_handler.setFormatter(detailed_formatter)
+    
+    # Create performance logger
+    performance_logger = logging.getLogger('performance')
+    performance_logger.addHandler(performance_handler)
+    performance_logger.setLevel(logging.INFO)
+    performance_logger.propagate = False
+    
+    logging.info(f"Logging system initialized. Log files in: {log_dir}")
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance for a specific module.
+    
+    Args:
+        name: Logger name (usually __name__)
+        
+    Returns:
+        Logger instance
+    """
+    return logging.getLogger(name)
+
+def log_trade(logger: logging.Logger, trade_data: Dict) -> None:
+    """
+    Log trade execution details.
+    
+    Args:
+        logger: Logger instance
+        trade_data: Dictionary containing trade information
+    """
+    logger.info(f"TRADE EXECUTED: {trade_data}")
+
+def log_performance(logger: logging.Logger, performance_data: Dict) -> None:
+    """
+    Log performance metrics.
+    
+    Args:
+        logger: Logger instance
+        performance_data: Dictionary containing performance metrics
+    """
+    perf_logger = logging.getLogger('performance')
+    perf_logger.info(f"PERFORMANCE: {performance_data}")
+
+def log_error(logger: logging.Logger, error: Exception, context: Optional[str] = None) -> None:
+    """
+    Log errors with context.
+    
+    Args:
+        logger: Logger instance
+        error: Exception that occurred
+        context: Additional context information
+    """
+    error_msg = f"ERROR: {type(error).__name__}: {str(error)}"
+    if context:
+        error_msg += f" | Context: {context}"
+    logger.error(error_msg, exc_info=True) 

agentic_ai_system/main.py

@@ -0,0 +1,106 @@
+import yaml
+import logging
+import sys
+from typing import Dict, Any
+from .orchestrator import run, run_backtest, run_live_trading
+from .logger_config import setup_logging
+
+def main():
+    """Main entry point for the trading system"""
+    try:
+        # Load configuration
+        config = load_config()
+        
+        # Setup logging
+        setup_logging(config)
+        logger = logging.getLogger(__name__)
+        
+        logger.info("Starting algorithmic trading system")
+        
+        # Run the trading workflow
+        result = run(config)
+        
+        if result['success']:
+            logger.info("Trading workflow completed successfully")
+            if result['order_executed']:
+                logger.info(f"Order executed: {result['execution_result']}")
+        else:
+            logger.error(f"Trading workflow failed: {result['errors']}")
+            
+    except Exception as e:
+        print(f"Fatal error: {e}")
+        sys.exit(1)
+
+def load_config(config_path: str = 'config.yaml') -> Dict[str, Any]:
+    """Load configuration from YAML file"""
+    try:
+        with open(config_path, 'r') as f:
+            config = yaml.safe_load(f)
+        return config
+    except FileNotFoundError:
+        print(f"Configuration file not found: {config_path}")
+        sys.exit(1)
+    except yaml.YAMLError as e:
+        print(f"Error parsing configuration file: {e}")
+        sys.exit(1)
+
+def run_backtest_mode(config_path: str = 'config.yaml', 
+                     start_date: str = '2024-01-01', 
+                     end_date: str = '2024-12-31'):
+    """Run the system in backtest mode"""
+    try:
+        config = load_config(config_path)
+        setup_logging(config)
+        logger = logging.getLogger(__name__)
+        
+        logger.info("Running in backtest mode")
+        result = run_backtest(config, start_date, end_date)
+        
+        if result['success']:
+            logger.info(f"Backtest completed: {result['total_return']:.2%} return")
+            logger.info(f"Total trades: {result['total_trades']}")
+        else:
+            logger.error(f"Backtest failed: {result['error']}")
+            
+    except Exception as e:
+        print(f"Backtest error: {e}")
+        sys.exit(1)
+
+def run_live_mode(config_path: str = 'config.yaml', duration_minutes: int = 60):
+    """Run the system in live trading mode"""
+    try:
+        config = load_config(config_path)
+        setup_logging(config)
+        logger = logging.getLogger(__name__)
+        
+        logger.info("Running in live trading mode")
+        result = run_live_trading(config, duration_minutes)
+        
+        if result['success']:
+            logger.info(f"Live trading completed: {result['total_trades']} trades")
+        else:
+            logger.error(f"Live trading failed: {result['error']}")
+            
+    except Exception as e:
+        print(f"Live trading error: {e}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Algorithmic Trading System')
+    parser.add_argument('--mode', choices=['standard', 'backtest', 'live'], 
+                       default='standard', help='Run mode')
+    parser.add_argument('--config', default='config.yaml', help='Configuration file path')
+    parser.add_argument('--start-date', default='2024-01-01', help='Backtest start date')
+    parser.add_argument('--end-date', default='2024-12-31', help='Backtest end date')
+    parser.add_argument('--duration', type=int, default=60, help='Live trading duration (minutes)')
+    
+    args = parser.parse_args()
+    
+    if args.mode == 'backtest':
+        run_backtest_mode(args.config, args.start_date, args.end_date)
+    elif args.mode == 'live':
+        run_live_mode(args.config, args.duration)
+    else:
+        main()

agentic_ai_system/orchestrator.py

@@ -0,0 +1,244 @@
+import logging
+import time
+import pandas as pd
+from typing import Dict, Any, Optional
+from .data_ingestion import load_data, validate_data
+from .strategy_agent import StrategyAgent
+from .execution_agent import ExecutionAgent
+
+logger = logging.getLogger(__name__)
+
+def run(config: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Main orchestration function that coordinates the trading workflow.
+    
+    Args:
+        config: Configuration dictionary
+        
+    Returns:
+        Dictionary containing execution results and statistics
+    """
+    start_time = time.time()
+    logger.info("Starting trading system orchestration")
+    
+    try:
+        # Initialize workflow results
+        workflow_result = {
+            'success': False,
+            'data_loaded': False,
+            'signal_generated': False,
+            'order_executed': False,
+            'execution_result': None,
+            'errors': [],
+            'execution_time': 0
+        }
+        
+        # Step 1: Load market data
+        logger.info("Step 1: Loading market data")
+        data = load_data(config)
+        
+        if data is not None and not data.empty:
+            workflow_result['data_loaded'] = True
+            logger.info(f"Successfully loaded {len(data)} data points")
+            
+            # Validate data quality
+            if validate_data(data):
+                logger.info("Data validation passed")
+            else:
+                logger.warning("Data validation failed, but continuing with workflow")
+        else:
+            logger.error("Failed to load market data")
+            workflow_result['errors'].append("Failed to load market data")
+            return workflow_result
+        
+        # Step 2: Generate trading signal
+        logger.info("Step 2: Generating trading signal")
+        strategy_agent = StrategyAgent(config)
+        signal = strategy_agent.act(data)
+        
+        if signal and signal.get('action') != 'hold':
+            workflow_result['signal_generated'] = True
+            logger.info(f"Generated signal: {signal['action']} {signal['quantity']} {signal['symbol']}")
+        else:
+            logger.info("No actionable signal generated (hold)")
+            workflow_result['signal_generated'] = True  # Hold is still a valid signal
+        
+        # Step 3: Execute order
+        logger.info("Step 3: Executing order")
+        execution_agent = ExecutionAgent(config)
+        execution_result = execution_agent.act(signal)
+        
+        if execution_result['success']:
+            workflow_result['order_executed'] = True
+            workflow_result['execution_result'] = execution_result
+            logger.info("Order executed successfully")
+        else:
+            logger.error(f"Order execution failed: {execution_result.get('error', 'Unknown error')}")
+            workflow_result['errors'].append(f"Order execution failed: {execution_result.get('error')}")
+        
+        # Calculate execution time
+        workflow_result['execution_time'] = time.time() - start_time
+        workflow_result['success'] = workflow_result['data_loaded'] and workflow_result['signal_generated']
+        
+        logger.info(f"Trading workflow completed in {workflow_result['execution_time']:.2f} seconds")
+        
+        return workflow_result
+        
+    except Exception as e:
+        logger.error(f"Error in trading workflow: {e}", exc_info=True)
+        workflow_result = {
+            'success': False,
+            'data_loaded': False,
+            'signal_generated': False,
+            'order_executed': False,
+            'execution_result': None,
+            'errors': [str(e)],
+            'execution_time': time.time() - start_time
+        }
+        return workflow_result
+
+def run_backtest(config: Dict[str, Any], start_date: str = '2024-01-01', end_date: str = '2024-12-31') -> Dict[str, Any]:
+    """
+    Run backtesting simulation over historical data.
+    
+    Args:
+        config: Configuration dictionary
+        start_date: Start date for backtest
+        end_date: End date for backtest
+        
+    Returns:
+        Dictionary containing backtest results
+    """
+    logger.info(f"Starting backtest from {start_date} to {end_date}")
+    
+    try:
+        # Load historical data
+        data = load_data(config)
+        
+        if data is None or data.empty:
+            logger.error("No data available for backtest")
+            return {'success': False, 'error': 'No data available'}
+        
+        # Filter data for backtest period
+        data['timestamp'] = pd.to_datetime(data['timestamp'])
+        mask = (data['timestamp'] >= start_date) & (data['timestamp'] <= end_date)
+        backtest_data = data.loc[mask]
+        
+        if backtest_data.empty:
+            logger.error("No data available for specified backtest period")
+            return {'success': False, 'error': 'No data for backtest period'}
+        
+        logger.info(f"Running backtest on {len(backtest_data)} data points")
+        
+        # Initialize agents
+        strategy_agent = StrategyAgent(config)
+        execution_agent = ExecutionAgent(config)
+        
+        # Track backtest results
+        trades = []
+        portfolio_value = config['trading']['capital']
+        positions = {}
+        
+        # Run simulation
+        for i in range(len(backtest_data)):
+            current_data = backtest_data.iloc[:i+1]
+            
+            if len(current_data) < 50:  # Need minimum data for indicators
+                continue
+            
+            # Generate signal
+            signal = strategy_agent.act(current_data)
+            
+            # Execute if not hold
+            if signal['action'] != 'hold':
+                execution_result = execution_agent.act(signal)
+                trades.append({
+                    'timestamp': current_data.index[-1],
+                    'signal': signal,
+                    'execution': execution_result
+                })
+                
+                # Update portfolio (simplified)
+                if execution_result['success']:
+                    symbol = signal['symbol']
+                    if signal['action'] == 'buy':
+                        positions[symbol] = positions.get(symbol, 0) + signal['quantity']
+                        portfolio_value -= execution_result['total_value']
+                    elif signal['action'] == 'sell':
+                        positions[symbol] = positions.get(symbol, 0) - signal['quantity']
+                        portfolio_value += execution_result['total_value']
+        
+        # Calculate final portfolio value
+        final_value = portfolio_value
+        for symbol, quantity in positions.items():
+            if quantity > 0:
+                final_price = backtest_data['close'].iloc[-1]
+                final_value += quantity * final_price
+        
+        # Calculate performance metrics
+        total_return = (final_value - config['trading']['capital']) / config['trading']['capital']
+        
+        backtest_results = {
+            'success': True,
+            'start_date': start_date,
+            'end_date': end_date,
+            'initial_capital': config['trading']['capital'],
+            'final_value': final_value,
+            'total_return': total_return,
+            'total_trades': len(trades),
+            'trades': trades,
+            'positions': positions
+        }
+        
+        logger.info(f"Backtest completed: {total_return:.2%} return over {len(trades)} trades")
+        return backtest_results
+        
+    except Exception as e:
+        logger.error(f"Error in backtest: {e}", exc_info=True)
+        return {'success': False, 'error': str(e)}
+
+def run_live_trading(config: Dict[str, Any], duration_minutes: int = 60) -> Dict[str, Any]:
+    """
+    Run live trading simulation for a specified duration.
+    
+    Args:
+        config: Configuration dictionary
+        duration_minutes: Duration to run live trading in minutes
+        
+    Returns:
+        Dictionary containing live trading results
+    """
+    logger.info(f"Starting live trading simulation for {duration_minutes} minutes")
+    
+    try:
+        import time
+        from datetime import datetime, timedelta
+        
+        end_time = datetime.now() + timedelta(minutes=duration_minutes)
+        trades = []
+        
+        while datetime.now() < end_time:
+            # Run single trading cycle
+            result = run(config)
+            
+            if result['order_executed'] and result['execution_result']['success']:
+                trades.append(result['execution_result'])
+            
+            # Wait before next cycle
+            time.sleep(60)  # Wait 1 minute between cycles
+        
+        live_results = {
+            'success': True,
+            'duration_minutes': duration_minutes,
+            'total_trades': len(trades),
+            'trades': trades,
+            'start_time': datetime.now() - timedelta(minutes=duration_minutes),
+            'end_time': datetime.now()
+        }
+        
+        logger.info(f"Live trading completed: {len(trades)} trades executed")
+        return live_results
+        
+    except Exception as e:
+        logger.error(f"Error in live trading: {e}", exc_info=True)
+        return {'success': False, 'error': str(e)}

agentic_ai_system/strategy_agent.py

@@ -0,0 +1,244 @@
+import pandas as pd
+import numpy as np
+import logging
+from typing import Dict, Any, Optional
+from .agent_base import Agent
+
+class StrategyAgent(Agent):
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(config)
+        self.symbol = config['trading']['symbol']
+        self.capital = config['trading']['capital']
+        self.max_position = config['risk']['max_position']
+        self.max_drawdown = config['risk']['max_drawdown']
+        self.logger.info(f"Strategy agent initialized for {self.symbol} with capital {self.capital}")
+    
+    def act(self, data: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Analyze market data and generate trading signals.
+        
+        Args:
+            data: DataFrame with OHLCV market data
+            
+        Returns:
+            Dictionary containing trading signal
+        """
+        try:
+            self.logger.info(f"Analyzing {len(data)} data points for {self.symbol}")
+            
+            # Validate data
+            if data.empty:
+                self.logger.warning("Empty data received")
+                return self._generate_no_action_signal()
+            
+            # Calculate technical indicators
+            indicators = self._calculate_indicators(data)
+            
+            # Generate trading signal
+            signal = self._generate_signal(data, indicators)
+            
+            # Log the signal
+            self.log_action(signal)
+            
+            return signal
+            
+        except Exception as e:
+            self.log_error(e, "Error in strategy analysis")
+            return self._generate_no_action_signal()
+    
+    def _calculate_indicators(self, data: pd.DataFrame) -> Dict[str, Any]:
+        """Calculate technical indicators from market data"""
+        try:
+            close_prices = data['close'].values
+            
+            # Simple Moving Averages
+            sma_20 = self._calculate_sma(close_prices, 20)
+            sma_50 = self._calculate_sma(close_prices, 50)
+            
+            # RSI
+            rsi = self._calculate_rsi(close_prices, 14)
+            
+            # Bollinger Bands
+            bb_upper, bb_lower = self._calculate_bollinger_bands(close_prices, 20, 2)
+            
+            # MACD
+            macd, signal_line = self._calculate_macd(close_prices)
+            
+            indicators = {
+                'sma_20': sma_20,
+                'sma_50': sma_50,
+                'rsi': rsi,
+                'bb_upper': bb_upper,
+                'bb_lower': bb_lower,
+                'macd': macd,
+                'macd_signal': signal_line
+            }
+            
+            self.logger.debug(f"Calculated indicators: {list(indicators.keys())}")
+            return indicators
+            
+        except Exception as e:
+            self.log_error(e, "Error calculating indicators")
+            return {}
+    
+    def _generate_signal(self, data: pd.DataFrame, indicators: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate trading signal based on indicators"""
+        try:
+            if not indicators:
+                return self._generate_no_action_signal()
+            
+            current_price = data['close'].iloc[-1]
+            current_volume = data['volume'].iloc[-1]
+            
+            # Get latest indicator values
+            sma_20 = indicators['sma_20'][-1] if len(indicators['sma_20']) > 0 else current_price
+            sma_50 = indicators['sma_50'][-1] if len(indicators['sma_50']) > 0 else current_price
+            rsi = indicators['rsi'][-1] if len(indicators['rsi']) > 0 else 50
+            bb_upper = indicators['bb_upper'][-1] if len(indicators['bb_upper']) > 0 else current_price * 1.02
+            bb_lower = indicators['bb_lower'][-1] if len(indicators['bb_lower']) > 0 else current_price * 0.98
+            
+            # Simple strategy: Buy when price is above SMA20 and RSI < 70
+            # Sell when price is below SMA20 or RSI > 80
+            action = 'hold'
+            quantity = 0
+            confidence = 0.5
+            
+            if current_price > sma_20 and rsi < 70:
+                action = 'buy'
+                quantity = self._calculate_position_size(current_price)
+                confidence = 0.7
+                self.logger.info(f"BUY signal: Price {current_price} > SMA20 {sma_20}, RSI {rsi}")
+                
+            elif current_price < sma_20 or rsi > 80:
+                action = 'sell'
+                quantity = self._calculate_position_size(current_price)
+                confidence = 0.6
+                self.logger.info(f"SELL signal: Price {current_price} < SMA20 {sma_20}, RSI {rsi}")
+            
+            return {
+                'action': action,
+                'symbol': self.symbol,
+                'quantity': quantity,
+                'price': current_price,
+                'confidence': confidence,
+                'timestamp': data.index[-1] if hasattr(data.index[-1], 'timestamp') else None,
+                'indicators': {
+                    'sma_20': sma_20,
+                    'sma_50': sma_50,
+                    'rsi': rsi,
+                    'bb_upper': bb_upper,
+                    'bb_lower': bb_lower
+                }
+            }
+            
+        except Exception as e:
+            self.log_error(e, "Error generating signal")
+            return self._generate_no_action_signal()
+    
+    def _calculate_position_size(self, price: float) -> int:
+        """Calculate position size based on risk management rules"""
+        try:
+            # Simple position sizing: use 10% of capital per trade
+            position_value = self.capital * 0.1
+            quantity = int(position_value / price)
+            
+            # Apply max position limit
+            quantity = min(quantity, self.max_position)
+            
+            # Ensure minimum quantity
+            if quantity < 1:
+                quantity = 1
+                
+            return quantity
+            
+        except Exception as e:
+            self.log_error(e, "Error calculating position size")
+            return 1
+    
+    def _generate_no_action_signal(self) -> Dict[str, Any]:
+        """Generate a no-action signal"""
+        return {
+            'action': 'hold',
+            'symbol': self.symbol,
+            'quantity': 0,
+            'price': 0,
+            'confidence': 0.0,
+            'timestamp': None,
+            'indicators': {}
+        }
+    
+    # Technical indicator calculations
+    def _calculate_sma(self, prices: np.ndarray, window: int) -> np.ndarray:
+        """Calculate Simple Moving Average"""
+        if len(prices) < window:
+            return np.array([])
+        return np.convolve(prices, np.ones(window)/window, mode='valid')
+    
+    def _calculate_rsi(self, prices: np.ndarray, window: int = 14) -> np.ndarray:
+        """Calculate Relative Strength Index"""
+        if len(prices) < window + 1:
+            return np.array([])
+        
+        deltas = np.diff(prices)
+        gains = np.where(deltas > 0, deltas, 0)
+        losses = np.where(deltas < 0, -deltas, 0)
+        
+        avg_gains = np.convolve(gains, np.ones(window)/window, mode='valid')
+        avg_losses = np.convolve(losses, np.ones(window)/window, mode='valid')
+        
+        rs = avg_gains / (avg_losses + 1e-10)  # Avoid division by zero
+        rsi = 100 - (100 / (1 + rs))
+        
+        return rsi
+    
+    def _calculate_bollinger_bands(self, prices: np.ndarray, window: int = 20, std_dev: float = 2) -> tuple:
+        """Calculate Bollinger Bands"""
+        if len(prices) < window:
+            return np.array([]), np.array([])
+        
+        sma = self._calculate_sma(prices, window)
+        if len(sma) == 0:
+            return np.array([]), np.array([])
+        
+        # Calculate rolling standard deviation
+        std = np.array([np.std(prices[i:i+window]) for i in range(len(prices) - window + 1)])
+        
+        upper_band = sma + (std_dev * std)
+        lower_band = sma - (std_dev * std)
+        
+        return upper_band, lower_band
+    
+    def _calculate_macd(self, prices: np.ndarray, fast: int = 12, slow: int = 26, signal: int = 9) -> tuple:
+        """Calculate MACD (Moving Average Convergence Divergence)"""
+        if len(prices) < slow:
+            return np.array([]), np.array([])
+        
+        ema_fast = self._calculate_ema(prices, fast)
+        ema_slow = self._calculate_ema(prices, slow)
+        
+        if len(ema_fast) == 0 or len(ema_slow) == 0:
+            return np.array([]), np.array([])
+        
+        # Align lengths
+        min_len = min(len(ema_fast), len(ema_slow))
+        ema_fast = ema_fast[-min_len:]
+        ema_slow = ema_slow[-min_len:]
+        
+        macd_line = ema_fast - ema_slow
+        signal_line = self._calculate_ema(macd_line, signal)
+        
+        return macd_line, signal_line
+    
+    def _calculate_ema(self, prices: np.ndarray, window: int) -> np.ndarray:
+        """Calculate Exponential Moving Average"""
+        if len(prices) < window:
+            return np.array([])
+        
+        alpha = 2 / (window + 1)
+        ema = np.zeros(len(prices))
+        ema[0] = prices[0]
+        
+        for i in range(1, len(prices)):
+            ema[i] = alpha * prices[i] + (1 - alpha) * ema[i-1]
+        
+        return ema[window-1:]  # Return only the valid EMA values

agentic_ai_system/synthetic_data_generator.py

@@ -0,0 +1,228 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import logging
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+class SyntheticDataGenerator:
+    """
+    Generates synthetic market data for testing and development purposes.
+    Creates realistic price movements with volatility, trends, and market noise.
+    """
+    
+    def __init__(self, config: Dict):
+        self.config = config
+        self.base_price = config.get('synthetic_data', {}).get('base_price', 100.0)
+        self.volatility = config.get('synthetic_data', {}).get('volatility', 0.02)
+        self.trend = config.get('synthetic_data', {}).get('trend', 0.001)
+        self.noise_level = config.get('synthetic_data', {}).get('noise_level', 0.005)
+        
+        logger.info(f"Initialized SyntheticDataGenerator with base_price={self.base_price}, "
+                   f"volatility={self.volatility}, trend={self.trend}")
+    
+    def generate_ohlcv_data(self, 
+                           symbol: str = 'AAPL',
+                           start_date: str = '2024-01-01',
+                           end_date: str = '2024-12-31',
+                           frequency: str = '1min') -> pd.DataFrame:
+        """
+        Generate synthetic OHLCV (Open, High, Low, Close, Volume) data.
+        
+        Args:
+            symbol: Stock symbol
+            start_date: Start date in YYYY-MM-DD format
+            end_date: End date in YYYY-MM-DD format
+            frequency: Data frequency ('1min', '5min', '1H', '1D')
+            
+        Returns:
+            DataFrame with OHLCV data
+        """
+        logger.info(f"Generating synthetic OHLCV data for {symbol} from {start_date} to {end_date}")
+        
+        # Create datetime range
+        start_dt = pd.to_datetime(start_date)
+        end_dt = pd.to_datetime(end_date)
+        
+        # Generate timestamps based on frequency
+        if frequency == '1min' or frequency == '1m':
+            timestamps = pd.date_range(start=start_dt, end=end_dt, freq='1min')
+        elif frequency == '5min' or frequency == '5m':
+            timestamps = pd.date_range(start=start_dt, end=end_dt, freq='5min')
+        elif frequency == '1H' or frequency == '1h':
+            timestamps = pd.date_range(start=start_dt, end=end_dt, freq='1H')
+        elif frequency == '1D' or frequency == '1d':
+            timestamps = pd.date_range(start=start_dt, end=end_dt, freq='1D')
+        else:
+            raise ValueError(f"Unsupported frequency: {frequency}")
+        
+        # Generate price data
+        prices = self._generate_price_series(len(timestamps))
+        
+        # Generate OHLCV data
+        data = []
+        current_price = self.base_price
+        
+        for i, timestamp in enumerate(timestamps):
+            # Add trend and noise
+            trend_component = self.trend * i
+            noise = np.random.normal(0, self.noise_level)
+            
+            # Generate OHLC from current price
+            open_price = current_price * (1 + noise)
+            close_price = open_price * (1 + np.random.normal(0, self.volatility))
+            
+            # Generate high and low
+            price_range = abs(close_price - open_price) * np.random.uniform(1.5, 3.0)
+            high_price = max(open_price, close_price) + price_range * np.random.uniform(0, 0.5)
+            low_price = min(open_price, close_price) - price_range * np.random.uniform(0, 0.5)
+            
+            # Generate volume (correlated with price movement)
+            volume = np.random.randint(1000, 100000) * (1 + abs(close_price - open_price) / open_price)
+            
+            data.append({
+                'timestamp': timestamp,
+                'symbol': symbol,
+                'open': round(open_price, 2),
+                'high': round(high_price, 2),
+                'low': round(low_price, 2),
+                'close': round(close_price, 2),
+                'volume': int(volume)
+            })
+            
+            current_price = close_price
+        
+        df = pd.DataFrame(data)
+        logger.info(f"Generated {len(df)} data points for {symbol}")
+        return df
+    
+    def generate_tick_data(self, 
+                          symbol: str = 'AAPL',
+                          duration_minutes: int = 60,
+                          tick_interval_ms: int = 1000) -> pd.DataFrame:
+        """
+        Generate high-frequency tick data for testing.
+        
+        Args:
+            symbol: Stock symbol
+            duration_minutes: Duration in minutes
+            tick_interval_ms: Interval between ticks in milliseconds
+            
+        Returns:
+            DataFrame with tick data
+        """
+        logger.info(f"Generating tick data for {symbol} for {duration_minutes} minutes")
+        
+        num_ticks = (duration_minutes * 60 * 1000) // tick_interval_ms
+        timestamps = pd.date_range(
+            start=datetime.now(),
+            periods=num_ticks,
+            freq=f'{tick_interval_ms}ms'
+        )
+        
+        # Generate price series with more noise for tick data
+        base_prices = self._generate_price_series(num_ticks, volatility=self.volatility * 2)
+        
+        data = []
+        for i, (timestamp, base_price) in enumerate(zip(timestamps, base_prices)):
+            # Add micro-movements
+            tick_price = base_price * (1 + np.random.normal(0, self.noise_level * 0.5))
+            
+            data.append({
+                'timestamp': timestamp,
+                'symbol': symbol,
+                'price': round(tick_price, 4),
+                'volume': np.random.randint(1, 100)
+            })
+        
+        df = pd.DataFrame(data)
+        logger.info(f"Generated {len(df)} tick data points for {symbol}")
+        return df
+    
+    def _generate_price_series(self, length: int, volatility: Optional[float] = None) -> np.ndarray:
+        """
+        Generate a realistic price series using geometric Brownian motion.
+        
+        Args:
+            length: Number of price points
+            volatility: Price volatility (if None, uses self.volatility)
+            
+        Returns:
+            Array of prices
+        """
+        if volatility is None:
+            volatility = self.volatility
+        
+        # Geometric Brownian motion parameters
+        mu = self.trend  # drift
+        sigma = volatility  # volatility
+        
+        # Generate random walks
+        dt = 1.0 / length
+        t = np.linspace(0, 1, length)
+        
+        # Brownian motion
+        dW = np.random.normal(0, np.sqrt(dt), length)
+        W = np.cumsum(dW)
+        
+        # Geometric Brownian motion
+        S = self.base_price * np.exp((mu - 0.5 * sigma**2) * t + sigma * W)
+        
+        return S
+    
+    def save_to_csv(self, df: pd.DataFrame, filepath: str) -> None:
+        """
+        Save generated data to CSV file.
+        
+        Args:
+            df: DataFrame to save
+            filepath: Path to save the CSV file
+        """
+        df.to_csv(filepath, index=False)
+        logger.info(f"Saved synthetic data to {filepath}")
+    
+    def generate_market_scenarios(self, scenario_type: str = 'normal') -> pd.DataFrame:
+        """
+        Generate data for different market scenarios.
+        
+        Args:
+            scenario_type: Type of scenario ('normal', 'volatile', 'trending', 'crash')
+            
+        Returns:
+            DataFrame with scenario-specific data
+        """
+        logger.info(f"Generating {scenario_type} market scenario")
+        
+        if scenario_type == 'normal':
+            return self.generate_ohlcv_data()
+        elif scenario_type == 'volatile':
+            # High volatility scenario
+            self.volatility *= 3
+            data = self.generate_ohlcv_data()
+            self.volatility /= 3  # Reset
+            return data
+        elif scenario_type == 'trending':
+            # Strong upward trend
+            self.trend *= 5
+            data = self.generate_ohlcv_data()
+            self.trend /= 5  # Reset
+            return data
+        elif scenario_type == 'crash':
+            # Market crash scenario
+            original_volatility = self.volatility
+            original_trend = self.trend
+            
+            self.volatility *= 5
+            self.trend = -0.01  # Strong downward trend
+            
+            try:
+                data = self.generate_ohlcv_data()
+            finally:
+                # Reset parameters
+                self.volatility = original_volatility
+                self.trend = original_trend
+            
+            return data
+        else:
+            raise ValueError(f"Unknown scenario type: {scenario_type}") 

config.yaml

@@ -0,0 +1,35 @@
+# Configuration file for the agentic AI trading system
+data_source:
+  type: 'csv'
+  path: 'data/market_data.csv'
+
+trading:
+  symbol: 'AAPL'
+  timeframe: '1m'
+  capital: 100000
+
+risk:
+  max_position: 100
+  max_drawdown: 0.05
+
+execution:
+  broker_api: 'paper'
+  order_size: 10
+
+# Synthetic data generation settings
+synthetic_data:
+  base_price: 150.0
+  volatility: 0.02
+  trend: 0.001
+  noise_level: 0.005
+  generate_data: true
+  data_path: 'data/synthetic_market_data.csv'
+
+# Logging configuration
+logging:
+  log_level: 'INFO'
+  log_dir: 'logs'
+  enable_console: true
+  enable_file: true
+  max_file_size_mb: 10
+  backup_count: 5

demo.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Demonstration script for the Algorithmic Trading System
+
+This script demonstrates the key features of the system:
+- Synthetic data generation
+- Trading workflow execution
+- Backtesting
+- Logging
+"""
+
+import yaml
+import pandas as pd
+from agentic_ai_system.synthetic_data_generator import SyntheticDataGenerator
+from agentic_ai_system.logger_config import setup_logging
+from agentic_ai_system.orchestrator import run, run_backtest
+from agentic_ai_system.main import load_config
+
+def main():
+    """Main demonstration function"""
+    print("🚀 Algorithmic Trading System Demo")
+    print("=" * 50)
+    
+    # Load configuration
+    try:
+        config = load_config()
+        print("✅ Configuration loaded successfully")
+    except Exception as e:
+        print(f"❌ Error loading configuration: {e}")
+        return
+    
+    # Setup logging
+    setup_logging(config)
+    print("✅ Logging system initialized")
+    
+    # Demo 1: Synthetic Data Generation
+    print("\n📊 Demo 1: Synthetic Data Generation")
+    print("-" * 30)
+    
+    try:
+        generator = SyntheticDataGenerator(config)
+        
+        # Generate OHLCV data
+        print("Generating OHLCV data...")
+        ohlcv_data = generator.generate_ohlcv_data(
+            symbol='AAPL',
+            start_date='2024-01-01',
+            end_date='2024-01-02',
+            frequency='1H'
+        )
+        print(f"✅ Generated {len(ohlcv_data)} OHLCV data points")
+        
+        # Show sample data
+        print("\nSample OHLCV data:")
+        print(ohlcv_data.head())
+        
+        # Generate different market scenarios
+        print("\nGenerating market scenarios...")
+        scenarios = ['normal', 'volatile', 'trending', 'crash']
+        
+        for scenario in scenarios:
+            scenario_data = generator.generate_market_scenarios(scenario)
+            avg_price = scenario_data['close'].mean()
+            print(f"  {scenario.capitalize()} market: {len(scenario_data)} points, avg price: ${avg_price:.2f}")
+        
+    except Exception as e:
+        print(f"❌ Error in synthetic data generation: {e}")
+    
+    # Demo 2: Trading Workflow
+    print("\n🤖 Demo 2: Trading Workflow")
+    print("-" * 30)
+    
+    try:
+        print("Running trading workflow...")
+        result = run(config)
+        
+        if result['success']:
+            print("✅ Trading workflow completed successfully")
+            print(f"  Data loaded: {result['data_loaded']}")
+            print(f"  Signal generated: {result['signal_generated']}")
+            print(f"  Order executed: {result['order_executed']}")
+            print(f"  Execution time: {result['execution_time']:.2f} seconds")
+            
+            if result['order_executed'] and result['execution_result']:
+                exec_result = result['execution_result']
+                print(f"  Order details: {exec_result['action']} {exec_result['quantity']} {exec_result['symbol']} @ ${exec_result['price']:.2f}")
+        else:
+            print("❌ Trading workflow failed")
+            print(f"  Errors: {result['errors']}")
+            
+    except Exception as e:
+        print(f"❌ Error in trading workflow: {e}")
+    
+    # Demo 3: Backtesting
+    print("\n📈 Demo 3: Backtesting")
+    print("-" * 30)
+    
+    try:
+        print("Running backtest...")
+        backtest_result = run_backtest(config, '2024-01-01', '2024-01-07')
+        
+        if backtest_result['success']:
+            print("✅ Backtest completed successfully")
+            print(f"  Initial capital: ${backtest_result['initial_capital']:,.2f}")
+            print(f"  Final value: ${backtest_result['final_value']:,.2f}")
+            print(f"  Total return: {backtest_result['total_return']:.2%}")
+            print(f"  Total trades: {backtest_result['total_trades']}")
+            print(f"  Positions: {backtest_result['positions']}")
+        else:
+            print("❌ Backtest failed")
+            print(f"  Error: {backtest_result['error']}")
+            
+    except Exception as e:
+        print(f"❌ Error in backtesting: {e}")
+    
+    # Demo 4: System Statistics
+    print("\n📊 Demo 4: System Statistics")
+    print("-" * 30)
+    
+    try:
+        # Show configuration summary
+        print("Configuration Summary:")
+        print(f"  Trading symbol: {config['trading']['symbol']}")
+        print(f"  Timeframe: {config['trading']['timeframe']}")
+        print(f"  Capital: ${config['trading']['capital']:,.2f}")
+        print(f"  Max position: {config['risk']['max_position']}")
+        print(f"  Max drawdown: {config['risk']['max_drawdown']:.1%}")
+        print(f"  Broker API: {config['execution']['broker_api']}")
+        
+        # Show synthetic data parameters
+        print("\nSynthetic Data Parameters:")
+        print(f"  Base price: ${config['synthetic_data']['base_price']:.2f}")
+        print(f"  Volatility: {config['synthetic_data']['volatility']:.3f}")
+        print(f"  Trend: {config['synthetic_data']['trend']:.3f}")
+        print(f"  Noise level: {config['synthetic_data']['noise_level']:.3f}")
+        
+    except Exception as e:
+        print(f"❌ Error showing statistics: {e}")
+    
+    print("\n🎉 Demo completed!")
+    print("\n📝 Check the logs directory for detailed logs:")
+    print("  - logs/trading_system.log")
+    print("  - logs/trading.log")
+    print("  - logs/performance.log")
+    print("  - logs/errors.log")
+
+if __name__ == '__main__':
+    main() 

pytest.ini

@@ -0,0 +1,19 @@
+[tool:pytest]
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+addopts = 
+    -v
+    --tb=short
+    --strict-markers
+    --disable-warnings
+    --cov=agentic_ai_system
+    --cov-report=term-missing
+    --cov-report=html:htmlcov
+    --cov-report=xml
+markers =
+    unit: Unit tests
+    integration: Integration tests
+    slow: Slow running tests
+    synthetic: Tests involving synthetic data generation 

requirements.txt

@@ -0,0 +1,9 @@
+pyyaml
+pandas
+numpy
+matplotlib
+seaborn
+pytest
+pytest-cov
+python-dateutil
+scipy

tests/__init__.py

@@ -0,0 +1 @@
+# Tests package for algorithmic trading system 

tests/test_data_ingestion.py

@@ -0,0 +1,311 @@
+import pytest
+import pandas as pd
+import numpy as np
+import tempfile
+import os
+from unittest.mock import patch, MagicMock
+from agentic_ai_system.data_ingestion import load_data, validate_data, _load_csv_data, _generate_synthetic_data
+
+class TestDataIngestion:
+    """Test cases for data ingestion module"""
+    
+    @pytest.fixture
+    def config(self):
+        """Sample configuration for testing"""
+        return {
+            'data_source': {
+                'type': 'csv',
+                'path': 'data/market_data.csv'
+            },
+            'synthetic_data': {
+                'base_price': 150.0,
+                'volatility': 0.02,
+                'trend': 0.001,
+                'noise_level': 0.005,
+                'data_path': 'data/synthetic_market_data.csv'
+            },
+            'trading': {
+                'symbol': 'AAPL',
+                'timeframe': '1min'
+            }
+        }
+    
+    @pytest.fixture
+    def sample_csv_data(self):
+        """Create sample CSV data for testing"""
+        dates = pd.date_range(start='2024-01-01', periods=100, freq='1min')
+        
+        data = []
+        for i, date in enumerate(dates):
+            base_price = 150.0 + (i * 0.1)
+            data.append({
+                'timestamp': date,
+                'open': base_price + np.random.normal(0, 1),
+                'high': base_price + abs(np.random.normal(0, 2)),
+                'low': base_price - abs(np.random.normal(0, 2)),
+                'close': base_price + np.random.normal(0, 1),
+                'volume': np.random.randint(1000, 100000)
+            })
+        
+        return pd.DataFrame(data)
+    
+    def test_load_data_csv_type(self, config, sample_csv_data):
+        """Test loading data with CSV type"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp_file:
+            sample_csv_data.to_csv(tmp_file.name, index=False)
+            config['data_source']['path'] = tmp_file.name
+            
+            try:
+                result = load_data(config)
+                
+                assert isinstance(result, pd.DataFrame)
+                assert len(result) == len(sample_csv_data)
+                assert list(result.columns) == list(sample_csv_data.columns)
+                
+            finally:
+                os.unlink(tmp_file.name)
+    
+    def test_load_data_synthetic_type(self, config):
+        """Test loading data with synthetic type"""
+        config['data_source']['type'] = 'synthetic'
+        
+        with patch('agentic_ai_system.data_ingestion._generate_synthetic_data') as mock_generate:
+            mock_df = pd.DataFrame({
+                'timestamp': pd.date_range('2024-01-01', periods=10, freq='1min'),
+                'open': [150] * 10,
+                'high': [155] * 10,
+                'low': [145] * 10,
+                'close': [152] * 10,
+                'volume': [1000] * 10
+            })
+            mock_generate.return_value = mock_df
+            
+            result = load_data(config)
+            
+            assert isinstance(result, pd.DataFrame)
+            mock_generate.assert_called_once_with(config)
+    
+    def test_load_data_invalid_type(self, config):
+        """Test loading data with invalid type"""
+        config['data_source']['type'] = 'invalid_type'
+        
+        with pytest.raises(ValueError, match="Unsupported data source type"):
+            load_data(config)
+    
+    def test_load_csv_data_file_exists(self, config, sample_csv_data):
+        """Test loading CSV data when file exists"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp_file:
+            sample_csv_data.to_csv(tmp_file.name, index=False)
+            config['data_source']['path'] = tmp_file.name
+            
+            try:
+                result = _load_csv_data(config)
+                
+                assert isinstance(result, pd.DataFrame)
+                assert len(result) == len(sample_csv_data)
+                assert result['timestamp'].dtype == 'datetime64[ns]'
+                
+            finally:
+                os.unlink(tmp_file.name)
+    
+    def test_load_csv_data_file_not_exists(self, config):
+        """Test loading CSV data when file doesn't exist"""
+        config['data_source']['path'] = 'nonexistent_file.csv'
+        
+        with patch('agentic_ai_system.data_ingestion._generate_synthetic_data') as mock_generate:
+            mock_df = pd.DataFrame({'test': [1, 2, 3]})
+            mock_generate.return_value = mock_df
+            
+            result = _load_csv_data(config)
+            
+            assert result is mock_df
+            mock_generate.assert_called_once_with(config)
+    
+    def test_load_csv_data_missing_columns(self, config):
+        """Test loading CSV data with missing columns"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp_file:
+            # Create CSV with missing columns
+            incomplete_data = pd.DataFrame({
+                'timestamp': pd.date_range('2024-01-01', periods=10, freq='1min'),
+                'open': [150] * 10,
+                'close': [152] * 10
+                # Missing high, low, volume
+            })
+            incomplete_data.to_csv(tmp_file.name, index=False)
+            config['data_source']['path'] = tmp_file.name
+            
+            try:
+                with patch('agentic_ai_system.data_ingestion._generate_synthetic_data') as mock_generate:
+                    mock_df = pd.DataFrame({'test': [1, 2, 3]})
+                    mock_generate.return_value = mock_df
+                    
+                    result = _load_csv_data(config)
+                    
+                    assert result is mock_df
+                    mock_generate.assert_called_once_with(config)
+                    
+            finally:
+                os.unlink(tmp_file.name)
+    
+    def test_generate_synthetic_data(self, config):
+        """Test synthetic data generation"""
+        with patch('agentic_ai_system.synthetic_data_generator.SyntheticDataGenerator') as mock_generator_class:
+            mock_generator = MagicMock()
+            mock_generator_class.return_value = mock_generator
+            
+            mock_df = pd.DataFrame({
+                'timestamp': pd.date_range('2024-01-01', periods=10, freq='1min'),
+                'open': [150] * 10,
+                'high': [155] * 10,
+                'low': [145] * 10,
+                'close': [152] * 10,
+                'volume': [1000] * 10
+            })
+            mock_generator.generate_ohlcv_data.return_value = mock_df
+            
+            result = _generate_synthetic_data(config)
+            
+            assert isinstance(result, pd.DataFrame)
+            mock_generator.generate_ohlcv_data.assert_called_once()
+            mock_generator.save_to_csv.assert_called_once()
+    
+    def test_validate_data_valid(self, sample_csv_data):
+        """Test data validation with valid data"""
+        assert validate_data(sample_csv_data) == True
+    
+    def test_validate_data_missing_columns(self):
+        """Test data validation with missing columns"""
+        invalid_data = pd.DataFrame({
+            'timestamp': pd.date_range('2024-01-01', periods=10, freq='1min'),
+            'open': [150] * 10
+            # Missing required columns
+        })
+        
+        assert validate_data(invalid_data) == False
+    
+    def test_validate_data_negative_prices(self):
+        """Test data validation with negative prices"""
+        invalid_data = pd.DataFrame({
+            'timestamp': pd.date_range('2024-01-01', periods=10, freq='1min'),
+            'open': [150] * 10,
+            'high': [155] * 10,
+            'low': [-145] * 10,  # Negative low price
+            'close': [152] * 10,
+            'volume': [1000] * 10
+        })
+        
+        assert validate_data(invalid_data) == False
+    
+    def test_validate_data_negative_volumes(self):
+        """Test data validation with negative volumes"""
+        invalid_data = pd.DataFrame({
+            'timestamp': pd.date_range('2024-01-01', periods=10, freq='1min'),
+            'open': [150] * 10,
+            'high': [155] * 10,
+            'low': [145] * 10,
+            'close': [152] * 10,
+            'volume': [-1000] * 10  # Negative volume
+        })
+        
+        assert validate_data(invalid_data) == False
+    
+    def test_validate_data_invalid_ohlc(self):
+        """Test data validation with invalid OHLC relationships"""
+        invalid_data = pd.DataFrame({
+            'timestamp': pd.date_range('2024-01-01', periods=10, freq='1min'),
+            'open': [150] * 10,
+            'high': [145] * 10,  # High < Open
+            'low': [145] * 10,
+            'close': [152] * 10,
+            'volume': [1000] * 10
+        })
+        
+        assert validate_data(invalid_data) == False
+    
+    def test_validate_data_null_values(self):
+        """Test data validation with null values"""
+        invalid_data = pd.DataFrame({
+            'timestamp': pd.date_range('2024-01-01', periods=10, freq='1min'),
+            'open': [150] * 10,
+            'high': [155] * 10,
+            'low': [145] * 10,
+            'close': [152] * 10,
+            'volume': [1000] * 10
+        })
+        
+        # Add null values
+        invalid_data.loc[0, 'open'] = None
+        
+        assert validate_data(invalid_data) == False
+    
+    def test_validate_data_empty_dataframe(self):
+        """Test data validation with empty DataFrame"""
+        empty_data = pd.DataFrame()
+        assert validate_data(empty_data) == False
+    
+    def test_load_data_error_handling(self, config):
+        """Test error handling in load_data"""
+        config['data_source']['type'] = 'csv'
+        config['data_source']['path'] = 'nonexistent_file.csv'
+        
+        with patch('agentic_ai_system.data_ingestion._generate_synthetic_data', side_effect=Exception("Test error")):
+            with pytest.raises(Exception, match="Test error"):
+                load_data(config)
+    
+    def test_csv_data_timestamp_conversion(self, config, sample_csv_data):
+        """Test timestamp conversion in CSV loading"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp_file:
+            # Convert timestamp to string for CSV
+            sample_csv_data['timestamp'] = sample_csv_data['timestamp'].astype(str)
+            sample_csv_data.to_csv(tmp_file.name, index=False)
+            config['data_source']['path'] = tmp_file.name
+            
+            try:
+                result = _load_csv_data(config)
+                
+                # Check that timestamp is converted to datetime
+                assert result['timestamp'].dtype == 'datetime64[ns]'
+                
+            finally:
+                os.unlink(tmp_file.name)
+    
+    def test_synthetic_data_directory_creation(self, config):
+        """Test that synthetic data directory is created if it doesn't exist"""
+        with patch('os.makedirs') as mock_makedirs:
+            with patch('agentic_ai_system.synthetic_data_generator.SyntheticDataGenerator') as mock_generator_class:
+                mock_generator = MagicMock()
+                mock_generator_class.return_value = mock_generator
+                
+                mock_df = pd.DataFrame({'test': [1, 2, 3]})
+                mock_generator.generate_ohlcv_data.return_value = mock_df
+                
+                _generate_synthetic_data(config)
+                
+                # Check that makedirs was called
+                mock_makedirs.assert_called_once()
+    
+    def test_data_validation_edge_cases(self):
+        """Test data validation with edge cases"""
+        # Test with single row
+        single_row_data = pd.DataFrame({
+            'timestamp': [pd.Timestamp('2024-01-01')],
+            'open': [150],
+            'high': [155],
+            'low': [145],
+            'close': [152],
+            'volume': [1000]
+        })
+        
+        assert validate_data(single_row_data) == True
+        
+        # Test with very large numbers
+        large_data = pd.DataFrame({
+            'timestamp': pd.date_range('2024-01-01', periods=5, freq='1min'),
+            'open': [1e6] * 5,
+            'high': [1e6 + 100] * 5,
+            'low': [1e6 - 100] * 5,
+            'close': [1e6 + 50] * 5,
+            'volume': [1e9] * 5
+        })
+        
+        assert validate_data(large_data) == True 

tests/test_execution_agent.py

@@ -0,0 +1,300 @@
+import pytest
+import time
+from unittest.mock import patch, MagicMock
+from agentic_ai_system.execution_agent import ExecutionAgent
+
+class TestExecutionAgent:
+    """Test cases for ExecutionAgent"""
+    
+    @pytest.fixture
+    def config(self):
+        """Sample configuration for testing"""
+        return {
+            'execution': {
+                'broker_api': 'paper',
+                'order_size': 10,
+                'delay_ms': 50,
+                'success_rate': 0.95
+            },
+            'trading': {
+                'symbol': 'AAPL',
+                'timeframe': '1min',
+                'capital': 100000
+            },
+            'risk': {
+                'max_position': 100,
+                'max_drawdown': 0.05
+            }
+        }
+    
+    @pytest.fixture
+    def execution_agent(self, config):
+        """Create an ExecutionAgent instance"""
+        return ExecutionAgent(config)
+    
+    @pytest.fixture
+    def valid_signal(self):
+        """Create a valid trading signal"""
+        return {
+            'action': 'buy',
+            'symbol': 'AAPL',
+            'quantity': 10,
+            'price': 150.0,
+            'confidence': 0.8
+        }
+    
+    def test_initialization(self, execution_agent, config):
+        """Test agent initialization"""
+        assert execution_agent.broker_api == config['execution']['broker_api']
+        assert execution_agent.order_size == config['execution']['order_size']
+        assert execution_agent.execution_delay == config['execution']['delay_ms']
+        assert execution_agent.success_rate == config['execution']['success_rate']
+    
+    def test_act_with_valid_signal(self, execution_agent, valid_signal):
+        """Test order execution with valid signal"""
+        result = execution_agent.act(valid_signal)
+        
+        # Check result structure
+        assert isinstance(result, dict)
+        assert 'order_id' in result
+        assert 'status' in result
+        assert 'action' in result
+        assert 'symbol' in result
+        assert 'quantity' in result
+        assert 'price' in result
+        assert 'execution_time' in result
+        assert 'commission' in result
+        assert 'total_value' in result
+        assert 'success' in result
+        assert 'error' in result
+        
+        # Check values
+        assert result['action'] == valid_signal['action']
+        assert result['symbol'] == valid_signal['symbol']
+        assert result['quantity'] == valid_signal['quantity']
+        assert result['price'] > 0
+        assert result['execution_time'] > 0
+        assert result['commission'] >= 0
+        assert result['total_value'] >= 0
+    
+    def test_act_with_hold_signal(self, execution_agent):
+        """Test order execution with hold signal"""
+        hold_signal = {
+            'action': 'hold',
+            'symbol': 'AAPL',
+            'quantity': 0,
+            'price': 0,
+            'confidence': 0.0
+        }
+        
+        result = execution_agent.act(hold_signal)
+        
+        assert result['action'] == 'hold'
+        assert result['quantity'] == 0
+        assert result['success'] == True  # Hold should always succeed
+    
+    def test_validate_signal_valid(self, execution_agent, valid_signal):
+        """Test signal validation with valid signal"""
+        assert execution_agent._validate_signal(valid_signal) == True
+    
+    def test_validate_signal_missing_fields(self, execution_agent):
+        """Test signal validation with missing fields"""
+        invalid_signal = {'action': 'buy'}  # Missing symbol and quantity
+        
+        assert execution_agent._validate_signal(invalid_signal) == False
+    
+    def test_validate_signal_invalid_action(self, execution_agent):
+        """Test signal validation with invalid action"""
+        invalid_signal = {
+            'action': 'invalid_action',
+            'symbol': 'AAPL',
+            'quantity': 10
+        }
+        
+        assert execution_agent._validate_signal(invalid_signal) == False
+    
+    def test_validate_signal_invalid_quantity(self, execution_agent):
+        """Test signal validation with invalid quantity"""
+        invalid_signal = {
+            'action': 'buy',
+            'symbol': 'AAPL',
+            'quantity': -5  # Negative quantity
+        }
+        
+        assert execution_agent._validate_signal(invalid_signal) == False
+    
+    def test_validate_signal_invalid_symbol(self, execution_agent):
+        """Test signal validation with invalid symbol"""
+        invalid_signal = {
+            'action': 'buy',
+            'symbol': '',  # Empty symbol
+            'quantity': 10
+        }
+        
+        assert execution_agent._validate_signal(invalid_signal) == False
+    
+    def test_calculate_commission(self, execution_agent):
+        """Test commission calculation"""
+        # Test buy order
+        buy_signal = {'action': 'buy', 'quantity': 10}
+        commission_buy = execution_agent._calculate_commission(buy_signal)
+        
+        # Base commission ($1) + per share commission ($0.01 * 10) = $1.10
+        expected_commission = 1.0 + (10 * 0.01)
+        assert commission_buy == expected_commission
+        
+        # Test sell order
+        sell_signal = {'action': 'sell', 'quantity': 5}
+        commission_sell = execution_agent._calculate_commission(sell_signal)
+        
+        expected_commission = 1.0 + (5 * 0.01)
+        assert commission_sell == expected_commission
+        
+        # Test hold order (no commission)
+        hold_signal = {'action': 'hold', 'quantity': 0}
+        commission_hold = execution_agent._calculate_commission(hold_signal)
+        
+        assert commission_hold == 0.0
+    
+    def test_generate_order_id(self, execution_agent):
+        """Test order ID generation"""
+        order_id = execution_agent._generate_order_id()
+        
+        assert isinstance(order_id, str)
+        assert order_id.startswith('ORD_')
+        assert len(order_id) == 12  # 'ORD_' + 8 hex characters
+    
+    def test_simulate_successful_execution(self, execution_agent, valid_signal):
+        """Test successful execution simulation"""
+        result = execution_agent._simulate_successful_execution(valid_signal)
+        
+        assert result['status'] == 'filled'
+        assert result['success'] == True
+        assert result['error'] is None
+        assert result['order_id'] is not None
+        assert result['price'] > 0
+        assert result['total_value'] > 0
+    
+    def test_simulate_failed_execution(self, execution_agent, valid_signal):
+        """Test failed execution simulation"""
+        result = execution_agent._simulate_failed_execution(valid_signal)
+        
+        assert result['status'] == 'rejected'
+        assert result['success'] == False
+        assert result['error'] is not None
+        assert result['order_id'] is None
+        assert result['price'] == 0
+        assert result['total_value'] == 0
+    
+    def test_generate_execution_result(self, execution_agent, valid_signal):
+        """Test execution result generation"""
+        # Test successful result
+        success_result = execution_agent._generate_execution_result(valid_signal, True)
+        
+        assert success_result['status'] == 'filled'
+        assert success_result['success'] == True
+        assert success_result['order_id'] is not None
+        
+        # Test failed result
+        failed_result = execution_agent._generate_execution_result(valid_signal, False, "Test error")
+        
+        assert failed_result['status'] == 'rejected'
+        assert failed_result['success'] == False
+        assert failed_result['error'] == "Test error"
+        assert failed_result['order_id'] is None
+    
+    def test_execution_delay(self, execution_agent, valid_signal):
+        """Test that execution delay is applied"""
+        start_time = time.time()
+        
+        with patch('time.sleep') as mock_sleep:
+            execution_agent._execute_order(valid_signal)
+            mock_sleep.assert_called_once()
+            
+            # Check that sleep was called with the correct delay
+            call_args = mock_sleep.call_args[0][0]
+            expected_delay = execution_agent.execution_delay / 1000.0
+            assert abs(call_args - expected_delay) < 0.001
+    
+    def test_success_rate_simulation(self, execution_agent, valid_signal):
+        """Test success rate simulation"""
+        # Set success rate to 0.0 (should always fail)
+        execution_agent.success_rate = 0.0
+        
+        with patch('random.random', return_value=0.5):  # Always above 0.0
+            result = execution_agent._execute_order(valid_signal)
+            assert result['success'] == False
+        
+        # Set success rate to 1.0 (should always succeed)
+        execution_agent.success_rate = 1.0
+        
+        with patch('random.random', return_value=0.5):  # Always below 1.0
+            result = execution_agent._execute_order(valid_signal)
+            assert result['success'] == True
+    
+    def test_error_handling_in_execution(self, execution_agent, valid_signal):
+        """Test error handling during execution"""
+        # Mock _simulate_successful_execution to raise an exception
+        with patch.object(execution_agent, '_simulate_successful_execution', side_effect=Exception("Test error")):
+            result = execution_agent._execute_order(valid_signal)
+            
+            assert result['success'] == False
+            assert "Test error" in result['error']
+    
+    def test_get_execution_statistics(self, execution_agent):
+        """Test execution statistics retrieval"""
+        stats = execution_agent.get_execution_statistics()
+        
+        expected_keys = [
+            'total_orders', 'successful_orders', 'failed_orders',
+            'success_rate', 'average_execution_time', 'total_commission'
+        ]
+        
+        for key in expected_keys:
+            assert key in stats
+        
+        # Check default values
+        assert stats['total_orders'] == 0
+        assert stats['successful_orders'] == 0
+        assert stats['failed_orders'] == 0
+        assert stats['success_rate'] == 0.0
+        assert stats['average_execution_time'] == 0.0
+        assert stats['total_commission'] == 0.0
+    
+    def test_price_slippage_simulation(self, execution_agent, valid_signal):
+        """Test price slippage simulation"""
+        # Mock random.uniform to return a known slippage value
+        with patch('random.uniform', return_value=0.001):  # 0.1% slippage
+            result = execution_agent._simulate_successful_execution(valid_signal)
+            
+            # Price should be slightly different from original
+            original_price = valid_signal['price']
+            executed_price = result['price']
+            
+            # Should be within 0.2% of original price
+            price_diff = abs(executed_price - original_price) / original_price
+            assert price_diff <= 0.002
+    
+    def test_commission_calculation_edge_cases(self, execution_agent):
+        """Test commission calculation edge cases"""
+        # Test with zero quantity
+        zero_signal = {'action': 'buy', 'quantity': 0}
+        commission_zero = execution_agent._calculate_commission(zero_signal)
+        assert commission_zero == 1.0  # Only base commission
+        
+        # Test with very large quantity
+        large_signal = {'action': 'sell', 'quantity': 10000}
+        commission_large = execution_agent._calculate_commission(large_signal)
+        expected_large = 1.0 + (10000 * 0.01)
+        assert commission_large == expected_large
+    
+    def test_order_id_uniqueness(self, execution_agent):
+        """Test that order IDs are unique"""
+        order_ids = set()
+        
+        for _ in range(100):
+            order_id = execution_agent._generate_order_id()
+            order_ids.add(order_id)
+        
+        # All order IDs should be unique
+        assert len(order_ids) == 100 

tests/test_integration.py

@@ -0,0 +1,313 @@
+import pytest
+import pandas as pd
+import numpy as np
+import tempfile
+import os
+from unittest.mock import patch, MagicMock
+from agentic_ai_system.orchestrator import run, run_backtest, run_live_trading
+from agentic_ai_system.main import load_config
+
+class TestIntegration:
+    """Integration tests for the entire trading system"""
+    
+    @pytest.fixture
+    def config(self):
+        """Sample configuration for integration testing"""
+        return {
+            'data_source': {
+                'type': 'synthetic',
+                'path': 'data/market_data.csv'
+            },
+            'trading': {
+                'symbol': 'AAPL',
+                'timeframe': '1min',
+                'capital': 100000
+            },
+            'risk': {
+                'max_position': 100,
+                'max_drawdown': 0.05
+            },
+            'execution': {
+                'broker_api': 'paper',
+                'order_size': 10,
+                'delay_ms': 10,  # Fast for testing
+                'success_rate': 1.0  # Always succeed for testing
+            },
+            'synthetic_data': {
+                'base_price': 150.0,
+                'volatility': 0.02,
+                'trend': 0.001,
+                'noise_level': 0.005,
+                'data_path': 'data/synthetic_market_data.csv'
+            },
+            'logging': {
+                'log_level': 'INFO',
+                'log_dir': 'logs',
+                'enable_console': True,
+                'enable_file': True
+            }
+        }
+    
+    def test_full_workflow(self, config):
+        """Test the complete trading workflow"""
+        result = run(config)
+        
+        # Check result structure
+        assert isinstance(result, dict)
+        assert 'success' in result
+        assert 'data_loaded' in result
+        assert 'signal_generated' in result
+        assert 'order_executed' in result
+        assert 'execution_time' in result
+        assert 'errors' in result
+        
+        # Check that data was loaded
+        assert result['data_loaded'] == True
+        
+        # Check that signal was generated
+        assert result['signal_generated'] == True
+        
+        # Check execution time is reasonable
+        assert result['execution_time'] > 0
+        assert result['execution_time'] < 60  # Should complete within 60 seconds
+    
+    def test_backtest_workflow(self, config):
+        """Test the backtest workflow"""
+        result = run_backtest(config, '2024-01-01', '2024-01-02')
+        
+        # Check result structure
+        assert isinstance(result, dict)
+        assert 'success' in result
+        
+        if result['success']:
+            assert 'start_date' in result
+            assert 'end_date' in result
+            assert 'initial_capital' in result
+            assert 'final_value' in result
+            assert 'total_return' in result
+            assert 'total_trades' in result
+            assert 'trades' in result
+            assert 'positions' in result
+            
+            # Check that backtest completed
+            assert result['initial_capital'] == config['trading']['capital']
+            assert result['final_value'] >= 0
+            assert isinstance(result['total_return'], float)
+            assert result['total_trades'] >= 0
+            assert isinstance(result['trades'], list)
+            assert isinstance(result['positions'], dict)
+    
+    def test_live_trading_workflow(self, config):
+        """Test the live trading workflow (short duration)"""
+        # Test with very short duration to avoid long test times
+        result = run_live_trading(config, duration_minutes=1)
+        
+        # Check result structure
+        assert isinstance(result, dict)
+        assert 'success' in result
+        
+        if result['success']:
+            assert 'duration_minutes' in result
+            assert 'total_trades' in result
+            assert 'trades' in result
+            assert 'start_time' in result
+            assert 'end_time' in result
+            
+            # Check that live trading completed
+            assert result['duration_minutes'] == 1
+            assert result['total_trades'] >= 0
+            assert isinstance(result['trades'], list)
+    
+    def test_workflow_with_csv_data(self, config):
+        """Test workflow with CSV data source"""
+        # Create temporary CSV file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp_file:
+            # Generate sample data
+            dates = pd.date_range(start='2024-01-01', periods=100, freq='1min')
+            data = []
+            for i, date in enumerate(dates):
+                base_price = 150.0 + (i * 0.1)
+                data.append({
+                    'timestamp': date,
+                    'open': base_price + np.random.normal(0, 1),
+                    'high': base_price + abs(np.random.normal(0, 2)),
+                    'low': base_price - abs(np.random.normal(0, 2)),
+                    'close': base_price + np.random.normal(0, 1),
+                    'volume': np.random.randint(1000, 100000)
+                })
+            
+            df = pd.DataFrame(data)
+            df.to_csv(tmp_file.name, index=False)
+            config['data_source']['type'] = 'csv'
+            config['data_source']['path'] = tmp_file.name
+            
+            try:
+                result = run(config)
+                
+                assert result['success'] == True
+                assert result['data_loaded'] == True
+                assert result['signal_generated'] == True
+                
+            finally:
+                os.unlink(tmp_file.name)
+    
+    def test_workflow_error_handling(self, config):
+        """Test workflow error handling"""
+        # Test with invalid configuration
+        invalid_config = config.copy()
+        invalid_config['data_source']['type'] = 'invalid_type'
+        
+        result = run(invalid_config)
+        
+        assert result['success'] == False
+        assert len(result['errors']) > 0
+    
+    def test_backtest_with_different_periods(self, config):
+        """Test backtest with different time periods"""
+        # Test short period
+        short_result = run_backtest(config, '2024-01-01', '2024-01-01')
+        assert isinstance(short_result, dict)
+        
+        # Test longer period
+        long_result = run_backtest(config, '2024-01-01', '2024-01-07')
+        assert isinstance(long_result, dict)
+        
+        # Both should be valid results (success or failure)
+        assert 'success' in short_result
+        assert 'success' in long_result
+    
+    def test_system_with_different_symbols(self, config):
+        """Test system with different trading symbols"""
+        symbols = ['AAPL', 'GOOGL', 'MSFT', 'TSLA']
+        
+        for symbol in symbols:
+            test_config = config.copy()
+            test_config['trading']['symbol'] = symbol
+            
+            result = run(test_config)
+            
+            assert result['success'] == True
+            assert result['data_loaded'] == True
+            assert result['signal_generated'] == True
+    
+    def test_system_with_different_capital_amounts(self, config):
+        """Test system with different capital amounts"""
+        capital_amounts = [10000, 50000, 100000, 500000]
+        
+        for capital in capital_amounts:
+            test_config = config.copy()
+            test_config['trading']['capital'] = capital
+            
+            result = run(test_config)
+            
+            assert result['success'] == True
+            assert result['data_loaded'] == True
+            assert result['signal_generated'] == True
+    
+    def test_execution_failure_simulation(self, config):
+        """Test system behavior with execution failures"""
+        # Set success rate to 0 to simulate all failures
+        test_config = config.copy()
+        test_config['execution']['success_rate'] = 0.0
+        
+        result = run(test_config)
+        
+        # System should still complete workflow
+        assert result['success'] == True
+        assert result['data_loaded'] == True
+        assert result['signal_generated'] == True
+        
+        # But order execution should fail
+        if result['order_executed']:
+            assert result['execution_result']['success'] == False
+    
+    def test_data_validation_integration(self, config):
+        """Test data validation integration"""
+        # Create invalid data
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp_file:
+            invalid_data = pd.DataFrame({
+                'timestamp': pd.date_range('2024-01-01', periods=10, freq='1min'),
+                'open': [150] * 10,
+                'high': [145] * 10,  # Invalid: high < open
+                'low': [145] * 10,
+                'close': [152] * 10,
+                'volume': [1000] * 10
+            })
+            invalid_data.to_csv(tmp_file.name, index=False)
+            config['data_source']['type'] = 'csv'
+            config['data_source']['path'] = tmp_file.name
+            
+            try:
+                result = run(config)
+                
+                # System should still work (fallback to synthetic data)
+                assert result['success'] == True
+                
+            finally:
+                os.unlink(tmp_file.name)
+    
+    def test_performance_metrics(self, config):
+        """Test that performance metrics are calculated correctly"""
+        result = run_backtest(config, '2024-01-01', '2024-01-03')
+        
+        if result['success']:
+            # Check that return is calculated correctly
+            initial_capital = result['initial_capital']
+            final_value = result['final_value']
+            calculated_return = (final_value - initial_capital) / initial_capital
+            
+            assert abs(result['total_return'] - calculated_return) < 0.001
+            
+            # Check that trade count is reasonable
+            assert result['total_trades'] >= 0
+    
+    def test_config_loading(self):
+        """Test configuration loading functionality"""
+        # Test with valid config
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as tmp_file:
+            config_content = """
+data_source:
+  type: 'synthetic'
+  path: 'data/market_data.csv'
+
+trading:
+  symbol: 'AAPL'
+  timeframe: '1min'
+  capital: 100000
+
+risk:
+  max_position: 100
+  max_drawdown: 0.05
+
+execution:
+  broker_api: 'paper'
+  order_size: 10
+"""
+            tmp_file.write(config_content)
+            tmp_file.flush()
+            
+            try:
+                config = load_config(tmp_file.name)
+                
+                assert config['data_source']['type'] == 'synthetic'
+                assert config['trading']['symbol'] == 'AAPL'
+                assert config['trading']['capital'] == 100000
+                
+            finally:
+                os.unlink(tmp_file.name)
+    
+    def test_system_scalability(self, config):
+        """Test system scalability with larger datasets"""
+        # Test with larger synthetic dataset
+        test_config = config.copy()
+        test_config['synthetic_data']['base_price'] = 200.0
+        test_config['synthetic_data']['volatility'] = 0.03
+        
+        result = run(test_config)
+        
+        assert result['success'] == True
+        assert result['data_loaded'] == True
+        assert result['signal_generated'] == True
+        
+        # Check execution time is reasonable
+        assert result['execution_time'] < 30  # Should complete within 30 seconds 

tests/test_strategy_agent.py

@@ -0,0 +1,252 @@
+import pytest
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from agentic_ai_system.strategy_agent import StrategyAgent
+
+class TestStrategyAgent:
+    """Test cases for StrategyAgent"""
+    
+    @pytest.fixture
+    def config(self):
+        """Sample configuration for testing"""
+        return {
+            'trading': {
+                'symbol': 'AAPL',
+                'timeframe': '1min',
+                'capital': 100000
+            },
+            'risk': {
+                'max_position': 100,
+                'max_drawdown': 0.05
+            },
+            'execution': {
+                'broker_api': 'paper',
+                'order_size': 10
+            }
+        }
+    
+    @pytest.fixture
+    def strategy_agent(self, config):
+        """Create a StrategyAgent instance"""
+        return StrategyAgent(config)
+    
+    @pytest.fixture
+    def sample_data(self):
+        """Create sample market data for testing"""
+        dates = pd.date_range(start='2024-01-01', periods=100, freq='1min')
+        
+        # Generate realistic price data
+        base_price = 150.0
+        prices = []
+        for i in range(100):
+            # Add some trend and noise
+            price = base_price + (i * 0.1) + np.random.normal(0, 2)
+            prices.append(max(price, 1))  # Ensure positive prices
+        
+        data = []
+        for i, (date, close_price) in enumerate(zip(dates, prices)):
+            # Generate OHLC from close price
+            noise = np.random.normal(0, 1)
+            open_price = close_price + noise
+            high_price = max(open_price, close_price) + abs(np.random.normal(0, 2))
+            low_price = min(open_price, close_price) - abs(np.random.normal(0, 2))
+            volume = np.random.randint(1000, 100000)
+            
+            data.append({
+                'timestamp': date,
+                'open': round(open_price, 2),
+                'high': round(high_price, 2),
+                'low': round(low_price, 2),
+                'close': round(close_price, 2),
+                'volume': volume
+            })
+        
+        return pd.DataFrame(data)
+    
+    def test_initialization(self, strategy_agent, config):
+        """Test agent initialization"""
+        assert strategy_agent.symbol == config['trading']['symbol']
+        assert strategy_agent.capital == config['trading']['capital']
+        assert strategy_agent.max_position == config['risk']['max_position']
+        assert strategy_agent.max_drawdown == config['risk']['max_drawdown']
+    
+    def test_act_with_valid_data(self, strategy_agent, sample_data):
+        """Test signal generation with valid data"""
+        signal = strategy_agent.act(sample_data)
+        
+        # Check signal structure
+        assert isinstance(signal, dict)
+        assert 'action' in signal
+        assert 'symbol' in signal
+        assert 'quantity' in signal
+        assert 'price' in signal
+        assert 'confidence' in signal
+        
+        # Check action values
+        assert signal['action'] in ['buy', 'sell', 'hold']
+        assert signal['symbol'] == strategy_agent.symbol
+        assert signal['quantity'] >= 0
+        assert signal['price'] > 0
+        assert 0 <= signal['confidence'] <= 1
+    
+    def test_act_with_empty_data(self, strategy_agent):
+        """Test signal generation with empty data"""
+        empty_data = pd.DataFrame()
+        signal = strategy_agent.act(empty_data)
+        
+        assert signal['action'] == 'hold'
+        assert signal['quantity'] == 0
+        assert signal['confidence'] == 0.0
+    
+    def test_calculate_indicators(self, strategy_agent, sample_data):
+        """Test technical indicator calculations"""
+        indicators = strategy_agent._calculate_indicators(sample_data)
+        
+        # Check that indicators are calculated
+        expected_indicators = ['sma_20', 'sma_50', 'rsi', 'bb_upper', 'bb_lower', 'macd', 'macd_signal']
+        for indicator in expected_indicators:
+            assert indicator in indicators
+        
+        # Check that indicators have reasonable values
+        if len(indicators['sma_20']) > 0:
+            assert indicators['sma_20'][-1] > 0
+        
+        if len(indicators['rsi']) > 0:
+            rsi_value = indicators['rsi'][-1]
+            assert 0 <= rsi_value <= 100
+    
+    def test_calculate_sma(self, strategy_agent):
+        """Test Simple Moving Average calculation"""
+        prices = np.array([100, 101, 102, 103, 104, 105, 106, 107, 108, 109])
+        
+        # Test SMA with window 3
+        sma = strategy_agent._calculate_sma(prices, 3)
+        expected_sma = np.array([101, 102, 103, 104, 105, 106, 107, 108])
+        
+        np.testing.assert_array_almost_equal(sma, expected_sma, decimal=2)
+        
+        # Test with insufficient data
+        short_prices = np.array([100, 101])
+        sma_short = strategy_agent._calculate_sma(short_prices, 3)
+        assert len(sma_short) == 0
+    
+    def test_calculate_rsi(self, strategy_agent):
+        """Test RSI calculation"""
+        # Create price data with known pattern
+        prices = np.array([100, 101, 102, 101, 100, 99, 98, 99, 100, 101])
+        
+        rsi = strategy_agent._calculate_rsi(prices, window=3)
+        
+        # RSI should be between 0 and 100
+        if len(rsi) > 0:
+            assert 0 <= rsi[-1] <= 100
+    
+    def test_calculate_bollinger_bands(self, strategy_agent):
+        """Test Bollinger Bands calculation"""
+        prices = np.array([100, 101, 102, 103, 104, 105, 106, 107, 108, 109])
+        
+        bb_upper, bb_lower = strategy_agent._calculate_bollinger_bands(prices, window=5)
+        
+        if len(bb_upper) > 0 and len(bb_lower) > 0:
+            # Upper band should be above lower band
+            assert bb_upper[-1] > bb_lower[-1]
+    
+    def test_calculate_position_size(self, strategy_agent):
+        """Test position size calculation"""
+        price = 150.0
+        
+        # Test normal case
+        quantity = strategy_agent._calculate_position_size(price)
+        expected_quantity = int((strategy_agent.capital * 0.1) / price)
+        expected_quantity = min(expected_quantity, strategy_agent.max_position)
+        
+        assert quantity == expected_quantity
+        assert quantity >= 1
+        
+        # Test with very high price
+        high_price = 10000.0
+        quantity_high = strategy_agent._calculate_position_size(high_price)
+        assert quantity_high == 1  # Minimum quantity
+    
+    def test_generate_no_action_signal(self, strategy_agent):
+        """Test no-action signal generation"""
+        signal = strategy_agent._generate_no_action_signal()
+        
+        assert signal['action'] == 'hold'
+        assert signal['quantity'] == 0
+        assert signal['price'] == 0
+        assert signal['confidence'] == 0.0
+        assert signal['symbol'] == strategy_agent.symbol
+    
+    def test_signal_generation_logic(self, strategy_agent, sample_data):
+        """Test signal generation logic with different market conditions"""
+        # Test with upward trending data (should generate buy signal)
+        upward_data = sample_data.copy()
+        upward_data['close'] = upward_data['close'] * 1.1  # 10% increase
+        
+        signal_up = strategy_agent.act(upward_data)
+        
+        # Test with downward trending data (should generate sell signal)
+        downward_data = sample_data.copy()
+        downward_data['close'] = downward_data['close'] * 0.9  # 10% decrease
+        
+        signal_down = strategy_agent.act(downward_data)
+        
+        # Both should be valid signals
+        assert signal_up['action'] in ['buy', 'sell', 'hold']
+        assert signal_down['action'] in ['buy', 'sell', 'hold']
+    
+    def test_error_handling(self, strategy_agent):
+        """Test error handling in signal generation"""
+        # Test with invalid data
+        invalid_data = pd.DataFrame({'invalid_column': [1, 2, 3]})
+        
+        # Should not raise exception, should return hold signal
+        signal = strategy_agent.act(invalid_data)
+        assert signal['action'] == 'hold'
+    
+    def test_technical_indicators_edge_cases(self, strategy_agent):
+        """Test technical indicators with edge cases"""
+        # Test with constant prices
+        constant_prices = np.ones(50) * 100
+        rsi_constant = strategy_agent._calculate_rsi(constant_prices)
+        
+        # Test with all increasing prices
+        increasing_prices = np.arange(100, 150)
+        rsi_increasing = strategy_agent._calculate_rsi(increasing_prices)
+        
+        # Test with all decreasing prices
+        decreasing_prices = np.arange(150, 100, -1)
+        rsi_decreasing = strategy_agent._calculate_rsi(decreasing_prices)
+        
+        # All should return valid arrays (possibly empty)
+        assert isinstance(rsi_constant, np.ndarray)
+        assert isinstance(rsi_increasing, np.ndarray)
+        assert isinstance(rsi_decreasing, np.ndarray)
+    
+    def test_macd_calculation(self, strategy_agent):
+        """Test MACD calculation"""
+        prices = np.array([100 + i * 0.1 + np.random.normal(0, 1) for i in range(50)])
+        
+        macd, signal = strategy_agent._calculate_macd(prices)
+        
+        # Both should be numpy arrays
+        assert isinstance(macd, np.ndarray)
+        assert isinstance(signal, np.ndarray)
+        
+        # If we have enough data, both should have values
+        if len(prices) >= 26:
+            assert len(macd) > 0
+            if len(macd) >= 9:  # Need enough data for signal line
+                assert len(signal) > 0
+    
+    def test_ema_calculation(self, strategy_agent):
+        """Test Exponential Moving Average calculation"""
+        prices = np.array([100, 101, 102, 103, 104, 105, 106, 107, 108, 109])
+        
+        ema = strategy_agent._calculate_ema(prices, window=5)
+        
+        assert isinstance(ema, np.ndarray)
+        if len(ema) > 0:
+            assert ema[-1] > 0  # EMA should be positive 

tests/test_synthetic_data_generator.py

@@ -0,0 +1,210 @@
+import pytest
+import pandas as pd
+import numpy as np
+from datetime import datetime
+import tempfile
+import os
+from agentic_ai_system.synthetic_data_generator import SyntheticDataGenerator
+
+class TestSyntheticDataGenerator:
+    """Test cases for SyntheticDataGenerator"""
+    
+    @pytest.fixture
+    def config(self):
+        """Sample configuration for testing"""
+        return {
+            'synthetic_data': {
+                'base_price': 100.0,
+                'volatility': 0.02,
+                'trend': 0.001,
+                'noise_level': 0.005
+            },
+            'trading': {
+                'symbol': 'AAPL',
+                'timeframe': '1min'
+            }
+        }
+    
+    @pytest.fixture
+    def generator(self, config):
+        """Create a SyntheticDataGenerator instance"""
+        return SyntheticDataGenerator(config)
+    
+    def test_initialization(self, generator, config):
+        """Test generator initialization"""
+        assert generator.base_price == config['synthetic_data']['base_price']
+        assert generator.volatility == config['synthetic_data']['volatility']
+        assert generator.trend == config['synthetic_data']['trend']
+        assert generator.noise_level == config['synthetic_data']['noise_level']
+    
+    def test_generate_ohlcv_data(self, generator):
+        """Test OHLCV data generation"""
+        df = generator.generate_ohlcv_data(
+            symbol='AAPL',
+            start_date='2024-01-01',
+            end_date='2024-01-02',
+            frequency='1min'
+        )
+        
+        # Check DataFrame structure
+        assert isinstance(df, pd.DataFrame)
+        assert len(df) > 0
+        
+        # Check required columns
+        required_columns = ['timestamp', 'symbol', 'open', 'high', 'low', 'close', 'volume']
+        for col in required_columns:
+            assert col in df.columns
+        
+        # Check data types
+        assert df['timestamp'].dtype == 'datetime64[ns]'
+        assert df['symbol'].dtype == 'object'
+        assert df['open'].dtype in ['float64', 'float32']
+        assert df['high'].dtype in ['float64', 'float32']
+        assert df['low'].dtype in ['float64', 'float32']
+        assert df['close'].dtype in ['float64', 'float32']
+        assert df['volume'].dtype in ['int64', 'int32']
+        
+        # Check data validity
+        assert (df['high'] >= df['low']).all()
+        assert (df['high'] >= df['open']).all()
+        assert (df['high'] >= df['close']).all()
+        assert (df['low'] <= df['open']).all()
+        assert (df['low'] <= df['close']).all()
+        assert (df['volume'] >= 0).all()
+        assert (df['open'] > 0).all()
+        assert (df['close'] > 0).all()
+    
+    def test_generate_tick_data(self, generator):
+        """Test tick data generation"""
+        df = generator.generate_tick_data(
+            symbol='AAPL',
+            duration_minutes=10,
+            tick_interval_ms=1000
+        )
+        
+        # Check DataFrame structure
+        assert isinstance(df, pd.DataFrame)
+        assert len(df) > 0
+        
+        # Check required columns
+        required_columns = ['timestamp', 'symbol', 'price', 'volume']
+        for col in required_columns:
+            assert col in df.columns
+        
+        # Check data validity
+        assert (df['price'] > 0).all()
+        assert (df['volume'] >= 0).all()
+        assert df['symbol'].iloc[0] == 'AAPL'
+    
+    def test_generate_price_series(self, generator):
+        """Test price series generation"""
+        length = 100
+        prices = generator._generate_price_series(length)
+        
+        assert isinstance(prices, np.ndarray)
+        assert len(prices) == length
+        assert (prices > 0).all()  # All prices should be positive
+    
+    def test_save_to_csv(self, generator):
+        """Test saving data to CSV"""
+        df = generator.generate_ohlcv_data(
+            symbol='AAPL',
+            start_date='2024-01-01',
+            end_date='2024-01-01',
+            frequency='1H'
+        )
+        
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp_file:
+            filepath = tmp_file.name
+        
+        try:
+            generator.save_to_csv(df, filepath)
+            
+            # Check if file exists and has content
+            assert os.path.exists(filepath)
+            assert os.path.getsize(filepath) > 0
+            
+            # Load and verify data
+            loaded_df = pd.read_csv(filepath)
+            assert len(loaded_df) == len(df)
+            assert list(loaded_df.columns) == list(df.columns)
+            
+        finally:
+            # Cleanup
+            if os.path.exists(filepath):
+                os.unlink(filepath)
+    
+    def test_market_scenarios(self, generator):
+        """Test different market scenarios"""
+        scenarios = ['normal', 'volatile', 'trending', 'crash']
+        
+        for scenario in scenarios:
+            df = generator.generate_market_scenarios(scenario)
+            
+            assert isinstance(df, pd.DataFrame)
+            assert len(df) > 0
+            
+            # Check that crash scenario has lower prices on average
+            if scenario == 'crash':
+                avg_price = df['close'].mean()
+                assert avg_price < generator.base_price * 0.9  # Should be significantly lower
+    
+    def test_invalid_frequency(self, generator):
+        """Test handling of invalid frequency"""
+        with pytest.raises(ValueError, match="Unsupported frequency"):
+            generator.generate_ohlcv_data(frequency='invalid')
+    
+    def test_invalid_scenario(self, generator):
+        """Test handling of invalid scenario"""
+        with pytest.raises(ValueError, match="Unknown scenario type"):
+            generator.generate_market_scenarios('invalid_scenario')
+    
+    def test_empty_date_range(self, generator):
+        """Test handling of empty date range"""
+        df = generator.generate_ohlcv_data(
+            start_date='2024-01-01',
+            end_date='2024-01-01',
+            frequency='1D'
+        )
+        
+        # Should generate at least one data point
+        assert len(df) >= 1
+    
+    def test_different_symbols(self, generator):
+        """Test data generation for different symbols"""
+        symbols = ['AAPL', 'GOOGL', 'MSFT', 'TSLA']
+        
+        for symbol in symbols:
+            df = generator.generate_ohlcv_data(symbol=symbol)
+            assert df['symbol'].iloc[0] == symbol
+    
+    def test_price_consistency(self, generator):
+        """Test that generated prices are consistent"""
+        df = generator.generate_ohlcv_data(
+            start_date='2024-01-01',
+            end_date='2024-01-02',
+            frequency='1H'
+        )
+        
+        # Check that prices are within reasonable bounds
+        max_price = df[['open', 'high', 'low', 'close']].max().max()
+        min_price = df[['open', 'high', 'low', 'close']].min().min()
+        
+        # Prices should be within 50% of base price
+        assert min_price > generator.base_price * 0.5
+        assert max_price < generator.base_price * 1.5
+    
+    def test_volume_correlation(self, generator):
+        """Test that volume correlates with price movement"""
+        df = generator.generate_ohlcv_data(
+            start_date='2024-01-01',
+            end_date='2024-01-02',
+            frequency='1H'
+        )
+        
+        # Calculate price movement
+        df['price_movement'] = abs(df['close'] - df['open'])
+        
+        # Check that volume is correlated with price movement
+        correlation = df['volume'].corr(df['price_movement'])
+        assert not np.isnan(correlation)  # Should have some correlation