diff --git a/.env.example b/.env.example
index a2eeff6d..5b68f78b 100644
--- a/.env.example
+++ b/.env.example
@@ -1,12 +1,30 @@
-# Kalshi Trading API (Required)
-KALSHI_API_KEY_ID=your_kalshi_key_id
-KALSHI_API_KEY=your_kalshi_api_key
+# ============================================
+# NEURAL SDK - ENVIRONMENT TEMPLATE
+# ============================================
+# Copy this file to .env and fill in your actual values
 
-# OpenWeatherMap API (Working!)
-OPENWEATHER_API_KEY=78596505b0f5fea89e98ebcbf3bd6e21
+# --- NEURAL API (Required) ---
+# Accepts: prod | demo (used for Kalshi endpoints)
+NEURAL_ENVIRONMENT=prod
+NEURAL_API_KEY_ID=your_neural_api_key_id
+# Either provide the private key INLINE or via FILE path
+# NEURAL_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\n...\n-----END RSA PRIVATE KEY-----"
+NEURAL_PRIVATE_KEY_FILE=./keys/neural_prod_private.key
 
-# Reddit API (Optional - for sentiment analysis)
+# --- EXTERNAL APIs ---
+# Used by weather adapter (config/data_sources.yaml)
+OPENWEATHER_API_KEY=your_openweather_api_key
 REDDIT_CLIENT_ID=your_reddit_client_id
 REDDIT_CLIENT_SECRET=your_reddit_client_secret
 
-# DraftKings (No API key needed - public data)
\ No newline at end of file
+# --- LLM CONFIGURATION ---
+OPENROUTER_API_KEY=your_openrouter_api_key
+
+# --- OTHER SERVICES ---
+E2B_API_KEY=your_e2b_api_key
+EXA_API_KEY=your_exa_api_key
+TWITTERAPI_KEY=your_twitter_api_key
+
+# --- AGENTUITY PLATFORM ---
+AGENTUITY_SDK_KEY=your_agentuity_sdk_key
+AGENTUITY_PROJECT_KEY=your_agentuity_project_key
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index c7282d82..bd0189ae 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -104,7 +104,7 @@ jobs:
       - name: Install package
         run: |
           pip install dist/*.whl
-          python -c "import agent_consumers; print('✅ Package imported successfully')"
+          python -c "import sdk, data_pipeline; print('✅ Package imported successfully')"
 
   create-github-release:
     name: Create GitHub Release
@@ -263,4 +263,4 @@ jobs:
       - name: Create incident
         run: |
           echo "📝 Creating incident report"
-          # gh issue create --title "Production deployment failed: ${{ needs.validate-version.outputs.version }}" --body "Automatic rollback initiated"
\ No newline at end of file
+          # gh issue create --title "Production deployment failed: ${{ needs.validate-version.outputs.version }}" --body "Automatic rollback initiated"
diff --git a/.gitignore b/.gitignore
index e4796dd1..518d5f7f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -131,6 +131,9 @@ celerybeat.pid
 .env
 .env.development
 .env.production
+.env.demo
+.env.*
+!*.example
 .venv
 env/
 venv/
@@ -191,6 +194,7 @@ keys/
 # Project Specific
 logs/
 *.log
+data/
 data/cache/
 data/backtest_results/
 temp/
@@ -214,4 +218,4 @@ Thumbs.db
 # Test outputs
 test_results/
 coverage/
-.pytest_cache/
\ No newline at end of file
+.pytest_cache/
diff --git a/CLAUDE.md b/CLAUDE.md
deleted file mode 100644
index 2ea1bbdd..00000000
--- a/CLAUDE.md
+++ /dev/null
@@ -1,494 +0,0 @@
-# CLAUDE.md
-
-This file provides comprehensive guidance to Claude Code (claude.ai/code) when working with the Kalshi Trading Agent System.
-
-## Project Overview
-
-Autonomous multi-agent trading system for Kalshi sports event contracts using the Agentuity framework. The system uses real-time WebSocket streams, Redis pub/sub for data distribution, and sophisticated agents with LLM analysis to execute trades using the Kelly Criterion for optimal position sizing.
-
-## System Architecture
-
-### Data Flow Pipeline
-```
-[External APIs] → [WebSocket Streams] → [Redis Pub/Sub] → [Agent Consumers] → [Trading Decisions]
-                           ↓                    ↓                 ↓
-                    [Stream Manager]    [Event Publisher]   [Agentuity Agents]
-                           ↓                    ↓                 ↓
-                    [Reliability Layer]  [Redis Channels]   [Kalshi API]
-```
-
-### Directory Structure (Production Names)
-```
-.
-├── agents/                    # Agentuity platform agents (high-level logic)
-├── agent_consumers/           # Redis consumers (data processing)
-├── data_pipeline/            # Data ingestion and streaming
-│   ├── orchestration/        # Stream coordination
-│   ├── streaming/           # WebSocket clients
-│   ├── data_sources/        # API integrations
-│   └── reliability/         # Resilience components
-├── trading_logic/           # Trading algorithms and tools
-├── tests/                   # Test suite
-├── examples/               # Usage examples
-└── docs/                   # Documentation
-```
-
-## Key Design Decisions
-
-### 1. Redis Pub/Sub Architecture
-**Decision:** Use Redis as central message broker  
-**Rationale:** 
-- Decouples data sources from consumers
-- Enables horizontal scaling
-- Provides buffering and persistence
-- Supports multiple subscribers per channel
-
-### 2. Separation of Concerns
-**Decision:** Split agents into consumers and platform agents  
-**Rationale:**
-- `agent_consumers/`: Handle real-time data, no LLM calls
-- `agents/`: Complex decisions with LLM analysis
-- Clear performance boundaries
-- Easier testing and debugging
-
-### 3. Kelly Criterion with Safety Factor
-**Decision:** Use 25% of Kelly for position sizing  
-**Rationale:**
-- Reduces risk of ruin
-- Accounts for estimation errors
-- Provides smoother equity curve
-- Industry standard practice
-
-## Common Development Tasks
-
-### Adding a New Data Source
-
-1. **Create WebSocket Client**
-```python
-# data_pipeline/streaming/new_source.py
-class NewSourceWebSocket:
-    async def connect(self):
-        # Implementation
-    
-    async def subscribe(self, channels):
-        # Implementation
-```
-
-2. **Add to Stream Manager**
-```python
-# data_pipeline/orchestration/unified_stream_manager.py
-self.new_source_client = NewSourceWebSocket(config)
-await self.new_source_client.connect()
-```
-
-3. **Define Redis Channel**
-```python
-# data_pipeline/orchestration/redis_event_publisher.py
-await self.publish("newsource:events", event_data)
-```
-
-4. **Create Consumer**
-```python
-# agent_consumers/NewConsumer/consumer.py
-class NewConsumer(BaseConsumer):
-    async def process_message(self, channel, data):
-        # Process events
-```
-
-### Implementing a Trading Strategy
-
-1. **Define Strategy in Agent**
-```python
-# agents/StrategyAnalyst/agent.py
-@tool
-def analyze_opportunity(market_data, sentiment):
-    # Strategy logic
-    return signal
-```
-
-2. **Process Signals in Consumer**
-```python
-# agent_consumers/DataCoordinator/data_coordinator.py
-if signal.strength > THRESHOLD:
-    await self.publish_signal(signal)
-```
-
-3. **Execute Trade**
-```python
-# agents/TradeExecutor/agent.py
-@tool
-def execute_trade(signal):
-    position_size = calculate_kelly_position(signal)
-    order = place_order(market, side, position_size)
-    return order
-```
-
-### Testing Workflows
-
-1. **Test Redis Integration**
-```bash
-# Start Redis
-redis-server
-
-# Run integration tests
-pytest tests/test_redis_integration.py
-```
-
-2. **Test Individual Agent**
-```bash
-# Start in dev mode
-agentuity dev
-
-# Test specific agent
-agentuity agent test DataCoordinator
-```
-
-3. **Full System Test**
-```bash
-# Run all components
-python examples/agent_redis_consumer.py all
-```
-
-## Code Style & Conventions
-
-### Python Standards
-- Use Python 3.10+ features
-- Type hints for all functions
-- Async/await for I/O operations
-- Dataclasses for data structures
-
-### Naming Conventions
-```python
-# Files and modules: snake_case
-unified_stream_manager.py
-
-# Classes: PascalCase
-class DataCoordinator:
-    pass
-
-# Functions and variables: snake_case
-def calculate_position_size():
-    pass
-
-# Constants: UPPER_SNAKE_CASE
-MAX_POSITION_SIZE = 100
-```
-
-### Import Organization
-```python
-# Standard library
-import os
-import asyncio
-from datetime import datetime
-
-# Third-party
-import redis
-import websockets
-from agentuity import Agent, tool
-
-# Local application
-from data_pipeline.orchestration import StreamManager
-from agent_consumers.base_consumer import BaseConsumer
-from trading_logic.kelly_tools import calculate_kelly
-```
-
-### Error Handling Pattern
-```python
-async def robust_operation():
-    """Standard error handling pattern."""
-    max_retries = 3
-    retry_delay = 1.0
-    
-    for attempt in range(max_retries):
-        try:
-            result = await risky_operation()
-            return result
-        except TemporaryError as e:
-            logger.warning(f"Attempt {attempt + 1} failed: {e}")
-            if attempt < max_retries - 1:
-                await asyncio.sleep(retry_delay)
-                retry_delay *= 2  # Exponential backoff
-            else:
-                raise
-        except PermanentError as e:
-            logger.error(f"Permanent failure: {e}")
-            raise
-```
-
-## Trading Logic Implementation
-
-### Position Sizing
-Always use Kelly Criterion with safety factors:
-```python
-# Never use full Kelly
-position = kelly_fraction * 0.25  # 25% of Kelly
-
-# Apply hard limits
-position = min(position, MAX_POSITION_SIZE)
-position = max(position, MIN_POSITION_SIZE)
-
-# Check portfolio exposure
-if total_exposure + position > MAX_PORTFOLIO_EXPOSURE:
-    position = MAX_PORTFOLIO_EXPOSURE - total_exposure
-```
-
-### Risk Management Rules
-1. **Stop Loss**: Always set at order time
-2. **Position Limits**: Max 5% per position
-3. **Correlation**: Reduce size for correlated bets
-4. **Drawdown**: Stop at 20% daily loss
-
-### Market Analysis
-```python
-# Check for arbitrage
-if yes_price + no_price < 0.98:
-    # Arbitrage opportunity exists
-    
-# Check liquidity
-if volume < MIN_LIQUIDITY:
-    # Skip illiquid markets
-    
-# Check spread
-if abs(yes_price - no_price) > MAX_SPREAD:
-    # Market too wide
-```
-
-## Performance Considerations
-
-### WebSocket Management
-- Maintain persistent connections
-- Implement heartbeat/ping
-- Buffer during disconnections
-- Automatic reconnection
-
-### Redis Optimization
-- Use connection pooling
-- Batch publish when possible
-- Set appropriate TTLs
-- Monitor memory usage
-
-### Agent Performance
-- Cache LLM responses
-- Batch similar requests
-- Use appropriate models
-- Monitor token usage
-
-## Security Practices
-
-### API Keys
-```bash
-# Never hardcode keys
-KALSHI_API_KEY_ID=xxx  # In .env file
-
-# Use environment variables
-key_id = os.getenv("KALSHI_API_KEY_ID")
-```
-
-### Data Privacy
-- Don't log sensitive data
-- Sanitize user inputs
-- Encrypt stored credentials
-- Audit access logs
-
-## Troubleshooting Guide
-
-### Common Issues
-
-#### WebSocket Disconnections
-```python
-# Check: Connection status
-logger.info(f"WebSocket state: {ws.state}")
-
-# Solution: Automatic reconnection
-await exponential_backoff_retry()
-```
-
-#### Redis Pub/Sub Issues
-```bash
-# Check: Redis connectivity
-redis-cli ping
-
-# Check: Active subscriptions
-redis-cli PUBSUB CHANNELS
-
-# Monitor: Message flow
-redis-cli MONITOR
-```
-
-#### No Trading Signals
-```python
-# Check: Data pipeline
-assert stream_manager.is_connected()
-
-# Check: Agent consumers
-assert len(active_consumers) > 0
-
-# Check: Signal thresholds
-logger.info(f"Signal threshold: {SIGNAL_THRESHOLD}")
-```
-
-#### High Latency
-```bash
-# Profile: Message processing
-python -m cProfile -s cumulative server.py
-
-# Check: Redis performance
-redis-cli --latency
-
-# Monitor: System resources
-htop
-```
-
-## Deployment Checklist
-
-### Pre-Deployment
-- [ ] All tests passing
-- [ ] Environment variables set
-- [ ] Redis configured
-- [ ] API credentials valid
-- [ ] Risk limits configured
-
-### Deployment Steps
-```bash
-# 1. Set production environment
-export ENVIRONMENT=production
-
-# 2. Verify configuration
-agentuity config verify
-
-# 3. Deploy agents
-agentuity deploy
-
-# 4. Monitor logs
-agentuity logs --follow
-```
-
-### Post-Deployment
-- [ ] Verify WebSocket connections
-- [ ] Check Redis pub/sub
-- [ ] Confirm agent health
-- [ ] Monitor first trades
-- [ ] Review error logs
-
-## Performance Benchmarks
-
-### Expected Metrics
-- WebSocket latency: < 100ms
-- Redis publish: < 10ms
-- Agent processing: < 500ms
-- End-to-end: < 1 second
-
-### Capacity Planning
-- Redis: 10K messages/second
-- WebSocket: 1K updates/second
-- Agents: 100 decisions/minute
-- Trades: 20 per day maximum
-
-## Emergency Procedures
-
-### Market Halt
-```python
-# Immediate stop
-await risk_manager.emergency_stop()
-
-# Cancel all orders
-await trade_executor.cancel_all_orders()
-
-# Notify team
-await send_alert("Trading halted")
-```
-
-### Data Loss
-```python
-# Switch to cached data
-await use_fallback_data()
-
-# Reduce position sizes
-KELLY_FRACTION *= 0.5
-
-# Log incident
-logger.critical("Data loss detected")
-```
-
-## Testing Strategy
-
-### Unit Tests
-Test individual components in isolation:
-```bash
-pytest tests/unit/ -v
-```
-
-### Integration Tests
-Test component interactions:
-```bash
-pytest tests/integration/ -v
-```
-
-### End-to-End Tests
-Test full system flow:
-```bash
-pytest tests/e2e/ -v
-```
-
-### Performance Tests
-```bash
-# Load testing
-locust -f tests/load/locustfile.py
-
-# Stress testing
-python tests/stress/stress_test.py
-```
-
-## Important Notes
-
-### Do's
-- ✅ Always use try/except for external calls
-- ✅ Log all trading decisions
-- ✅ Validate data before processing
-- ✅ Use type hints
-- ✅ Write tests for new features
-
-### Don'ts
-- ❌ Never commit secrets
-- ❌ Don't bypass risk checks
-- ❌ Avoid synchronous I/O
-- ❌ Don't ignore error logs
-- ❌ Never use full Kelly
-
-## Quick Commands Reference
-
-```bash
-# Development
-agentuity dev                    # Start dev server
-uv run server.py                 # Run directly
-uv run pytest tests/            # Run tests
-
-# Redis
-redis-cli ping                   # Check Redis
-redis-cli MONITOR               # Monitor messages
-redis-cli FLUSHALL              # Clear all data
-
-# Deployment
-agentuity deploy                # Deploy to cloud
-agentuity logs DataCoordinator  # View agent logs
-agentuity status                # Check deployment
-
-# Monitoring
-python examples/agent_redis_consumer.py all  # Run all consumers
-python examples/test_kalshi_websocket.py    # Test WebSocket
-```
-
-## Contact & Support
-
-For questions about:
-- **Architecture**: Review docs/ARCHITECTURE.md
-- **Agents**: Check agents/README.md
-- **Trading Logic**: See trading_logic/README.md
-- **Data Pipeline**: Read data_pipeline/README.md
-
-When debugging:
-1. Check logs first
-2. Verify configuration
-3. Test components individually
-4. Review recent changes
-5. Check system resources
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 00000000..50b37a1b
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,25 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends curl build-essential \
+ && rm -rf /var/lib/apt/lists/*
+
+# Optional: install uv for reproducible installs
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh && ln -s /root/.local/bin/uv /usr/local/bin/uv
+
+WORKDIR /app
+
+# Install dependencies first (leverage caching)
+COPY pyproject.toml uv.lock ./
+RUN uv sync --no-dev || pip install .
+
+# Copy source and configs
+COPY neural_sdk ./neural_sdk
+COPY config ./config
+
+# Default command does a smoke import
+CMD ["python", "-c", "import neural_sdk; print('Neural SDK OK')"]
+
diff --git a/INVESTOR_DEMO.md b/INVESTOR_DEMO.md
deleted file mode 100644
index c57cb5f4..00000000
--- a/INVESTOR_DEMO.md
+++ /dev/null
@@ -1,496 +0,0 @@
-# 🏆 Kalshi Trading Agent Platform
-## AI-Powered Sports Prediction Market Trading System
-
----
-
-## Executive Summary
-
-### 📊 The Opportunity
-- **$2B+ Daily Volume** in sports prediction markets
-- **67% Average Spread** indicates market inefficiencies
-- **<100ms Latency Advantage** over manual traders
-- **24/7 Autonomous Operation** capturing opportunities humans miss
-
-### 🎯 Our Solution
-An institutional-grade autonomous trading system that:
-- Correlates real-time game data with market prices
-- Uses AI to identify and exploit pricing inefficiencies
-- Manages risk using proven quantitative methods
-- Scales horizontally to trade hundreds of markets simultaneously
-
----
-
-## System Architecture Overview
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                     KALSHI TRADING AGENT PLATFORM                │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                   │
-│  DATA INGESTION LAYER                                           │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │
-│  │   Kalshi    │  │    ESPN     │  │   Twitter   │            │
-│  │  WebSocket  │  │   Stream    │  │  Sentiment  │            │
-│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘            │
-│         │                 │                 │                    │
-│  ═══════╪═════════════════╪═════════════════╪═══════════        │
-│         ▼                 ▼                 ▼                    │
-│  ┌────────────────────────────────────────────────┐            │
-│  │         UNIFIED STREAM MANAGER                  │            │
-│  │  • Event Correlation                           │            │
-│  │  • Time Synchronization                        │            │
-│  │  • Backpressure Control                        │            │
-│  └─────────────────────┬──────────────────────────┘            │
-│                        │                                         │
-│  DISTRIBUTION LAYER    ▼                                         │
-│  ┌────────────────────────────────────────────────┐            │
-│  │            REDIS PUB/SUB HUB                   │            │
-│  │  • 10K msg/sec throughput                      │            │
-│  │  • Channel-based routing                       │            │
-│  │  • Persistent message buffer                   │            │
-│  └──┬──────────┬──────────┬──────────┬──────────┘            │
-│     │          │          │          │                          │
-│  INTELLIGENCE LAYER                                             │
-│     ▼          ▼          ▼          ▼                          │
-│  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐                      │
-│  │Data  │  │Market│  │Risk  │  │Trade │                      │
-│  │Coord.│  │Analy.│  │Mgr.  │  │Exec. │                      │
-│  └──────┘  └──────┘  └──────┘  └──────┘                      │
-│     │          │          │          │                          │
-│  EXECUTION LAYER      │          │                              │
-│     └──────────┴──────────┴──────────┘                          │
-│                        │                                         │
-│                        ▼                                         │
-│              ┌──────────────────┐                              │
-│              │   KALSHI API     │                              │
-│              │   • Orders       │                              │
-│              │   • Positions    │                              │
-│              └──────────────────┘                              │
-└─────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 🚀 Live Data Flow Demonstration
-
-### Real-Time Market Monitoring
-```python
-# LIVE EXAMPLE: Super Bowl 2025 - Chiefs vs Bills
-Market: SUPERBOWL-2025-WINNER
-Current Prices: Chiefs YES: $0.65 | Bills YES: $0.35
-
-📈 Data Sources Active:
-- Kalshi WebSocket: ✅ Connected (12ms latency)
-- ESPN GameCast: ✅ Streaming (45ms latency)  
-- Twitter Sentiment: ✅ Processing (2,341 tweets/min)
-
-🔄 Recent Events (Last 30 seconds):
-[14:23:45] ESPN: Touchdown Chiefs! Score: 21-14
-[14:23:46] Twitter: Sentiment spike detected (+18% Chiefs)
-[14:23:47] Kalshi: Price movement $0.62 → $0.65 (+4.8%)
-[14:23:48] System: OPPORTUNITY - Market lagging game event
-[14:23:49] Trade: BUY Chiefs YES @ $0.65 (100 contracts)
-[14:23:51] Trade: FILLED @ $0.65 ✓
-
-💰 P&L This Session: +$487.23 (12 trades, 83% win rate)
-```
-
----
-
-## 🧠 AI Agent Architecture
-
-### Always-On Agents (24/7 Monitoring)
-```
-┌────────────────────────────────────────┐
-│       DATA COORDINATOR AGENT           │
-│  • Correlates multi-source data       │
-│  • Maintains market context           │
-│  • Publishes unified events           │
-└────────────────────────────────────────┘
-                    │
-    ┌───────────────┼───────────────┐
-    ▼               ▼               ▼
-┌─────────┐   ┌─────────┐   ┌─────────┐
-│Portfolio│   │ Market  │   │  Risk   │
-│ Monitor │   │ Scanner │   │ Monitor │
-└─────────┘   └─────────┘   └─────────┘
-```
-
-### On-Demand Agents (Decision Making)
-```
-┌────────────────────────────────────────┐
-│       STRATEGY ANALYST AGENT          │
-│  • GPT-4 powered analysis             │
-│  • Pattern recognition                │
-│  • Probability calculation            │
-└────────────────────────────────────────┘
-                    │
-                    ▼
-┌────────────────────────────────────────┐
-│        TRADE EXECUTOR AGENT           │
-│  • Kelly Criterion sizing             │
-│  • Order management                   │
-│  • Execution optimization             │
-└────────────────────────────────────────┘
-```
-
----
-
-## 📊 Backtesting & Performance
-
-### Historical Performance (2024 Season)
-```
-Period: Jan 2024 - Dec 2024
-Markets Traded: 487
-Total Trades: 3,241
-
-Performance Metrics:
-┌─────────────────────────────────────┐
-│ Sharpe Ratio:        2.87          │
-│ Win Rate:            67.3%         │
-│ Avg Win/Loss:        1.82          │
-│ Max Drawdown:        -12.4%        │
-│ Total Return:        +187%         │
-│ Profit Factor:       2.41          │
-└─────────────────────────────────────┘
-
-Monthly Returns:
-Jan: +14.2%  Apr: +11.8%  Jul: +18.3%  Oct: +22.1%
-Feb: +8.7%   May: +15.4%  Aug: +12.9%  Nov: +19.7%
-Mar: +9.3%   Jun: -3.2%   Sep: +16.5%  Dec: +24.8%
-```
-
-### Strategy Optimization Results
-```python
-# Genetic Algorithm Optimization (10,000 iterations)
-OPTIMAL PARAMETERS:
-├── Kelly Multiplier: 0.25 (25% of full Kelly)
-├── Stop Loss: 12%
-├── Take Profit: 35%
-├── Min Edge Required: 3.5%
-├── Confidence Threshold: 0.72
-└── Max Position Size: 5% of capital
-
-# Walk-Forward Analysis (6 months out-of-sample)
-In-Sample Sharpe: 2.87
-Out-of-Sample Sharpe: 2.64 ✓ (Robust)
-```
-
----
-
-## 🛡️ Risk Management
-
-### Multi-Layer Risk Control
-```
-Level 1: Pre-Trade Checks
-├── Market liquidity verification
-├── Correlation analysis
-├── Position sizing (Kelly Criterion)
-└── Max exposure limits
-
-Level 2: Real-Time Monitoring  
-├── Stop-loss triggers
-├── Drawdown circuit breakers
-├── Volatility adjustment
-└── Portfolio heat mapping
-
-Level 3: System Protection
-├── API rate limiting
-├── Connection redundancy
-├── Data validation
-└── Emergency shutdown
-```
-
-### Live Risk Dashboard
-```
-Current Portfolio Status:
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Open Positions: 8
-Total Exposure: $24,531 (49% of capital)
-Daily P&L: +$1,247 (+2.5%)
-Risk Metrics:
-  • VaR (95%): $1,823
-  • Correlation Risk: LOW
-  • System Health: 98/100
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
----
-
-## 💻 Technology Stack
-
-### Core Infrastructure
-- **Language**: Python 3.11+ with async/await
-- **Message Queue**: Redis Pub/Sub (10K msg/sec)
-- **WebSockets**: Persistent bi-directional streams
-- **AI/ML**: OpenAI GPT-4, Custom sentiment models
-- **Monitoring**: Prometheus + Grafana dashboards
-
-### Performance Specifications
-```
-Latency Benchmarks:
-├── Market Data → Decision: <100ms
-├── Decision → Execution: <50ms
-├── End-to-End: <200ms
-└── Failure Recovery: <2 seconds
-
-Capacity:
-├── Concurrent Markets: 500+
-├── Events/Second: 10,000
-├── Decisions/Minute: 100
-└── Orders/Day: 1,000+
-```
-
----
-
-## 📈 Competitive Advantages
-
-### 1. **Speed** - Microsecond Advantage
-```
-Human Trader: 2-5 seconds to react
-Our System:   0.1 seconds to execute
-Advantage:    20-50x faster
-```
-
-### 2. **Scale** - Parallel Processing
-```
-Human: Monitors 1-3 markets
-System: Monitors 500+ markets
-Advantage: 166x coverage
-```
-
-### 3. **Consistency** - No Emotions
-```
-Human: 55% win rate (emotional decisions)
-System: 67% win rate (data-driven)
-Advantage: 22% improvement
-```
-
-### 4. **Intelligence** - AI Enhancement
-```python
-# Real correlation example
-if espn_touchdown_event and not kalshi_price_moved:
-    confidence = calculate_edge(game_state, market_state)
-    if confidence > 0.72:
-        execute_trade(size=kelly_position(confidence))
-```
-
----
-
-## 🎯 Market Opportunity
-
-### Total Addressable Market
-- **Kalshi Daily Volume**: $2M+ and growing
-- **Sports Betting Market**: $150B globally
-- **Prediction Markets**: $10B+ by 2025
-
-### Revenue Model
-- **Performance Fee**: 20% of profits
-- **Management Fee**: 2% AUM
-- **License Revenue**: White-label to funds
-
-### Scalability Path
-```
-Phase 1: Single Exchange (Kalshi) ✓ Complete
-Phase 2: Multi-Exchange (Polymarket, Manifold)
-Phase 3: Traditional Sports Books Integration
-Phase 4: Custom Market Making
-```
-
----
-
-## 🚦 Live System Demo
-
-### Starting the Platform
-```bash
-# Initialize all components
-$ python scripts/run_agents.py all
-
-[2024-08-30 14:30:00] Starting Kalshi Trading Platform...
-[2024-08-30 14:30:01] ✓ Redis connected (localhost:6379)
-[2024-08-30 14:30:02] ✓ Kalshi WebSocket connected
-[2024-08-30 14:30:03] ✓ ESPN stream active (4 games)
-[2024-08-30 14:30:04] ✓ Twitter sentiment analyzer online
-[2024-08-30 14:30:05] ✓ 5 AI agents initialized
-[2024-08-30 14:30:06] ✓ Risk manager active
-[2024-08-30 14:30:07] System ready. Monitoring 12 markets...
-
-═══════════════════════════════════════════════
-    KALSHI TRADING PLATFORM - LIVE
-═══════════════════════════════════════════════
-Markets: 12 | Agents: 5 | Latency: 23ms
-P&L Today: +$1,247.83 | Win Rate: 71%
-═══════════════════════════════════════════════
-```
-
-### Real-Time Market Action
-```python
-# Live opportunity detection
-[14:31:23] 🎯 OPPORTUNITY DETECTED
-Market: NFL-WEEK18-KC-BUF
-Signal: BIG_PLAY_DIVERGENCE
-├── ESPN: 75-yard TD pass (Chiefs)
-├── Twitter: +2,341 mentions/min
-├── Kalshi: No price movement yet
-├── Edge: 8.3% (HIGH CONFIDENCE)
-└── Action: BUY 250 contracts @ $0.64
-
-[14:31:24] 📊 Executing Trade...
-├── Kelly Position: $1,250 (2.5% of capital)
-├── Order ID: ORD-2024-483921
-├── Status: PENDING → FILLED
-└── Fill Price: $0.64 ✓
-
-[14:31:28] 💰 Price Movement
-├── Market moved: $0.64 → $0.69
-├── Unrealized P&L: +$125.00
-└── Signal accuracy: CONFIRMED ✓
-```
-
----
-
-## 📊 Performance Analytics Dashboard
-
-```
-╔══════════════════════════════════════════════════════╗
-║           LIVE TRADING DASHBOARD                     ║
-╠══════════════════════════════════════════════════════╣
-║                                                       ║
-║  Portfolio Performance (24H)                         ║
-║  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░  +4.7%                      ║
-║                                                       ║
-║  Win Rate by Market Type                            ║
-║  NFL:  ▓▓▓▓▓▓▓▓▓▓▓▓▓░  72%                        ║
-║  NBA:  ▓▓▓▓▓▓▓▓▓▓░░░░  65%                        ║
-║  MLB:  ▓▓▓▓▓▓▓▓▓▓▓░░░  68%                        ║
-║                                                       ║
-║  System Health                                       ║
-║  CPU:  ▓▓▓░░░░░░░░░░░  23%                        ║
-║  MEM:  ▓▓▓▓▓░░░░░░░░░  41%                        ║
-║  NET:  ▓▓░░░░░░░░░░░░  15%                        ║
-║                                                       ║
-║  Active Strategies                                   ║
-║  • Momentum Following     [ACTIVE]  +$823          ║
-║  • Mean Reversion        [ACTIVE]  +$412          ║
-║  • Sentiment Arbitrage   [ACTIVE]  +$198          ║
-║  • Event Correlation     [PAUSED]  $0             ║
-║                                                       ║
-╚══════════════════════════════════════════════════════╝
-```
-
----
-
-## 🔮 Future Roadmap
-
-### Q1 2025: Enhanced Intelligence
-- [ ] GPT-4 Vision for game footage analysis
-- [ ] Custom transformer models for price prediction
-- [ ] Reinforcement learning for strategy optimization
-
-### Q2 2025: Market Expansion
-- [ ] Polymarket integration
-- [ ] Augur protocol support
-- [ ] Cross-market arbitrage
-
-### Q3 2025: Institutional Features
-- [ ] FIX protocol support
-- [ ] Multi-account management
-- [ ] Compliance reporting
-
-### Q4 2025: Platform as a Service
-- [ ] White-label solution
-- [ ] API for third-party strategies
-- [ ] Mobile monitoring app
-
----
-
-## 💡 Investment Highlights
-
-### Why Invest Now?
-1. **First Mover**: Early in prediction market automation
-2. **Proven System**: 187% return in backtesting
-3. **Scalable Tech**: Handles 500+ markets simultaneously
-4. **Protected IP**: Proprietary correlation algorithms
-5. **Growing Market**: 300% YoY growth in prediction markets
-
-### Use of Funds
-```
-$2M Seed Round Allocation:
-├── 40% - Engineering (ML/AI team expansion)
-├── 25% - Infrastructure (servers, data feeds)
-├── 20% - Compliance & Legal
-├── 10% - Marketing & BD
-└── 5%  - Operations
-```
-
-### Expected Returns
-```
-Conservative: 35% annual return
-Base Case:    65% annual return  
-Optimistic:   120% annual return
-
-With 2% management + 20% performance fee:
-Year 1 Revenue: $1.2M
-Year 2 Revenue: $4.8M
-Year 3 Revenue: $18M
-```
-
----
-
-## 🤝 Team & Advisors
-
-### Core Team
-- **CTO**: 15 years quantitative trading
-- **Head of AI**: Ex-DeepMind, PhD ML
-- **Lead Engineer**: Ex-Jane Street
-- **Risk Manager**: Ex-Citadel
-
-### Advisors
-- Former Head of Trading, Two Sigma
-- Professor of Statistics, MIT
-- Early investor in Polymarket
-
----
-
-## 📞 Contact & Next Steps
-
-### Live Demo Available
-See the system trade in real-time on actual markets
-
-### Documentation
-- Technical Architecture: `/docs/ARCHITECTURE.md`
-- API Documentation: `/docs/API.md`
-- Risk Framework: `/docs/RISK_MANAGEMENT.md`
-
-### Investment Inquiries
-Ready to discuss terms and provide deeper technical dive
-
----
-
-## ⚡ Quick Start Demo
-
-```bash
-# Clone and setup
-git clone [repository]
-cd Kalshi_Agentic_Agent
-
-# Install dependencies
-pip install -r requirements.txt
-
-# Configure credentials
-cp .env.example .env
-# Add your API keys
-
-# Run backtesting demo
-python scripts/run_backtest.py --mode optimize
-
-# Start live trading (paper mode)
-python scripts/run_agents.py all --paper-trading
-
-# View real-time dashboard
-open http://localhost:8080/dashboard
-```
-
----
-
-*This platform represents the future of algorithmic trading in prediction markets - combining speed, intelligence, and scale to capture opportunities invisible to human traders.*
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..d0b9fb18
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kalshi Trading SDK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/PLATFORM_ROADMAP.md b/PLATFORM_ROADMAP.md
deleted file mode 100644
index 341d96c7..00000000
--- a/PLATFORM_ROADMAP.md
+++ /dev/null
@@ -1,556 +0,0 @@
-# 🚀 Neural Trading Platform - Development Roadmap
-
-## Executive Vision
-Transform the Kalshi Trading Agent into a **universal algorithmic trading platform** where users can:
-- Plug in any data source (websockets, APIs, databases)
-- Deploy custom trading algorithms
-- Backtest strategies across multiple markets
-- Share and monetize successful strategies
-
----
-
-## 📊 Platform Evolution Phases
-
-### Phase 1: Core Infrastructure (Q1 2025)
-**Goal:** Build extensible foundation for custom components
-
-#### 1.1 Plugin Architecture
-```python
-# Example: Custom Data Source Plugin
-class CustomDataPlugin(BaseDataSource):
-    """User-defined data source"""
-    
-    async def connect(self):
-        """Connect to custom websocket/API"""
-        pass
-    
-    async def subscribe(self, symbols):
-        """Subscribe to data streams"""
-        pass
-    
-    def transform(self, raw_data):
-        """Transform to unified format"""
-        return UnifiedEvent(...)
-```
-
-#### 1.2 Strategy Framework
-```python
-# Example: Custom Trading Strategy
-class UserStrategy(BaseStrategy):
-    """User-defined trading algorithm"""
-    
-    def analyze(self, market_data, indicators):
-        """Custom analysis logic"""
-        signal = self.calculate_signal(market_data)
-        return TradingSignal(
-            action="BUY",
-            confidence=0.85,
-            size=self.kelly_sizing(signal)
-        )
-```
-
-#### 1.3 Unified Data Model
-```yaml
-# Standardized event schema
-UnifiedMarketEvent:
-  timestamp: datetime
-  source: string
-  symbol: string
-  data:
-    price: float
-    volume: float
-    bid: float
-    ask: float
-    custom_fields: dict
-```
-
-**Deliverables:**
-- [ ] Plugin system with hot-reload capability
-- [ ] Strategy SDK with examples
-- [ ] Data transformation pipeline
-- [ ] Developer documentation
-
----
-
-### Phase 2: Developer Platform (Q2 2025)
-**Goal:** Enable developers to build and test strategies
-
-#### 2.1 Visual Strategy Builder
-```
-┌─────────────────────────────────────────┐
-│        STRATEGY BUILDER UI              │
-├─────────────────────────────────────────┤
-│  [Data Sources]  →  [Indicators]  →    │
-│         ↓                ↓              │
-│  [Conditions]    →  [Actions]          │
-│         ↓                ↓              │
-│  [Risk Rules]    →  [Backtest]         │
-└─────────────────────────────────────────┘
-```
-
-#### 2.2 Backtesting as a Service
-```python
-# API for custom backtesting
-POST /api/backtest
-{
-  "strategy": "user_strategy_id",
-  "data_sources": ["kalshi", "custom_ws"],
-  "date_range": {
-    "start": "2024-01-01",
-    "end": "2024-12-31"
-  },
-  "parameters": {
-    "stop_loss": 0.10,
-    "position_size": 0.05
-  }
-}
-
-# Response
-{
-  "sharpe_ratio": 2.87,
-  "total_return": 1.87,
-  "max_drawdown": -0.124,
-  "win_rate": 0.673,
-  "report_url": "https://platform.com/report/abc123"
-}
-```
-
-#### 2.3 Strategy Marketplace
-```
-┌─────────────────────────────────────────┐
-│         STRATEGY MARKETPLACE            │
-├─────────────────────────────────────────┤
-│  Top Performers:                        │
-│  • MomentumPro     ⭐4.8  +187% return │
-│  • MeanReversion   ⭐4.6  +142% return │
-│  • EventArbitrage  ⭐4.5  +98% return  │
-│                                         │
-│  [Deploy] [Clone] [Analyze]            │
-└─────────────────────────────────────────┘
-```
-
-**Deliverables:**
-- [ ] Web-based strategy builder
-- [ ] REST API for backtesting
-- [ ] Strategy marketplace MVP
-- [ ] Performance analytics dashboard
-
----
-
-### Phase 3: Custom Data Integration (Q3 2025)
-**Goal:** Support any data source and market
-
-#### 3.1 WebSocket Adapter Framework
-```python
-# Universal WebSocket adapter
-class WebSocketAdapter:
-    def __init__(self, config):
-        self.url = config['url']
-        self.auth = config['auth']
-        self.parser = config['parser']
-    
-    async def connect(self):
-        """Auto-configure from user spec"""
-        self.ws = await websockets.connect(
-            self.url,
-            extra_headers=self.auth
-        )
-    
-    def parse_message(self, msg):
-        """User-defined parser or auto-detect"""
-        return self.parser(msg)
-```
-
-#### 3.2 Data Source Registry
-```yaml
-# User registers custom data source
-data_sources:
-  - name: "crypto_exchange"
-    type: "websocket"
-    url: "wss://stream.exchange.com"
-    auth_type: "api_key"
-    message_format: "json"
-    mappings:
-      price: "$.last_price"
-      volume: "$.24h_volume"
-      
-  - name: "news_sentiment"
-    type: "rest_api"
-    url: "https://api.news.com/sentiment"
-    poll_interval: 60
-    auth_type: "bearer_token"
-```
-
-#### 3.3 Multi-Exchange Support
-```python
-# Trade across multiple venues
-class UniversalExecutor:
-    exchanges = {
-        'kalshi': KalshiClient(),
-        'polymarket': PolymarketClient(),
-        'manifold': ManifoldClient(),
-        'custom': UserExchangeClient()
-    }
-    
-    async def execute_best(self, order):
-        """Route to best execution venue"""
-        best_price = await self.find_best_price(order)
-        return await self.exchanges[best_price.venue].execute(order)
-```
-
-**Deliverables:**
-- [ ] WebSocket adapter generator
-- [ ] REST API adapter
-- [ ] Database connectors (PostgreSQL, MongoDB)
-- [ ] Multi-exchange execution router
-
----
-
-### Phase 4: Algorithm Marketplace (Q4 2025)
-**Goal:** Create ecosystem for algorithm sharing and monetization
-
-#### 4.1 Algorithm Store
-```
-┌─────────────────────────────────────────┐
-│          ALGORITHM STORE                │
-├─────────────────────────────────────────┤
-│  Categories:                            │
-│  • Mean Reversion (45 algos)           │
-│  • Momentum (82 algos)                 │
-│  • Arbitrage (31 algos)                │
-│  • ML-Based (67 algos)                 │
-│                                         │
-│  Revenue Models:                        │
-│  • One-time purchase                   │
-│  • Subscription                        │
-│  • Profit sharing                      │
-└─────────────────────────────────────────┘
-```
-
-#### 4.2 Strategy Templates
-```python
-# Pre-built templates users can customize
-templates = {
-    'pairs_trading': PairsTradingTemplate(),
-    'momentum': MomentumTemplate(),
-    'mean_reversion': MeanReversionTemplate(),
-    'ml_prediction': MLPredictionTemplate(),
-    'event_driven': EventDrivenTemplate()
-}
-
-# User customizes template
-my_strategy = templates['momentum'].customize(
-    indicators=['RSI', 'MACD'],
-    entry_conditions={'RSI': '<30'},
-    exit_conditions={'profit': '>5%'}
-)
-```
-
-#### 4.3 Performance Verification
-```python
-# Verified performance tracking
-class PerformanceVerifier:
-    """Cryptographically verify algorithm performance"""
-    
-    def verify_backtest(self, strategy_id):
-        """Independent backtest verification"""
-        return {
-            'verified': True,
-            'hash': 'abc123...',
-            'performance': {...},
-            'certificate_url': '...'
-        }
-    
-    def track_live(self, strategy_id):
-        """Real-time performance tracking"""
-        return LivePerformanceTracker(strategy_id)
-```
-
-**Deliverables:**
-- [ ] Algorithm marketplace platform
-- [ ] Revenue sharing system
-- [ ] Performance verification service
-- [ ] Copy-trading functionality
-
----
-
-## 🛠️ Technical Implementation
-
-### Core Architecture Extensions
-
-#### 1. Plugin System Architecture
-```
-┌─────────────────────────────────────────┐
-│            PLUGIN MANAGER               │
-├─────────────────────────────────────────┤
-│                                         │
-│  Plugin Types:                          │
-│  ┌──────────┐  ┌──────────┐           │
-│  │   Data   │  │ Strategy │           │
-│  │  Source  │  │  Plugin  │           │
-│  └────┬─────┘  └────┬─────┘           │
-│       │              │                  │
-│  ┌────▼──────────────▼────┐           │
-│  │   Plugin Runtime        │           │
-│  │  • Sandboxing           │           │
-│  │  • Resource limits      │           │
-│  │  • API access control   │           │
-│  └─────────────────────────┘           │
-│                                         │
-└─────────────────────────────────────────┘
-```
-
-#### 2. Custom Algorithm API
-```python
-# Base classes for user extensions
-class CustomDataSource(ABC):
-    @abstractmethod
-    async def connect(self): pass
-    
-    @abstractmethod
-    async def subscribe(self, symbols): pass
-    
-    @abstractmethod
-    def transform(self, data): pass
-
-class CustomStrategy(ABC):
-    @abstractmethod
-    def analyze(self, data): pass
-    
-    @abstractmethod
-    def generate_signal(self, analysis): pass
-    
-    @abstractmethod
-    def calculate_position_size(self, signal): pass
-
-class CustomIndicator(ABC):
-    @abstractmethod
-    def calculate(self, data): pass
-    
-    @abstractmethod
-    def get_signal(self): pass
-```
-
-#### 3. Backtest Engine Extensions
-```python
-class UniversalBacktestEngine:
-    """Extended backtesting for any data/strategy"""
-    
-    def __init__(self):
-        self.data_sources = DataSourceRegistry()
-        self.strategies = StrategyRegistry()
-        self.validators = ValidationPipeline()
-    
-    async def backtest(self, config):
-        # Load custom data source
-        data = await self.data_sources.load(
-            config['data_source'],
-            config['date_range']
-        )
-        
-        # Load custom strategy
-        strategy = self.strategies.load(
-            config['strategy'],
-            config['parameters']
-        )
-        
-        # Run backtest with custom components
-        results = await self.run_simulation(
-            data, 
-            strategy,
-            config['capital']
-        )
-        
-        return self.generate_report(results)
-```
-
-#### 4. SDK and CLI Tools
-```bash
-# Neural Trading Platform CLI
-ntp create strategy momentum_breakout
-ntp backtest --strategy momentum_breakout --data kalshi --from 2024-01-01
-ntp deploy momentum_breakout --capital 10000 --risk-limit 0.20
-ntp monitor momentum_breakout --dashboard
-
-# SDK usage
-from ntp import Strategy, DataSource, Backtest
-
-class MyStrategy(Strategy):
-    def analyze(self, data):
-        # Custom logic
-        return signal
-
-# Register and backtest
-strategy = MyStrategy()
-backtest = Backtest(strategy, data_source="kalshi")
-results = backtest.run(start="2024-01-01", end="2024-12-31")
-```
-
----
-
-## 📈 Monetization Strategy
-
-### Revenue Streams
-
-#### 1. Platform Fees
-- **Basic:** Free tier with limited backtests
-- **Pro:** $99/month unlimited backtesting
-- **Enterprise:** $999/month with priority execution
-
-#### 2. Marketplace Commission
-- 30% commission on algorithm sales
-- 20% on subscription revenues
-- 15% on profit-sharing arrangements
-
-#### 3. Data Services
-- Premium data feeds
-- Historical data packages
-- Real-time data API access
-
-#### 4. Managed Services
-- White-label platform
-- Custom strategy development
-- Institutional deployment
-
----
-
-## 🎯 Success Metrics
-
-### Year 1 Goals
-- 1,000+ registered developers
-- 100+ custom strategies deployed
-- 50+ data sources integrated
-- $1M+ in platform transactions
-
-### Year 2 Goals
-- 10,000+ active users
-- 1,000+ algorithms in marketplace
-- 500+ data sources
-- $10M+ in platform transactions
-
-### Year 3 Goals
-- 50,000+ users
-- 5,000+ algorithms
-- Institutional adoption
-- $100M+ in platform transactions
-
----
-
-## 🔧 Implementation Timeline
-
-### Q1 2025: Foundation
-- [ ] Week 1-4: Plugin architecture design
-- [ ] Week 5-8: Strategy SDK development
-- [ ] Week 9-12: Testing and documentation
-
-### Q2 2025: Developer Tools
-- [ ] Week 1-4: Visual builder UI
-- [ ] Week 5-8: Backtesting API
-- [ ] Week 9-12: Marketplace MVP
-
-### Q3 2025: Data Integration
-- [ ] Week 1-4: WebSocket framework
-- [ ] Week 5-8: Multi-exchange support
-- [ ] Week 9-12: Testing and optimization
-
-### Q4 2025: Marketplace Launch
-- [ ] Week 1-4: Algorithm store
-- [ ] Week 5-8: Performance verification
-- [ ] Week 9-12: Marketing and launch
-
----
-
-## 🚀 Quick Wins (Next 30 Days)
-
-### 1. Create Plugin Interface
-```python
-# Simple plugin interface to start
-class PluginInterface:
-    def initialize(self, config): pass
-    def process(self, data): pass
-    def cleanup(self): pass
-```
-
-### 2. Add Custom Strategy Support
-```python
-# Allow users to drop in Python files
-strategies/
-  ├── user_strategy_1.py
-  ├── user_strategy_2.py
-  └── user_strategy_3.py
-```
-
-### 3. Extend Backtest Engine
-```python
-# Support custom data formats
-backtest.add_data_source(
-    CSVDataSource("historical_data.csv")
-)
-```
-
-### 4. Create Developer Docs
-- Getting started guide
-- API reference
-- Example strategies
-- Video tutorials
-
----
-
-## 🎨 Platform Features Comparison
-
-| Feature | Current | Phase 1 | Phase 2 | Phase 3 | Phase 4 |
-|---------|---------|---------|---------|---------|---------|
-| Data Sources | Kalshi, ESPN, Twitter | +5 sources | +20 sources | Any WebSocket/API | Unlimited |
-| Custom Strategies | No | Yes (code) | Yes (visual) | Templates | Marketplace |
-| Backtesting | Built-in | API access | Cloud-based | Distributed | Verified |
-| Markets | Kalshi only | 3 exchanges | 10 exchanges | Any exchange | Universal |
-| Users | Single | Team | Organization | Public | Ecosystem |
-| Revenue Model | Trading | SaaS | Platform fees | Marketplace | Full ecosystem |
-
----
-
-## 🌟 Competitive Advantages
-
-### Why This Platform Will Win
-
-1. **Open Architecture**
-   - Unlike QuantConnect: Not locked to specific brokers
-   - Unlike TradingView: Full algorithmic capabilities
-   - Unlike MT4/MT5: Modern tech stack and AI
-
-2. **Network Effects**
-   - More strategies → More users
-   - More users → More data sources
-   - More data → Better strategies
-
-3. **Developer-First**
-   - Excellent documentation
-   - Simple SDK
-   - Active community
-   - Revenue sharing
-
-4. **Technology Edge**
-   - Sub-100ms latency
-   - Distributed backtesting
-   - AI/ML integration
-   - Cloud-native architecture
-
----
-
-## 📞 Next Steps
-
-### Immediate Actions
-1. **Technical Design**: Finalize plugin architecture
-2. **Community Building**: Launch developer forum
-3. **Partnerships**: Connect with data providers
-4. **Funding**: Raise Series A for platform development
-
-### Contact for Collaboration
-- **Developers**: Join our beta program
-- **Data Providers**: Partner with us
-- **Investors**: Fund the future of algo trading
-- **Traders**: Test early access features
-
----
-
-*The Neural Trading Platform will democratize algorithmic trading by providing institutional-grade infrastructure to every developer and trader.*
\ No newline at end of file
diff --git a/README.md b/README.md
index b2362cda..17a2c1c2 100644
--- a/README.md
+++ b/README.md
@@ -1,332 +1,249 @@
-# 🏈 Neural Trading Platform - Autonomous Sports Event Trading
+# 🧠 Neural SDK
 
-> **Real-time algorithmic trading system for Kalshi sports prediction markets**  
-> Monitors multiple data sources • Detects market inefficiencies • Executes trades in <3 seconds
+> **Open-source Python SDK for algorithmic prediction market trading**  
+> Build sophisticated trading strategies with real-time data streaming and comprehensive backtesting
 
-
-## 🎯 What This Does
-
-This platform automatically trades sports prediction markets on Kalshi by detecting and exploiting information asymmetries faster than human traders.
-
-### Real Example
-```
-18:35:22 - ESPN: "Touchdown Chiefs! Mahomes 45-yard pass"
-18:35:22 - Platform detects event (100ms)
-18:35:22 - Checks Kalshi price: still at 0.65 (hasn't moved)
-18:35:23 - Places BUY order: 1,923 shares @ 0.65
-18:35:24 - Order filled
-18:35:37 - Kalshi price moves to 0.70
-18:35:37 - Profit: +7.7% in 15 seconds
-```
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![PyPI version](https://badge.fury.io/py/neural-sdk.svg)](https://badge.fury.io/py/neural-sdk)
 
 ## 🚀 Quick Start
 
-### Prerequisites
-- Python 3.10+
-- Redis server
-- Kalshi account (for live trading)
-- Free API keys for data sources
+### Installation
 
-### 1. Clone & Setup
 ```bash
-git clone https://github.com/IntelIP/Neural-Trading-Platform.git
-cd Neural-Trading-Platform
-pip install -r requirements.txt
-```
+pip install neural-sdk
 
-### 2. Configure APIs
-Create `.env` file:
-```bash
-# Trading (required for live trading)
-KALSHI_API_KEY_ID=your_key_id
-KALSHI_API_KEY=your_api_key
-
-# Data Sources (weather API included free)
-OPENWEATHER_API_KEY=78596505b0f5fea89e98ebcbf3bd6e21  # Working key
-REDDIT_CLIENT_ID=your_reddit_id         # Optional
-REDDIT_CLIENT_SECRET=your_reddit_secret # Optional
+# Or install from GitHub
+pip install git+https://github.com/IntelIP/kalshi.git@feat/synthetic-training-integration
 ```
 
-### 3. Start Redis
-```bash
-# macOS
-brew install redis && brew services start redis
+### Basic Usage
 
-# Linux
-sudo apt-get install redis-server && sudo systemctl start redis
+```python
+from neural_sdk import NeuralSDK
 
-# Verify
-redis-cli ping  # Should return PONG
-```
+# Initialize SDK
+sdk = NeuralSDK.from_env()
 
-### 4. Test the System
-```bash
-# Test weather monitoring (working API included)
-python scripts/quick_weather_demo.py
+# Create a simple strategy
+@sdk.strategy
+async def momentum_strategy(market_data):
+    for symbol, price in market_data.prices.items():
+        if 'NFL' in symbol and price < 0.3:
+            return sdk.create_signal('BUY', symbol, size=100)
 
-# Full SDK demo
-python scripts/demo_sdk.py
+# Start trading
+await sdk.start_trading()
+```
 
-# Paper trading mode
-python scripts/run_agents.py --paper-trading
+### Backtesting
+
+```python
+from neural_sdk.backtesting import BacktestEngine, BacktestConfig
+
+# Configure backtest
+config = BacktestConfig(
+    start_date="2024-01-01",
+    end_date="2024-12-31", 
+    initial_capital=10000
+)
+
+# Run backtest
+engine = BacktestEngine(config)
+engine.add_strategy(my_strategy)
+engine.load_data("csv", path="historical_data.csv")
+
+results = engine.run()
+print(f"Total Return: {results.total_return:.2f}%")
+print(f"Sharpe Ratio: {results.metrics['sharpe_ratio']:.3f}")
 ```
 
-## 🏗️ How It Works
+## 🏗️ Architecture
 
 ```mermaid
 graph LR
     A[Data Sources] --> B[SDK Adapters]
-    B --> C[Redis Pub/Sub]
-    C --> D[Trading Agents]
-    D --> E[Kalshi API]
+    B --> C[Strategy Engine]
+    C --> D[Kalshi API]
     
-    A1[DraftKings<br/>Odds] --> B
-    A2[Weather<br/>Conditions] --> B
-    A3[Reddit<br/>Sentiment] --> B
-    A4[ESPN<br/>GameCast] --> B
+    A1[Weather API] --> B
+    A2[Reddit Sentiment] --> B
+    A3[Sports APIs] --> B
     
-    D1[DataCoordinator] --> D
-    D2[StrategyAnalyst] --> D
-    D3[TradeExecutor] --> D
-    D4[RiskManager] --> D
+    E[Backtesting Engine] --> F[Performance Analytics]
 ```
 
-### Data Flow Timeline
-| Step | Component | Latency | Action |
-|------|-----------|---------|--------|
-| 1 | ESPN GameCast | 0ms | "Touchdown!" event detected |
-| 2 | SDK Adapter | +100ms | Converts to StandardizedEvent |
-| 3 | Redis Pub/Sub | +10ms | Distributes to subscribers |
-| 4 | DataCoordinator | +200ms | Correlates with Kalshi price |
-| 5 | StrategyAnalyst | +300ms | Calculates expected move |
-| 6 | TradeExecutor | +200ms | Places order via API |
-| **Total** | **End-to-end** | **810ms** | **Sub-second execution** |
+## 📊 Features
 
-## 📊 Data Source SDK
+### Core Trading
+- **Real-time market data** streaming from multiple sources
+- **Strategy framework** with easy-to-use decorators
+- **Risk management** with position limits and stop-losses
+- **Order execution** with realistic slippage simulation
 
-The platform's edge comes from its modular Data Source SDK that makes adding new data sources trivial:
+### Backtesting
+- **Event-driven engine** for accurate historical testing
+- **Multiple data sources**: CSV, Parquet, SQL, S3
+- **Performance metrics**: Sharpe ratio, drawdown, win rate
+- **Portfolio simulation** with realistic costs and slippage
 
-### Currently Implemented
+### Data Integration
+- **Plugin architecture** for custom data sources
+- **Built-in adapters** for weather, Reddit, sports APIs
+- **Data caching** for improved performance
+- **Format standardization** across all sources
 
-| Source | Status | Latency | Purpose | API Required |
-|--------|--------|---------|---------|--------------|
-| **Weather** | ✅ Working | 2s | Wind/rain affects scoring | Included (free) |
-| **DraftKings** | ✅ Ready | 500ms | Sharp money movements | None (public) |
-| **Reddit** | ⚙️ Configured | 2-5s | Sentiment extremes | Yes (free) |
-| **ESPN** | 🔄 Planned | 1-2s | Official game events | Development |
+## 🛠️ Data Sources
 
-### Add Your Own Source (50 lines)
-```python
-from src.sdk import DataSourceAdapter, StandardizedEvent, EventType
+| Source | Status | Purpose | Setup |
+|--------|--------|---------|-------|
+| **Weather API** | ✅ Ready | Weather impacts on sports | Free API key |
+| **Reddit** | ✅ Ready | Sentiment analysis | Free API credentials |
+| **Custom CSV** | ✅ Ready | Historical data | Local files |
+| **Parquet** | ✅ Ready | High-performance data | S3 or local |
+| **PostgreSQL** | ⚙️ Optional | Large datasets | Database connection |
 
-class MyAdapter(DataSourceAdapter):
-    async def connect(self):
-        self.client = YourAPIClient(self.config['api_key'])
-        return await self.client.connect()
-    
-    async def stream(self):
-        while self.is_connected:
-            data = await self.fetch_data()
-            
-            # Detect trading opportunity
-            if self.is_significant(data):
-                yield StandardizedEvent(
-                    source="MySource",
-                    event_type=EventType.CUSTOM,
-                    data=data,
-                    confidence=0.85,
-                    impact="high"
-                )
-            
-            await asyncio.sleep(self.config['interval'])
+## 📈 Strategy Examples
+
+### Momentum Strategy
+```python
+def momentum_strategy(market_data):
+    \"\"\"Buy markets trending upward below 60 cents\"\"\"
+    for symbol, price in market_data.prices.items():
+        if price < 0.6 and market_data.is_trending_up(symbol):
+            return {'action': 'BUY', 'symbol': symbol, 'size': 50}
 ```
 
-## 🤖 Trading Intelligence
+### Mean Reversion
+```python  
+def mean_reversion_strategy(market_data):
+    \"\"\"Buy undervalued markets, sell overvalued\"\"\"
+    for symbol, price in market_data.prices.items():
+        if price < 0.3:  # Undervalued
+            return {'action': 'BUY', 'symbol': symbol, 'size': 100}
+        elif price > 0.7:  # Overvalued  
+            return {'action': 'SELL', 'symbol': symbol, 'size': 100}
+```
 
-### Signal Generation
-The platform correlates events across sources to identify opportunities:
+## 🔧 Configuration
 
-```python
-# Example: Weather + Odds Correlation
-if weather.wind_speed > 20 and not draftkings.total_moved:
-    signal = Signal(
-        action="BET_UNDER",
-        confidence=0.75,
-        edge=0.04,  # 4% expected value
-        reason="High wind not priced into total"
-    )
+### Environment Setup
+```bash
+# Create .env file
+NEURAL_API_KEY_ID=your_neural_api_key
+NEURAL_PRIVATE_KEY_FILE=./keys/neural_private.key
+
+# Optional: Data source APIs
+OPENWEATHER_API_KEY=your_weather_key
+REDDIT_CLIENT_ID=your_reddit_id
+REDDIT_CLIENT_SECRET=your_reddit_secret
 ```
 
-### Position Sizing (Kelly Criterion)
+### SDK Configuration
 ```python
-# Never use full Kelly - too risky
-position = kelly_fraction * 0.25  # 25% of Kelly
-position = min(position, 0.05 * capital)  # Max 5% per trade
+from neural_sdk import SDKConfig
+
+config = SDKConfig(
+    max_position_size=0.05,  # Max 5% per position
+    daily_loss_limit=0.20,   # Stop at 20% daily loss
+    commission=0.02,         # Kalshi's 2% fee
+    slippage=0.01           # 1% estimated slippage
+)
+
+sdk = KalshiSDK(config)
 ```
 
-### Risk Management
-- **Stop Loss**: -5% automatic exit
-- **Daily Limit**: -20% circuit breaker
-- **Correlation Check**: Reduce correlated positions
-- **Max Positions**: 10 concurrent trades
+## 📚 Documentation
 
-## 📈 Performance Metrics
+| Document | Description |
+|----------|-------------|
+| [**Getting Started**](docs/getting_started.md) | Installation and first strategy |
+| [**API Reference**](docs/api_reference.md) | Complete SDK documentation |
+| [**Backtesting Guide**](docs/backtesting.md) | Historical testing framework |
+| [**Data Sources**](docs/data_sources.md) | Setting up data feeds |
+| [**Strategy Development**](docs/strategies.md) | Building trading algorithms |
 
-### Backtested Results (30 days)
-| Metric | Value | Target |
-|--------|-------|--------|
-| **Win Rate** | 67.3% | >65% |
-| **Sharpe Ratio** | 2.14 | >2.0 |
-| **Avg Return/Trade** | +1.8% | >1.5% |
-| **Max Drawdown** | -18.2% | <20% |
-| **Trades/Day** | 12 | 10-20 |
+## 🧪 Testing
 
-### Live Performance Tracking
 ```bash
-# Monitor real-time performance
-python scripts/monitor_performance.py
+# Run all tests
+pytest tests/
 
-# Run backtest on strategy
-python scripts/run_backtest.py --strategy sharp_money --days 30
-```
+# Run specific test suite  
+pytest tests/unit/test_backtesting.py
 
-## 🎮 Configuration Examples
-
-### Monitor Specific Game
-```yaml
-# config/game_config.yaml
-game_monitoring:
-  mode: "single_game"
-  game:
-    sport: "NFL"
-    home_team: "Kansas City Chiefs"
-    away_team: "Buffalo Bills"
-    
-  kalshi_markets:
-    - "NFL-KC-BUF-WINNER"
-    - "NFL-KC-BUF-TOTAL"
+# Run with coverage
+pytest --cov=kalshi_trading_sdk tests/
 ```
 
-### Weather Impact Settings
-```yaml
-# config/data_sources.yaml
-weather:
-  enabled: true
-  thresholds:
-    wind_speed: 15      # mph - affects passing
-    precipitation: 0.1   # in/hr - affects scoring
-```
+## 📊 Performance Metrics
 
-## 🧪 Testing
+The SDK calculates comprehensive metrics for strategy evaluation:
 
-```bash
-# Unit tests
-pytest tests/unit/
+- **Return Metrics**: Total return, CAGR, Sharpe ratio
+- **Risk Metrics**: Max drawdown, volatility, VaR
+- **Trade Analysis**: Win rate, average win/loss, profit factor
+- **Time Analysis**: Best/worst days, consecutive wins/losses
 
-# Integration tests
-pytest tests/integration/
+## 🌟 Example Results
 
-# Test specific adapter
-python scripts/test_weather_adapter.py
-
-# Load testing
-python tests/load/stress_test.py
+```
+BACKTEST RESULTS
+================
+Period: 2024-01-01 to 2024-12-31
+Initial Capital: $10,000.00
+Final Value: $12,750.00
+
+Total Return: +27.5%
+Sharpe Ratio: 1.85
+Max Drawdown: -8.2%
+Win Rate: 68.5%
+Total Trades: 156
 ```
 
-## 📚 Documentation
+## 🤝 Contributing
 
-| Document | Description |
-|----------|-------------|
-| [Getting Started](docs/GETTING_STARTED.md) | Installation and first trade |
-| [System Overview](docs/SYSTEM_OVERVIEW.md) | Architecture deep dive |
-| [SDK Documentation](docs/SDK_DOCUMENTATION.md) | Build custom adapters |
-| [Trading Logic](docs/TRADING_LOGIC.md) | How decisions are made |
-| [Data Sources Guide](docs/DATA_SOURCES_GUIDE.md) | Configure each source |
-
-## 🚦 Project Status
-
-### ✅ Completed
-- Data Source SDK framework
-- Weather monitoring (OpenWeatherMap API)
-- DraftKings odds adapter
-- Reddit sentiment adapter
-- Redis pub/sub message bus
-- Kelly Criterion position sizing
-- Risk management system
-- Comprehensive documentation
-
-### 🔄 In Development
-- ESPN GameCast integration
-- Machine learning signal enhancement
-- Multi-sport expansion (NBA, MLB)
-
-### 📅 Roadmap
-- Q4 2024: Production deployment
-- Q1 2025: ML model integration
-- Q2 2025: Mobile monitoring app
-
-## 🛠️ Tech Stack
-
-- **Python 3.10+** - Async/await for speed
-- **Redis** - 10,000 msg/sec pub/sub
-- **Agentuity** - Agent orchestration
-- **aiohttp** - Async HTTP client
-- **asyncpraw** - Reddit streaming
-- **pandas/numpy** - Data analysis
-- **TextBlob** - Sentiment analysis
-
-## 📊 System Requirements
-
-### Minimum (Development)
-- 2 CPU cores
-- 4 GB RAM
-- 10 GB storage
-- 10 Mbps internet
-
-### Recommended (Production)
-- 4+ CPU cores
-- 8 GB RAM
-- 50 GB SSD
-- 100 Mbps internet
-- Redis dedicated instance
+We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
-## 🤝 Contributing
+### Development Setup
+```bash
+git clone https://github.com/neural/neural-sdk.git
+cd neural-sdk
 
-We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+# Install development dependencies
+pip install -e ".[dev]"
 
-### Areas Needing Help
-- ESPN WebSocket integration
-- Additional sports adapters
-- ML model development
-- Performance optimization
+# Run pre-commit hooks
+pre-commit install
+```
 
-## 📝 License
+## 📄 License
 
-MIT License - see [LICENSE](LICENSE) file
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
 ## ⚠️ Disclaimer
 
-**IMPORTANT**: This software is for educational purposes. Sports event trading involves significant risk of loss. 
+**Important**: This software is for educational and research purposes. Trading involves substantial risk of loss. 
 
 - Always start with paper trading
-- Never risk more than you can afford to lose
+- Never risk more than you can afford to lose  
 - Past performance doesn't guarantee future results
-- The platform is not financial advice
+- The SDK is not financial advice
 
-## 🏆 Acknowledgments
+## 🔗 Links
 
-- Kalshi for providing the trading platform
-- OpenWeatherMap for weather data (API key included)
-- Reddit community for sentiment data
-- DraftKings for odds reference data
+- **Documentation**: [https://kalshi-trading-sdk.readthedocs.io/](https://kalshi-trading-sdk.readthedocs.io/)
+- **PyPI Package**: [https://pypi.org/project/kalshi-trading-sdk/](https://pypi.org/project/kalshi-trading-sdk/)
+- **Issues**: [https://github.com/kalshi/kalshi-trading-sdk/issues](https://github.com/kalshi/kalshi-trading-sdk/issues)
+- **Discussions**: [https://github.com/kalshi/kalshi-trading-sdk/discussions](https://github.com/kalshi/kalshi-trading-sdk/discussions)
 
-## 📞 Support
+## 🏆 Acknowledgments
 
-- 📖 [Documentation](docs/)
-- 💬 [GitHub Issues](https://github.com/IntelIP/Neural-Trading-Platform/issues)
-- 📧 Contact: [your-email]
+- Kalshi for providing the trading platform
+- Contributors and beta testers
+- Open source community for excellent libraries
 
 ---
 
-**Built for algorithmic trading**  
-*Trade responsibly. Speed matters. Edge wins.*
\ No newline at end of file
+**Built for algorithmic trading • Trade responsibly • Performance matters**
\ No newline at end of file
diff --git a/config/data_sources.yaml b/config/data_sources.yaml
index 04f8a009..1dd43fcd 100644
--- a/config/data_sources.yaml
+++ b/config/data_sources.yaml
@@ -6,7 +6,7 @@ sources:
   - name: draftkings
     enabled: true
     class: DraftKingsAdapter
-    module: src.sdk.adapters.draftkings
+    module: sdk.adapters.draftkings
     priority: 1  # Higher priority = processed first
     config:
       sports:
@@ -20,7 +20,7 @@ sources:
   - name: reddit
     enabled: false  # Enable after adding credentials
     class: RedditAdapter
-    module: src.sdk.adapters.reddit
+    module: sdk.adapters.reddit
     priority: 2
     config:
       client_id: ${REDDIT_CLIENT_ID}
@@ -37,14 +37,30 @@ sources:
         injury: ["injury", "injured", "hurt", "down"]
         big_play: ["holy shit", "wow", "incredible"]
   
+  # ESPN Play-by-Play Data
+  - name: espn
+    enabled: true  # No API key needed - completely free!
+    class: ESPNAdapter
+    module: sdk.adapters.espn
+    priority: 1  # High priority for real-time game events
+    config:
+      sports:
+        - nfl
+        - nba
+      update_interval: 5  # Base polling interval in seconds
+      critical_interval: 3  # Interval during critical game moments
+      # Optional: Monitor specific games by ID
+      # games:
+      #   - "401547652"
+  
   # Weather Conditions
   - name: weather
     enabled: true  # API key is working!
     class: WeatherAdapter
-    module: src.sdk.adapters.weather
+    module: sdk.adapters.weather
     priority: 3
     config:
-      api_key: 78596505b0f5fea89e98ebcbf3bd6e21  # Your working API key
+      api_key: ${OPENWEATHER_API_KEY}
       update_interval: 300  # 5 minutes
       thresholds:
         wind_speed: 15  # mph
@@ -73,4 +89,4 @@ settings:
   event_queue_size: 10000
   max_adapters: 10
   health_check_interval: 60  # seconds
-  log_level: INFO
\ No newline at end of file
+  log_level: INFO
diff --git a/config/environments/development.yaml b/config/environments/development.yaml
new file mode 100644
index 00000000..ed2d5640
--- /dev/null
+++ b/config/environments/development.yaml
@@ -0,0 +1,87 @@
+# Development Environment Configuration
+# For local development and testing
+
+name: "Development"
+environment: "development"
+redis_db: 4
+redis_prefix: "dev:"
+
+api_endpoints:
+  kalshi: "http://localhost:8000/mock/kalshi"
+  odds: "http://localhost:8001/mock/odds"
+  sportsdata: "http://localhost:8002/mock/sportsdata"
+  twitter: "http://localhost:8003/mock/twitter"
+
+rate_limits:
+  kalshi: 100000
+  odds: 100000
+  sportsdata: 100000
+  twitter: 100000
+
+# Safety and Security
+safety_checks: false
+require_confirmation: false
+require_mfa: false
+
+# Allowed Operations
+allowed_operations:
+  - "*"  # All operations allowed in development
+
+# Restricted Operations
+restricted_operations: []  # No restrictions in development
+
+# Data Management
+data_retention_hours: 1  # Minimal retention
+backup_enabled: false
+backup_frequency_hours: 0
+
+# Trading Limits (No limits for development)
+max_position_size: 1.0
+max_daily_trades: 100000
+max_concurrent_positions: 10000
+max_order_value: 10000000.0
+min_order_value: 0.001
+
+# Risk Management (Disabled for development)
+stop_loss_percentage: 1.0
+max_drawdown_percentage: 1.0
+position_sizing_method: "fixed"
+kelly_fraction: 1.0
+
+# Logging and Monitoring
+enable_logging: true
+log_level: "DEBUG"
+telemetry_enabled: false
+alert_enabled: false
+alert_channels: []
+
+# Feature Flags
+features:
+  auto_trading: true
+  paper_trading: true
+  backtesting: true
+  synthetic_data: true
+  debug_mode: true
+  performance_profiling: true
+  real_time_analytics: false
+  emergency_stop: false
+  development_mode: true
+  hot_reload: true
+  mock_apis: true
+  verbose_logging: true
+  
+# Development Specific Settings
+development:
+  auto_reload: true
+  debug_toolbar: true
+  sql_echo: true
+  mock_delay_ms: 0
+  bypass_cache: true
+  show_stack_traces: true
+  
+# Monitoring Thresholds (Disabled for development)
+monitoring:
+  latency_threshold_ms: 10000
+  error_rate_threshold: 1.0
+  memory_threshold_gb: 16
+  cpu_threshold_percent: 100
\ No newline at end of file
diff --git a/config/environments/production.yaml b/config/environments/production.yaml
new file mode 100644
index 00000000..d2d9bf97
--- /dev/null
+++ b/config/environments/production.yaml
@@ -0,0 +1,86 @@
+# Production Environment Configuration
+# CRITICAL: This configuration is for LIVE TRADING with REAL MONEY
+
+name: "Production"
+environment: "production"
+redis_db: 0
+redis_prefix: "prod:"
+
+api_endpoints:
+  kalshi: "https://api.kalshi.com"
+  odds: "https://api.theoddsapi.com/v4"
+  sportsdata: "https://api.sportsdata.io/v3/nfl"
+  twitter: "https://api.twitter.com/2"
+
+rate_limits:
+  kalshi: 100
+  odds: 50
+  sportsdata: 100
+  twitter: 300
+
+# Safety and Security
+safety_checks: true
+require_confirmation: true
+require_mfa: true
+
+# Allowed Operations
+allowed_operations:
+  - "place_order"
+  - "cancel_order"
+  - "get_positions"
+  - "get_markets"
+  - "get_account"
+  - "analyze_market"
+  - "calculate_kelly"
+
+# Restricted Operations
+restricted_operations:
+  - "delete_all_data"
+  - "reset_account"
+  - "modify_system_config"
+  - "bypass_risk_checks"
+
+# Data Management
+data_retention_hours: 720  # 30 days
+backup_enabled: true
+backup_frequency_hours: 24
+
+# Trading Limits
+max_position_size: 0.05  # 5% of portfolio
+max_daily_trades: 20
+max_concurrent_positions: 10
+max_order_value: 1000.0
+min_order_value: 1.0
+
+# Risk Management
+stop_loss_percentage: 0.10
+max_drawdown_percentage: 0.20
+position_sizing_method: "kelly_fraction"
+kelly_fraction: 0.25
+
+# Logging and Monitoring
+enable_logging: true
+log_level: "INFO"
+telemetry_enabled: true
+alert_enabled: true
+alert_channels:
+  - "email"
+  - "slack"
+
+# Feature Flags
+features:
+  auto_trading: true
+  paper_trading: false
+  backtesting: false
+  synthetic_data: false
+  debug_mode: false
+  performance_profiling: true
+  real_time_analytics: true
+  emergency_stop: true
+  
+# Monitoring Thresholds
+monitoring:
+  latency_threshold_ms: 1000
+  error_rate_threshold: 0.01
+  memory_threshold_gb: 4
+  cpu_threshold_percent: 80
\ No newline at end of file
diff --git a/config/environments/sandbox.yaml b/config/environments/sandbox.yaml
new file mode 100644
index 00000000..9f44e836
--- /dev/null
+++ b/config/environments/sandbox.yaml
@@ -0,0 +1,86 @@
+# Sandbox Environment Configuration
+# For testing with demo APIs and safe experimentation
+
+name: "Sandbox"
+environment: "sandbox"
+redis_db: 2
+redis_prefix: "sandbox:"
+
+api_endpoints:
+  kalshi: "https://demo-api.kalshi.co"
+  odds: "https://api.theoddsapi.com/v4"
+  sportsdata: "https://api.sportsdata.io/v3/nfl"
+  twitter: "https://api.twitter.com/2"
+
+rate_limits:
+  kalshi: 500
+  odds: 200
+  sportsdata: 200
+  twitter: 500
+
+# Safety and Security
+safety_checks: true
+require_confirmation: false
+require_mfa: false
+
+# Allowed Operations
+allowed_operations:
+  - "*"  # All operations allowed in sandbox
+
+# Restricted Operations
+restricted_operations:
+  - "delete_production_data"
+  - "modify_production_config"
+
+# Data Management
+data_retention_hours: 24  # 1 day retention
+backup_enabled: false
+backup_frequency_hours: 0
+
+# Trading Limits (Moderate for sandbox)
+max_position_size: 0.20  # 20% of portfolio
+max_daily_trades: 100
+max_concurrent_positions: 50
+max_order_value: 10000.0
+min_order_value: 0.10
+
+# Risk Management
+stop_loss_percentage: 0.20
+max_drawdown_percentage: 0.40
+position_sizing_method: "kelly_fraction"
+kelly_fraction: 0.50
+
+# Logging and Monitoring
+enable_logging: true
+log_level: "DEBUG"
+telemetry_enabled: false
+alert_enabled: false
+alert_channels: []
+
+# Feature Flags
+features:
+  auto_trading: true
+  paper_trading: true
+  backtesting: true
+  synthetic_data: false
+  debug_mode: true
+  performance_profiling: true
+  real_time_analytics: true
+  emergency_stop: true
+  sandbox_mode: true
+  api_mocking: true
+  
+# Sandbox Specific Settings
+sandbox:
+  reset_daily: true
+  demo_balance: 10000.0
+  unlimited_retries: true
+  skip_authentication: false
+  mock_latency_ms: 100
+  
+# Monitoring Thresholds
+monitoring:
+  latency_threshold_ms: 2000
+  error_rate_threshold: 0.05
+  memory_threshold_gb: 4
+  cpu_threshold_percent: 90
\ No newline at end of file
diff --git a/config/environments/training.yaml b/config/environments/training.yaml
new file mode 100644
index 00000000..8842409b
--- /dev/null
+++ b/config/environments/training.yaml
@@ -0,0 +1,96 @@
+# Training Environment Configuration
+# For agent training with synthetic data
+
+name: "Training"
+environment: "training"
+redis_db: 3
+redis_prefix: "training:"
+
+api_endpoints:
+  kalshi: "http://localhost:8000/mock/kalshi"
+  odds: "http://localhost:8001/mock/odds"
+  sportsdata: "http://localhost:8002/mock/sportsdata"
+  twitter: "http://localhost:8003/mock/twitter"
+
+rate_limits:
+  kalshi: 10000
+  odds: 10000
+  sportsdata: 10000
+  twitter: 10000
+
+# Safety and Security
+safety_checks: false
+require_confirmation: false
+require_mfa: false
+
+# Allowed Operations
+allowed_operations:
+  - "*"  # All operations allowed in training
+
+# Restricted Operations
+restricted_operations: []  # No restrictions in training
+
+# Data Management
+data_retention_hours: 4  # Short retention for training data
+backup_enabled: false
+backup_frequency_hours: 0
+
+# Trading Limits (Relaxed for training)
+max_position_size: 1.0  # 100% allowed for training
+max_daily_trades: 10000
+max_concurrent_positions: 1000
+max_order_value: 1000000.0
+min_order_value: 0.01
+
+# Risk Management (Configurable for training)
+stop_loss_percentage: 0.50
+max_drawdown_percentage: 1.0
+position_sizing_method: "kelly_fraction"
+kelly_fraction: 1.0  # Full Kelly for training experiments
+
+# Logging and Monitoring
+enable_logging: true
+log_level: "DEBUG"
+telemetry_enabled: false
+alert_enabled: false
+alert_channels: []
+
+# Feature Flags
+features:
+  auto_trading: true
+  paper_trading: true
+  backtesting: true
+  synthetic_data: true
+  debug_mode: true
+  performance_profiling: true
+  real_time_analytics: false
+  emergency_stop: false
+  training_mode: true
+  exploration_mode: true
+  replay_mode: true
+  
+# Training Specific Settings
+training:
+  scenario_generation: true
+  adaptive_difficulty: true
+  performance_tracking: true
+  decision_replay: true
+  confidence_calibration: true
+  memory_system: true
+  batch_size: 32
+  learning_rate: 0.001
+  
+# Synthetic Data Settings
+synthetic_data:
+  generation_enabled: true
+  realistic_timing: true
+  market_reaction_simulation: true
+  price_impact_modeling: true
+  volatility_injection: true
+  
+# Monitoring Thresholds (Relaxed for training)
+monitoring:
+  latency_threshold_ms: 5000
+  error_rate_threshold: 0.10
+  memory_threshold_gb: 8
+  cpu_threshold_percent: 95
\ No newline at end of file
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 00000000..3a63b70b
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,23 @@
+version: "3.9"
+
+services:
+  redis:
+    image: redis:7-alpine
+    container_name: neural_redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    command: ["redis-server", "--appendonly", "yes"]
+
+  app:
+    build: .
+    depends_on:
+      - redis
+    env_file:
+      - .env
+    command: ["python", "-c", "import neural_sdk; print('Neural SDK ready with env')"]
+
+volumes:
+  redis_data:
+
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 6d8a9e10..5ad19a7a 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -1,7 +1,7 @@
-# Kalshi Trading Agent Architecture
+# Neural Trading Agent Architecture
 
 ## Overview
-A practical multi-agent system for automated sports betting on Kalshi, with clear separation between always-on monitoring agents and on-demand analysis agents.
+A practical multi-agent system for automated sports betting on Neural, with clear separation between always-on monitoring agents and on-demand analysis agents.
 
 ## Agent Types
 
@@ -13,7 +13,7 @@ A practical multi-agent system for automated sports betting on Kalshi, with clea
 **Responsibilities:**
 - Monitor ESPN for live games and scores
 - Track Twitter sentiment in real-time
-- Watch Kalshi market prices and volumes
+- Watch Neural market prices and volumes
 - Store historical data for analysis
 - Detect anomalies and significant events
 
@@ -36,8 +36,8 @@ class DataCollectionAgent:
             # Monitor Twitter
             sentiment = await self.consume_twitter_stream()
             
-            # Monitor Kalshi
-            markets = await self.consume_kalshi_stream()
+            # Monitor Neural
+            markets = await self.consume_neural_stream()
             
             # Detect triggers
             if self.detect_opportunity(espn_data, sentiment, markets):
@@ -110,7 +110,7 @@ class GameAnalystAgent:
         injuries = await self.get_injury_report(teams)
         
         # 3. Market Analysis
-        market_data = await self.get_kalshi_markets(game_id)
+        market_data = await self.get_neural_markets(game_id)
         implied_prob = self.calculate_implied_probability(market_data)
         
         # 4. Sentiment Analysis
@@ -408,7 +408,7 @@ data_collector:
   enabled: true
   mode: always_on
   redis_channels:
-    - kalshi:markets
+    - neural:markets
     - espn:games
     - twitter:sentiment
   
diff --git a/docs/DATA_SOURCES_GUIDE.md b/docs/DATA_SOURCES_GUIDE.md
index f7368261..9fe679ce 100644
--- a/docs/DATA_SOURCES_GUIDE.md
+++ b/docs/DATA_SOURCES_GUIDE.md
@@ -10,7 +10,7 @@ Each data source provides unique alpha for trading decisions. This guide explain
 
 ### 1. DraftKings Sportsbook
 
-**Purpose**: Professional odds movements often lead Kalshi markets by 5-30 seconds
+**Purpose**: Professional odds movements often lead Neural markets by 5-30 seconds
 
 **What It Provides**:
 - Real-time odds for all major sports
diff --git a/docs/GAME_CONFIGURATION_GUIDE.md b/docs/GAME_CONFIGURATION_GUIDE.md
index 3a59c81c..05c5a5f2 100644
--- a/docs/GAME_CONFIGURATION_GUIDE.md
+++ b/docs/GAME_CONFIGURATION_GUIDE.md
@@ -24,8 +24,8 @@ game_monitoring:
     start_time: "2024-01-21T18:30:00Z"
     venue: "Arrowhead Stadium"
     
-  # Kalshi markets to trade
-  kalshi_markets:
+  # Neural markets to trade
+  neural_markets:
     - "NFL-KC-BUF-WINNER"
     - "NFL-KC-BUF-SPREAD"
     - "NFL-KC-BUF-TOTAL"
@@ -213,7 +213,7 @@ auto_discovery:
   
   # Find games with these criteria
   criteria:
-    min_kalshi_volume: 10000  # Minimum liquidity
+    min_neural_volume: 10000  # Minimum liquidity
     min_edge_required: 0.03   # 3% edge
     sports: ["NFL", "NBA"]
     
@@ -586,7 +586,7 @@ def validate_game_config(config):
     errors = []
     
     # Check required fields
-    required = ['game_monitoring', 'kalshi_markets', 'data_sources']
+    required = ['game_monitoring', 'neural_markets', 'data_sources']
     for field in required:
         if field not in config:
             errors.append(f"Missing required field: {field}")
diff --git a/docs/GETTING_STARTED.md b/docs/GETTING_STARTED.md
index c7a20cce..f1316416 100644
--- a/docs/GETTING_STARTED.md
+++ b/docs/GETTING_STARTED.md
@@ -1,418 +1,25 @@
-# Getting Started - Neural Trading Platform
+# Getting Started with Neural SDK
 
-## Prerequisites
-
-Before you begin, ensure you have:
-
-- Python 3.10 or higher
-- Redis server installed
-- Git for version control
-- At least one API key (Kalshi, DraftKings, Reddit, or OpenWeatherMap)
-
----
+Welcome to the Neural SDK! This guide will help you get up and running with your first trading strategy.
 
 ## Installation
 
-### 1. Clone the Repository
-
-```bash
-git clone https://github.com/IntelIP/Neural-Trading-Platform.git
-cd Neural-Trading-Platform
-```
-
-### 2. Install Dependencies
-
-```bash
-# Using pip
-pip install -r requirements.txt
-
-# Or using uv (recommended for faster installs)
-uv pip install -r requirements.txt
-```
-
-### 3. Set Up Redis
-
-```bash
-# macOS
-brew install redis
-brew services start redis
-
-# Ubuntu/Debian
-sudo apt-get install redis-server
-sudo systemctl start redis
-
-# Verify Redis is running
-redis-cli ping
-# Should return: PONG
-```
-
-### 4. Configure Environment Variables
-
-Create a `.env` file in the project root:
-
-```bash
-# Kalshi Trading (Required)
-KALSHI_API_KEY_ID=your_key_id_here
-KALSHI_API_KEY=your_api_key_here
-
-# Data Sources (Optional - add what you have)
-REDDIT_CLIENT_ID=your_reddit_client_id
-REDDIT_CLIENT_SECRET=your_reddit_secret
-OPENWEATHER_API_KEY=your_weather_api_key
-```
-
----
-
-## Quick Start: Monitor Your First Game
-
-### Step 1: Configure a Game to Monitor
-
-Edit `config/data_sources.yaml` to enable your available data sources:
-
-```yaml
-sources:
-  # If you have a weather API key, enable this
-  - name: weather
-    enabled: true  # Change from false to true
-    config:
-      api_key: ${OPENWEATHER_API_KEY}
-      
-  # DraftKings is free, enable this
-  - name: draftkings
-    enabled: true
-    config:
-      sports:
-        - NFL  # Pick the sport you want
-```
-
-### Step 2: Run the SDK Demo
-
-This will show you data flowing through the system:
-
-```bash
-python scripts/demo_sdk.py
-```
-
-You'll see output like:
-```
-📡 Initializing data sources...
-✅ Loaded 2 adapters:
-  • DraftKings v1.0.0
-    Type: sportsbook
-    Latency: 500ms
-    Reliability: 95.0%
-  • Weather v1.0.0
-    Type: environmental
-    Latency: 2000ms
-    Reliability: 99.0%
-
-🚀 Starting data streams...
-📊 Processing events (30 seconds)...
-
-📊 Odds Change: Chiefs vs Bills
-   Market: spread
-   Change: 0.650 → 0.675
-   Direction: up
-
-🌤️ Weather Alert: Arrowhead Stadium
-   Condition: high_wind
-   Impact: ['passing_game', 'field_goals', 'punts']
-```
-
-### Step 3: Connect to Kalshi Markets
-
-Once you have Kalshi API credentials, start the full platform:
-
-```bash
-# Start the unified stream manager
-python -m src.data_pipeline.orchestration.unified_stream_manager
-
-# In another terminal, start agent consumers
-python examples/agent_redis_consumer.py all
-```
-
----
-
-## Understanding the Data Flow
-
-Here's what happens when you run the platform:
-
-```
-1. Data Sources Connect
-   ↓
-2. Events Stream In (odds changes, weather updates, etc.)
-   ↓
-3. Stream Manager Standardizes Events
-   ↓
-4. Redis Distributes to Subscribers
-   ↓
-5. Agents Analyze for Opportunities
-   ↓
-6. Trading Signals Generated
-   ↓
-7. Orders Placed on Kalshi
-```
-
-### Real Example: Touchdown Scored
-
-```
-ESPN GameCast → "Touchdown Chiefs!"
-     ↓ (100ms)
-Stream Manager → StandardizedEvent(type=GAME_EVENT, impact=HIGH)
-     ↓ (10ms)
-Redis Pub/Sub → Channel: "espn:games"
-     ↓ (5ms)
-DataCoordinator → Detects Kalshi price hasn't moved
-     ↓ (200ms)
-StrategyAnalyst → Calculates expected +5% price move
-     ↓ (100ms)
-TradeExecutor → Places BUY order on Kalshi
-     ↓ (200ms)
-Total Time: ~615ms (before other traders react!)
-```
-
----
-
-## Basic Operations
-
-### Starting Individual Components
-
-```bash
-# Just weather monitoring
-python -m src.sdk.adapters.weather
-
-# Just DraftKings odds
-python -m src.sdk.adapters.draftkings
-
-# Just Reddit sentiment
-python -m src.sdk.adapters.reddit
-```
-
-### Monitoring System Health
-
-```bash
-# Check Redis messages
-redis-cli MONITOR
-
-# See active channels
-redis-cli PUBSUB CHANNELS
-
-# Count messages in a channel
-redis-cli PUBSUB NUMSUB kalshi:markets
-```
-
-### Running Tests
-
 ```bash
-# Test SDK functionality
-python scripts/test_sdk.py
-
-# Test specific adapter
-python -c "
-from src.sdk import SDKManager
-import asyncio
-
-async def test():
-    sdk = SDKManager()
-    await sdk.initialize()
-    results = await sdk.test_adapter('draftkings', duration=10)
-    print(f'Events received: {results[\"events_received\"]}')
-    
-asyncio.run(test())
-"
-```
-
----
-
-## Common Configurations
-
-### Focus on Specific Games
-
-To monitor only specific games, configure your sources:
-
-```yaml
-# config/data_sources.yaml
-sources:
-  - name: draftkings
-    config:
-      sports:
-        - NFL
-      teams:  # Optional: focus on specific teams
-        - "Kansas City Chiefs"
-        - "Buffalo Bills"
-```
-
-### Adjust Update Frequencies
-
-```yaml
-sources:
-  - name: draftkings
-    config:
-      poll_interval: 2  # Check every 2 seconds (was 5)
-      
-  - name: weather
-    config:
-      update_interval: 60  # Check every minute (was 5 minutes)
+pip install neural-sdk
 ```
 
-### Set Trading Thresholds
-
-```yaml
-# config/trading_config.yaml
-thresholds:
-  min_edge: 0.03  # 3% minimum advantage
-  min_confidence: 0.75  # 75% confidence required
-  max_position: 0.05  # 5% of capital max per trade
-```
-
----
-
-## Troubleshooting
+## Quick Start
 
-### No Events Showing Up?
+1. **Set up environment variables**
+2. **Create your first strategy** 
+3. **Run a backtest**
+4. **Deploy live trading** (optional)
 
-1. **Check Redis is running:**
-```bash
-redis-cli ping
-# Should return PONG
-```
-
-2. **Verify API credentials:**
-```bash
-# Test weather API
-curl "https://api.openweathermap.org/data/2.5/weather?q=London&appid=YOUR_KEY"
-```
-
-3. **Enable debug logging:**
-```python
-# Add to your script
-import logging
-logging.basicConfig(level=logging.DEBUG)
-```
-
-### Events But No Trading?
-
-1. **Check Kalshi connection:**
-```bash
-python examples/test_kalshi_websocket.py
-```
-
-2. **Verify market is open:**
-- Sports markets only trade during games
-- Check Kalshi website for active markets
-
-3. **Review thresholds:**
-- Your edge threshold might be too high
-- Lower confidence requirement for testing
-
-### High Latency?
-
-1. **Check network:**
-```bash
-ping api.kalshi.com
-```
-
-2. **Reduce data sources:**
-- Start with just one source
-- Add more gradually
-
-3. **Optimize Redis:**
-```bash
-# Check Redis latency
-redis-cli --latency
-```
-
----
+For detailed instructions, see the main README.md.
 
 ## Next Steps
 
-### 1. Add More Data Sources
-
-Create your own adapter in under 50 lines:
-
-```python
-from src.sdk import DataSourceAdapter, StandardizedEvent, EventType
-
-class MyAdapter(DataSourceAdapter):
-    async def connect(self):
-        # Your connection logic
-        return True
-    
-    async def stream(self):
-        while self.is_connected:
-            # Your data fetching
-            data = await self.fetch()
-            yield StandardizedEvent(
-                source="MySource",
-                event_type=EventType.CUSTOM,
-                data=data
-            )
-```
-
-### 2. Customize Trading Logic
-
-Modify agents to implement your strategy:
-
-```python
-# agents/StrategyAnalyst/agent.py
-@tool
-def my_custom_strategy(market_data, weather, sentiment):
-    # Your alpha generation logic
-    if weather['wind_speed'] > 20 and market_data['spread'] > 3:
-        return {"action": "buy", "confidence": 0.85}
-```
-
-### 3. Set Up Production Monitoring
-
-```bash
-# Run with full logging
-python examples/production_monitor.py
-
-# Set up alerts
-python scripts/setup_alerts.py --email your@email.com
-```
-
----
-
-## Essential Commands
-
-```bash
-# Development
-python scripts/demo_sdk.py              # Test SDK
-python examples/agent_redis_consumer.py # Run consumers
-redis-cli MONITOR                       # Watch Redis
-
-# Testing
-pytest tests/                            # Run all tests
-pytest tests/test_sdk.py -v            # Test SDK only
-
-# Production
-python -m src.data_pipeline.orchestration.unified_stream_manager  # Start streams
-python agents/launch_all.py            # Start all agents
-python scripts/monitor_health.py       # Health dashboard
-```
-
----
-
-## Getting Help
-
-If you run into issues:
-
-1. Check the logs in `logs/` directory
-2. Review configuration in `config/` 
-3. Run diagnostic script: `python scripts/diagnose.py`
-4. See troubleshooting guide in docs
-
-Remember: Start simple with one data source, verify it works, then add complexity!
-
----
-
-## Ready to Trade?
-
-You're now ready to:
-- ✅ Stream real-time data
-- ✅ Process events through the pipeline  
-- ✅ Generate trading signals
-- ✅ Execute on Kalshi markets
-
-Next: Read [DATA_SOURCES_GUIDE.md](DATA_SOURCES_GUIDE.md) to understand each data source in detail.
\ No newline at end of file
+- [API Reference](api_reference.md) - Complete SDK documentation
+- [Backtesting Guide](backtesting.md) - Historical testing framework
+- [Data Sources](data_sources.md) - Setting up data feeds
+- [Strategy Development](strategies.md) - Building trading algorithms
\ No newline at end of file
diff --git a/docs/GITHUB_PUSH_GUIDE.md b/docs/GITHUB_PUSH_GUIDE.md
deleted file mode 100644
index c716a620..00000000
--- a/docs/GITHUB_PUSH_GUIDE.md
+++ /dev/null
@@ -1,467 +0,0 @@
-# GitHub Push Guide
-
-## Pre-Push Checklist
-
-### 1. Verify Local Setup
-```bash
-# Check git is initialized
-git status
-
-# Verify remote is not set yet
-git remote -v
-
-# Ensure you're on main branch
-git branch
-```
-
-### 2. Clean Sensitive Data
-```bash
-# Ensure .env is in .gitignore
-grep "^\.env$" .gitignore
-
-# Check for any secrets in code
-grep -r "KALSHI_API_KEY" --exclude-dir=.git --exclude=.env* .
-grep -r "OPENROUTER_API_KEY" --exclude-dir=.git --exclude=.env* .
-grep -r "AGENTUITY_SDK_KEY" --exclude-dir=.git --exclude=.env* .
-
-# Verify no credentials in committed files
-git diff --cached | grep -i "api_key\|secret\|password\|token"
-```
-
-### 3. Verify Documentation
-```bash
-# Check all required docs exist
-ls -la README.md CLAUDE.md CONTRIBUTING.md
-ls -la docs/
-ls -la .github/
-```
-
-## Initial Repository Setup
-
-### Step 1: Create GitHub Repository
-
-1. Go to https://github.com/new
-2. Repository settings:
-   - **Name**: `Kalshi_Agentic_Agent`
-   - **Description**: "Autonomous multi-agent trading system for Kalshi sports event contracts"
-   - **Visibility**: Private (initially)
-   - **DO NOT** initialize with README, .gitignore, or license
-
-### Step 2: Initialize Local Repository
-
-```bash
-# If not already initialized
-git init
-
-# Add GitHub remote
-git remote add origin https://github.com/YOUR_USERNAME/Kalshi_Agentic_Agent.git
-
-# Verify remote
-git remote -v
-```
-
-### Step 3: Prepare Initial Commit
-
-```bash
-# Stage all files
-git add .
-
-# Verify what's being staged
-git status
-
-# Check file count
-git ls-files | wc -l
-
-# Create initial commit
-git commit -m "feat: initial commit - production-ready multi-agent trading system
-
-- Complete repository structure with clear naming conventions
-- Comprehensive CI/CD pipeline with GitHub Actions
-- Full documentation suite (README, CLAUDE.md, CONTRIBUTING.md)
-- Redis-based agent communication architecture
-- Agentuity framework integration
-- Kelly Criterion trading logic implementation
-- WebSocket data pipeline for real-time processing
-- PostgreSQL database with Alembic migrations
-- Security scanning and automated testing
-- Docker containerization support"
-```
-
-### Step 4: Push to GitHub
-
-```bash
-# Push main branch
-git push -u origin main
-
-# Create and push develop branch
-git checkout -b develop
-git push -u origin develop
-
-# Return to main
-git checkout main
-```
-
-## Configure GitHub Repository
-
-### Step 1: Set Up Secrets
-
-Navigate to: Settings → Secrets and variables → Actions
-
-Add the following secrets:
-
-#### Required Secrets
-```yaml
-# Kalshi Trading
-KALSHI_API_KEY_ID: "your-kalshi-api-key-id"
-KALSHI_PRIVATE_KEY: |
-  -----BEGIN PRIVATE KEY-----
-  your-private-key-content
-  -----END PRIVATE KEY-----
-KALSHI_ENVIRONMENT: "production"  # or "demo" for testing
-
-# AI/LLM
-OPENROUTER_API_KEY: "your-openrouter-api-key"
-
-# Agentuity Platform
-AGENTUITY_SDK_KEY: "your-agentuity-sdk-key"
-
-# Infrastructure
-REDIS_URL: "redis://your-redis-host:6379"
-
-# Optional - for deployment
-DOCKER_REGISTRY: "your-docker-registry"
-DOCKER_USERNAME: "your-docker-username"
-DOCKER_PASSWORD: "your-docker-password"
-```
-
-### Step 2: Configure Environments
-
-Navigate to: Settings → Environments
-
-Create two environments:
-
-#### Staging Environment
-- **Name**: staging
-- **Protection rules**: 
-  - Only from: `develop` branch
-  - Required reviewers: 1
-- **Secrets**: Add staging-specific overrides
-
-#### Production Environment
-- **Name**: production
-- **Protection rules**:
-  - Only from: `main` branch
-  - Required reviewers: 2
-  - Restrict deployments to specific users
-- **Secrets**: Add production-specific values
-
-### Step 3: Enable Branch Protection
-
-Navigate to: Settings → Branches
-
-#### Main Branch Protection
-```bash
-# Using GitHub CLI (if installed)
-gh api repos/:owner/:repo/branches/main/protection \
-  --method PUT \
-  --field required_status_checks='{"strict":true,"contexts":["CI Pipeline / Lint & Format Check","CI Pipeline / Test Suite","CI Pipeline / Security Scan","CI Pipeline / Build & Validate"]}' \
-  --field required_pull_request_reviews='{"required_approving_review_count":2,"dismiss_stale_reviews":true}' \
-  --field enforce_admins=true \
-  --field allow_force_pushes=false \
-  --field allow_deletions=false
-```
-
-Or manually:
-1. Click "Add rule"
-2. Branch name pattern: `main`
-3. Enable:
-   - ✅ Require pull request before merging (2 approvals)
-   - ✅ Require status checks to pass
-   - ✅ Require branches to be up to date
-   - ✅ Include administrators
-   - ✅ Restrict who can push (only maintainers)
-
-#### Develop Branch Protection
-Similar to main but with 1 required approval.
-
-### Step 4: Configure GitHub Pages (Optional)
-
-For documentation hosting:
-
-1. Settings → Pages
-2. Source: Deploy from branch
-3. Branch: main
-4. Folder: /docs
-5. Save
-
-### Step 5: Set Up Teams (If Organization)
-
-1. Settings → Manage access → Invite teams
-2. Create teams:
-   - `maintainers` - Admin access
-   - `developers` - Write access
-   - `qa-team` - Triage access
-
-### Step 6: Configure Webhooks (Optional)
-
-For external integrations:
-
-1. Settings → Webhooks → Add webhook
-2. Payload URL: Your monitoring service
-3. Events: Push, Pull Request, Deployment
-
-## Verify CI/CD Pipeline
-
-### Step 1: Create Test PR
-
-```bash
-# Create feature branch
-git checkout -b feature/test-ci
-echo "# Test CI" > test.md
-git add test.md
-git commit -m "test: verify CI pipeline"
-git push -u origin feature/test-ci
-```
-
-### Step 2: Open Pull Request
-
-1. Go to repository on GitHub
-2. Click "Compare & pull request"
-3. Target: develop
-4. Create pull request
-
-### Step 3: Verify Checks
-
-Ensure all checks pass:
-- ✅ Lint & Format Check
-- ✅ Test Suite
-- ✅ Security Scan
-- ✅ Build & Validate
-- ✅ PR Checks
-
-### Step 4: Clean Up
-
-```bash
-# After merge, delete test branch
-git checkout develop
-git pull origin develop
-git branch -d feature/test-ci
-git push origin --delete feature/test-ci
-```
-
-## First Deployment
-
-### Step 1: Prepare for Deployment
-
-```bash
-# Ensure on develop branch
-git checkout develop
-
-# Tag release candidate
-git tag -a v0.1.0-rc.1 -m "Release candidate 1 for v0.1.0"
-git push origin v0.1.0-rc.1
-```
-
-### Step 2: Deploy to Staging
-
-```bash
-# Trigger staging deployment
-# This happens automatically on push to develop
-
-# Or manually via GitHub Actions
-gh workflow run deploy.yml -f environment=staging -f version=v0.1.0-rc.1
-```
-
-### Step 3: Production Release
-
-```bash
-# Create release PR
-git checkout -b release/v0.1.0
-git push -u origin release/v0.1.0
-
-# After approval and merge to main
-git checkout main
-git pull origin main
-git tag -a v0.1.0 -m "Initial release v0.1.0"
-git push origin v0.1.0
-
-# Create GitHub Release
-gh release create v0.1.0 \
-  --title "v0.1.0 - Initial Release" \
-  --notes "Initial production release of Kalshi Trading Agent System" \
-  --target main
-```
-
-## Post-Push Tasks
-
-### Immediate Actions
-
-1. **Verify Repository Access**:
-   ```bash
-   # Clone in new directory to test
-   cd /tmp
-   git clone https://github.com/YOUR_USERNAME/Kalshi_Agentic_Agent.git
-   cd Kalshi_Agentic_Agent
-   ```
-
-2. **Check CI Status**:
-   - Go to Actions tab
-   - Verify workflows are detected
-   - Check for any configuration errors
-
-3. **Update README Badge**:
-   ```markdown
-   ![CI Pipeline](https://github.com/YOUR_USERNAME/Kalshi_Agentic_Agent/workflows/CI%20Pipeline/badge.svg)
-   ```
-
-### Within 24 Hours
-
-1. **Security Scan**:
-   - Enable Dependabot alerts
-   - Review security recommendations
-   - Set up code scanning
-
-2. **Documentation**:
-   - Verify all links work
-   - Check rendered markdown
-   - Update any absolute paths
-
-3. **Team Access**:
-   - Invite collaborators
-   - Set up CODEOWNERS file
-   - Configure notifications
-
-### Within First Week
-
-1. **Monitoring Setup**:
-   - Configure error tracking
-   - Set up performance monitoring
-   - Add deployment notifications
-
-2. **Backup Strategy**:
-   - Set up repository mirroring
-   - Configure automated backups
-   - Document recovery procedures
-
-3. **Performance Baseline**:
-   - Run initial load tests
-   - Document response times
-   - Set up metrics collection
-
-## Troubleshooting
-
-### Common Issues
-
-#### Push Rejected - Large Files
-```bash
-# Check for large files
-find . -type f -size +100M
-
-# Add to .gitignore if needed
-echo "large-file.bin" >> .gitignore
-
-# Remove from git history
-git filter-branch --index-filter 'git rm --cached --ignore-unmatch large-file.bin' HEAD
-```
-
-#### Push Rejected - Credentials Detected
-```bash
-# Remove sensitive data
-git filter-branch --force --index-filter \
-  'git rm --cached --ignore-unmatch path/to/sensitive-file' \
-  --prune-empty --tag-name-filter cat -- --all
-```
-
-#### CI Workflows Not Triggering
-1. Check workflow syntax
-2. Verify file location (.github/workflows/)
-3. Ensure proper permissions
-4. Check branch protection settings
-
-#### Permission Denied
-```bash
-# For HTTPS
-git config --global credential.helper cache
-
-# For SSH
-ssh-add ~/.ssh/id_rsa
-```
-
-## Security Checklist
-
-Before making repository public:
-
-- [ ] All secrets in GitHub Secrets
-- [ ] No hardcoded credentials
-- [ ] .env.example has placeholder values
-- [ ] Security scanning enabled
-- [ ] Dependency review enabled
-- [ ] Branch protection configured
-- [ ] CODEOWNERS file created
-- [ ] Security policy added
-- [ ] Vulnerability reporting enabled
-
-## Quick Reference
-
-### Essential Commands
-```bash
-# Initial push
-git push -u origin main
-
-# Create develop branch
-git checkout -b develop
-git push -u origin develop
-
-# Create feature branch
-git checkout -b feature/new-feature
-git push -u origin feature/new-feature
-
-# Update from upstream
-git fetch origin
-git merge origin/develop
-
-# Tag release
-git tag -a v1.0.0 -m "Release v1.0.0"
-git push origin v1.0.0
-```
-
-### GitHub CLI Commands
-```bash
-# Check workflow runs
-gh run list
-
-# View workflow details
-gh run view
-
-# Watch workflow in progress
-gh run watch
-
-# List issues
-gh issue list
-
-# Create issue
-gh issue create --title "Bug report" --body "Description"
-
-# List PRs
-gh pr list
-
-# Create PR
-gh pr create --title "Feature" --body "Description"
-```
-
-## Next Steps
-
-After successful push:
-
-1. **Test the CI pipeline** with a small PR
-2. **Configure deployment** to Agentuity platform
-3. **Set up monitoring** and alerting
-4. **Document API endpoints** if applicable
-5. **Create initial issues** for known improvements
-6. **Invite team members** and assign roles
-7. **Schedule regular dependency updates**
-8. **Plan first sprint** using GitHub Projects
-
----
-
-Remember: This is a financial trading system. Ensure all security measures are properly configured before deploying to production.
\ No newline at end of file
diff --git a/docs/GIT_WORKFLOW.md b/docs/GIT_WORKFLOW.md
deleted file mode 100644
index ff781fc5..00000000
--- a/docs/GIT_WORKFLOW.md
+++ /dev/null
@@ -1,443 +0,0 @@
-# Git Workflow & Branching Strategy
-
-## Branch Structure
-
-```
-main (production)
-  ├── develop (integration)
-  │   ├── feature/feature-name
-  │   ├── bugfix/issue-description
-  │   └── hotfix/critical-fix
-  └── release/v1.0.0
-```
-
-## Branch Types
-
-### 1. Main Branch (`main`)
-- **Purpose**: Production-ready code
-- **Protection**: Full protection enabled
-- **Deploy**: Automatically to production
-- **Merge**: Only from `release/*` or `hotfix/*` branches
-- **Requirements**:
-  - All tests passing
-  - Code review approved
-  - No merge conflicts
-
-### 2. Develop Branch (`develop`)
-- **Purpose**: Integration branch for features
-- **Protection**: Requires PR and tests
-- **Deploy**: To staging environment
-- **Merge**: From `feature/*` and `bugfix/*` branches
-- **Updated**: Daily from `main`
-
-### 3. Feature Branches (`feature/*`)
-- **Naming**: `feature/description-of-feature`
-- **Created from**: `develop`
-- **Merged to**: `develop`
-- **Lifetime**: Until feature complete
-- **Examples**:
-  - `feature/add-stop-loss-monitor`
-  - `feature/espn-api-integration`
-  - `feature/kelly-criterion-update`
-
-### 4. Bugfix Branches (`bugfix/*`)
-- **Naming**: `bugfix/issue-number-description`
-- **Created from**: `develop`
-- **Merged to**: `develop`
-- **Lifetime**: Until bug fixed
-- **Examples**:
-  - `bugfix/123-websocket-reconnection`
-  - `bugfix/456-redis-timeout`
-
-### 5. Release Branches (`release/*`)
-- **Naming**: `release/vX.Y.Z`
-- **Created from**: `develop`
-- **Merged to**: `main` and back to `develop`
-- **Purpose**: Final testing and version prep
-- **Allowed changes**: Bug fixes only
-
-### 6. Hotfix Branches (`hotfix/*`)
-- **Naming**: `hotfix/critical-issue`
-- **Created from**: `main`
-- **Merged to**: `main` and `develop`
-- **Purpose**: Emergency production fixes
-- **Review**: Expedited process
-
-## Workflow Steps
-
-### Starting New Feature
-
-```bash
-# 1. Update develop branch
-git checkout develop
-git pull origin develop
-
-# 2. Create feature branch
-git checkout -b feature/my-new-feature
-
-# 3. Work on feature
-git add .
-git commit -m "feat: add new feature description"
-
-# 4. Push to remote
-git push -u origin feature/my-new-feature
-
-# 5. Create Pull Request to develop
-```
-
-### Creating a Release
-
-```bash
-# 1. Create release branch from develop
-git checkout develop
-git pull origin develop
-git checkout -b release/v1.0.0
-
-# 2. Update version numbers
-# Update pyproject.toml, README.md, etc.
-
-# 3. Final testing and fixes
-git add .
-git commit -m "chore: prepare release v1.0.0"
-
-# 4. Merge to main
-git checkout main
-git merge --no-ff release/v1.0.0
-git tag -a v1.0.0 -m "Release version 1.0.0"
-
-# 5. Merge back to develop
-git checkout develop
-git merge --no-ff release/v1.0.0
-
-# 6. Push everything
-git push origin main develop --tags
-
-# 7. Delete release branch
-git branch -d release/v1.0.0
-git push origin --delete release/v1.0.0
-```
-
-### Emergency Hotfix
-
-```bash
-# 1. Create hotfix from main
-git checkout main
-git pull origin main
-git checkout -b hotfix/critical-bug
-
-# 2. Fix the issue
-git add .
-git commit -m "hotfix: fix critical production bug"
-
-# 3. Merge to main
-git checkout main
-git merge --no-ff hotfix/critical-bug
-git tag -a v1.0.1 -m "Hotfix version 1.0.1"
-
-# 4. Merge to develop
-git checkout develop
-git merge --no-ff hotfix/critical-bug
-
-# 5. Push and cleanup
-git push origin main develop --tags
-git branch -d hotfix/critical-bug
-git push origin --delete hotfix/critical-bug
-```
-
-## Commit Message Convention
-
-### Format
-```
-<type>(<scope>): <subject>
-
-<body>
-
-<footer>
-```
-
-### Types
-- `feat`: New feature
-- `fix`: Bug fix
-- `docs`: Documentation changes
-- `style`: Code style changes (formatting, etc)
-- `refactor`: Code refactoring
-- `perf`: Performance improvements
-- `test`: Test additions or fixes
-- `chore`: Build process or auxiliary tool changes
-- `ci`: CI/CD changes
-
-### Examples
-```bash
-feat(websocket): add automatic reconnection logic
-
-fix(redis): handle connection timeout gracefully
-
-docs(readme): update installation instructions
-
-refactor(agents): simplify message processing logic
-
-test(trading): add Kelly Criterion unit tests
-
-chore(deps): update dependencies to latest versions
-```
-
-## Pull Request Process
-
-### 1. Create PR
-- Use PR template
-- Link related issues
-- Add appropriate labels
-- Assign reviewers
-
-### 2. PR Title Format
-```
-[TYPE] Brief description (#issue-number)
-```
-
-Examples:
-- `[FEATURE] Add WebSocket reconnection logic (#123)`
-- `[BUGFIX] Fix Redis timeout handling (#456)`
-- `[HOTFIX] Critical trading logic fix (#789)`
-
-### 3. PR Checklist
-- [ ] Tests pass locally
-- [ ] Code follows style guide
-- [ ] Documentation updated
-- [ ] No merge conflicts
-- [ ] Reviewed by at least 1 person
-- [ ] CI/CD checks pass
-
-### 4. Review Process
-1. **Draft PR**: For early feedback
-2. **Ready for Review**: When complete
-3. **Changes Requested**: Address feedback
-4. **Approved**: Ready to merge
-5. **Merged**: Squash and merge to target branch
-
-## Branch Protection Rules
-
-### Main Branch
-```yaml
-protection_rules:
-  - require_pull_request_reviews:
-      required_approving_review_count: 2
-      dismiss_stale_reviews: true
-  - require_status_checks:
-      strict: true
-      contexts:
-        - continuous-integration/tests
-        - continuous-integration/lint
-  - enforce_admins: false
-  - restrict_push:
-      teams: ["maintainers"]
-  - allow_force_pushes: false
-  - allow_deletions: false
-```
-
-### Develop Branch
-```yaml
-protection_rules:
-  - require_pull_request_reviews:
-      required_approving_review_count: 1
-  - require_status_checks:
-      contexts:
-        - continuous-integration/tests
-  - enforce_admins: false
-  - allow_force_pushes: false
-```
-
-## Versioning Strategy
-
-### Semantic Versioning (SemVer)
-Format: `MAJOR.MINOR.PATCH`
-
-- **MAJOR**: Breaking changes
-- **MINOR**: New features (backward compatible)
-- **PATCH**: Bug fixes (backward compatible)
-
-### Examples
-- `1.0.0` → `2.0.0`: Breaking API changes
-- `1.0.0` → `1.1.0`: New feature added
-- `1.0.0` → `1.0.1`: Bug fix
-
-### Pre-release Versions
-- Alpha: `1.0.0-alpha.1`
-- Beta: `1.0.0-beta.1`
-- Release Candidate: `1.0.0-rc.1`
-
-## Git Aliases (Optional)
-
-Add to `~/.gitconfig`:
-
-```ini
-[alias]
-    # Create feature branch
-    feature = "!f() { git checkout develop && git pull && git checkout -b feature/$1; }; f"
-    
-    # Create bugfix branch
-    bugfix = "!f() { git checkout develop && git pull && git checkout -b bugfix/$1; }; f"
-    
-    # Create release branch
-    release = "!f() { git checkout develop && git pull && git checkout -b release/$1; }; f"
-    
-    # Create hotfix branch
-    hotfix = "!f() { git checkout main && git pull && git checkout -b hotfix/$1; }; f"
-    
-    # Finish feature (merge to develop)
-    finish-feature = "!f() { git checkout develop && git merge --no-ff $1 && git branch -d $1; }; f"
-    
-    # Pretty log
-    lg = log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit
-```
-
-## Merge Strategies
-
-### Feature → Develop
-- Strategy: **Squash and Merge**
-- Keeps develop history clean
-- One commit per feature
-
-### Develop → Main
-- Strategy: **Create Merge Commit**
-- Preserves release history
-- Clear release points
-
-### Hotfix → Main/Develop
-- Strategy: **Create Merge Commit**
-- Tracks emergency fixes
-- Maintains audit trail
-
-## Conflict Resolution
-
-### Prevention
-1. Pull latest changes daily
-2. Keep branches short-lived
-3. Communicate with team
-4. Use feature flags for long features
-
-### Resolution Steps
-```bash
-# 1. Update target branch
-git checkout develop
-git pull origin develop
-
-# 2. Merge into feature branch
-git checkout feature/my-feature
-git merge develop
-
-# 3. Resolve conflicts
-# Edit conflicted files
-git add .
-git commit -m "resolve: merge conflicts with develop"
-
-# 4. Test thoroughly
-pytest tests/
-
-# 5. Push resolved branch
-git push origin feature/my-feature
-```
-
-## Release Checklist
-
-### Pre-Release
-- [ ] All features merged to develop
-- [ ] All tests passing
-- [ ] Documentation updated
-- [ ] CHANGELOG.md updated
-- [ ] Version numbers updated
-- [ ] Security audit completed
-
-### Release
-- [ ] Create release branch
-- [ ] Final testing on staging
-- [ ] Merge to main
-- [ ] Tag release
-- [ ] Merge back to develop
-
-### Post-Release
-- [ ] Deploy to production
-- [ ] Monitor for issues
-- [ ] Update release notes
-- [ ] Notify stakeholders
-- [ ] Archive release branch
-
-## Rollback Procedure
-
-### Quick Revert
-```bash
-# Revert last commit on main
-git checkout main
-git revert HEAD
-git push origin main
-```
-
-### Tag Rollback
-```bash
-# Deploy previous version
-git checkout v1.0.0
-git checkout -b hotfix/rollback-to-v1.0.0
-# Deploy this branch
-```
-
-### Full Rollback
-```bash
-# Reset to previous release
-git checkout main
-git reset --hard v1.0.0
-git push --force-with-lease origin main
-```
-
-## Best Practices
-
-### Do's
-- ✅ Pull before starting work
-- ✅ Commit frequently with clear messages
-- ✅ Test before pushing
-- ✅ Keep branches focused
-- ✅ Update documentation
-- ✅ Use descriptive branch names
-
-### Don'ts
-- ❌ Commit directly to main
-- ❌ Force push to shared branches
-- ❌ Leave branches unmerged for weeks
-- ❌ Merge without review
-- ❌ Include credentials in commits
-- ❌ Rewrite public history
-
-## Tools & Integration
-
-### Required Tools
-- Git 2.30+
-- GitHub CLI (`gh`)
-- Pre-commit hooks
-
-### Setup
-```bash
-# Install GitHub CLI
-brew install gh
-
-# Install pre-commit
-pip install pre-commit
-pre-commit install
-
-# Configure git
-git config --global user.name "Your Name"
-git config --global user.email "you@example.com"
-git config --global init.defaultBranch main
-```
-
-### Useful Commands
-```bash
-# View branch graph
-git log --graph --oneline --all
-
-# Clean up local branches
-git branch --merged | grep -v "\*\|main\|develop" | xargs -n 1 git branch -d
-
-# Update fork from upstream
-git remote add upstream https://github.com/original/repo.git
-git fetch upstream
-git checkout main
-git merge upstream/main
-```
\ No newline at end of file
diff --git a/docs/MVP_PLAN.md b/docs/MVP_PLAN.md
deleted file mode 100644
index 9d3ab597..00000000
--- a/docs/MVP_PLAN.md
+++ /dev/null
@@ -1,84 +0,0 @@
-# MVP Plan - Kalshi Trading System
-
-## Core Objective
-WebSockets → Redis → Agents → Kalshi Trading on Agentuity
-
-## What We Have Built
-- ✅ WebSocket infrastructure for Kalshi market data
-- ✅ ESPN data streaming
-- ✅ Circuit breaker protection
-- ✅ Rate limiting & backpressure
-- ✅ Stream orchestration (StreamManager)
-
-## What We Need (Minimal Path to Trading)
-
-### 1. Redis Integration (TODAY)
-- Connect StreamManager to Redis pub/sub
-- Publish market events to channels:
-  - `kalshi:markets` - Market updates
-  - `kalshi:trades` - Trade events
-  - `espn:games` - Game updates
-
-### 2. Agent Data Consumption (NEXT)
-- Agents subscribe to Redis channels
-- Process real-time events
-- Make trading decisions
-
-### 3. Trade Execution (FINAL)
-- TradeExecutor places orders via Kalshi API
-- RiskManager monitors positions
-- Basic P&L tracking
-
-## NO BLOAT - What We're NOT Building
-- ❌ Complex order management systems
-- ❌ Sophisticated backtesting
-- ❌ Multiple strategy frameworks
-- ❌ Advanced ML models
-- ❌ Custom monitoring dashboards
-- ❌ Mock/simulation systems
-
-## Implementation Steps
-
-### Step 1: Redis Publisher (Today)
-```python
-# StreamManager publishes to Redis
-await redis.publish('kalshi:markets', market_data)
-```
-
-### Step 2: Agent Subscribers (Tomorrow)
-```python
-# Agents consume from Redis
-async for message in redis.subscribe('kalshi:markets'):
-    await process_market_data(message)
-```
-
-### Step 3: Execute Trades (Day After)
-```python
-# Simple trade execution
-if signal > threshold:
-    await kalshi_api.place_order(market, side, quantity)
-```
-
-## Success Criteria
-1. WebSockets stream live data ✅
-2. Data flows through Redis to agents
-3. Agents analyze and identify opportunities
-4. Trades execute on Kalshi
-5. Positions are monitored
-6. System runs on Agentuity
-
-## Timeline
-- Day 1-7: Infrastructure ✅
-- Day 8-9: Redis integration
-- Day 10-11: Agent consumption
-- Day 12-13: Trade execution
-- Day 14: Deploy on Agentuity
-
-**Target: Trading within 7 days**
-
-## Remember
-- Keep it simple
-- No mock systems
-- Real data only
-- Focus on execution
-- Deploy and iterate
\ No newline at end of file
diff --git a/docs/README.md b/docs/README.md
index 1ddd9038..5d505dfe 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -7,7 +7,7 @@ Complete documentation for the Neural Trading Platform - organized by topic and
 ### For New Users
 1. **[Getting Started](GETTING_STARTED.md)** - Installation, setup, and your first trade
 2. **[System Overview](SYSTEM_OVERVIEW.md)** - How the platform works end-to-end
-3. **[Quick Weather Demo](../scripts/quick_weather_demo.py)** - See real-time data in action
+3. **[Basic Usage Example](../examples/basic_usage.py)** - See the SDK in action
 
 ### For Developers
 1. **[SDK Documentation](SDK_DOCUMENTATION.md)** - Build custom data adapters
@@ -38,18 +38,12 @@ Complete documentation for the Neural Trading Platform - organized by topic and
 - **[Backtesting](../scripts/run_backtest.py)** - Historical testing
 
 ### Development & Deployment
-- **[Git Workflow](GIT_WORKFLOW.md)** - Version control practices
-- **[GitHub Push Guide](GITHUB_PUSH_GUIDE.md)** - Deployment process
 - **[Contributing](../CONTRIBUTING.md)** - Contribution guidelines
+- **[Architecture](ARCHITECTURE.md)** - Technical deep dive
 
-### Platform & Vision
-- **[Platform Roadmap](../PLATFORM_ROADMAP.md)** - Future development plans
-- **[Investor Demo](../INVESTOR_DEMO.md)** - Platform capabilities
-- **[MVP Plan](MVP_PLAN.md)** - Minimum viable product
-
-### Agents & Components
-- **[Agents](AGENTS.md)** - Trading agent descriptions
-- **[CLAUDE.md](../CLAUDE.md)** - AI assistant guidelines
+### SDK Reference
+- **[API Reference](api_reference.md)** - Complete API documentation
+- **[Backtesting Guide](backtesting.md)** - Historical testing framework
 
 ## 🔑 Key Concepts
 
@@ -72,11 +66,10 @@ Data Sources → SDK Adapters → Redis → Agents → Trading
 
 ## 🧪 Examples & Demos
 
-### Scripts
-- **[demo_sdk.py](../scripts/demo_sdk.py)** - Full SDK demonstration
-- **[test_weather_adapter.py](../scripts/test_weather_adapter.py)** - Weather API testing
-- **[quick_weather_demo.py](../scripts/quick_weather_demo.py)** - Quick weather check
-- **[demo_investor.py](../scripts/demo_investor.py)** - Investor presentation
+### Examples
+- **[basic_usage.py](../examples/basic_usage.py)** - Full SDK demonstration
+- **[backtest_strategy.py](../examples/backtest_strategy.py)** - Backtesting example
+- **[custom_data_adapter.py](../examples/custom_data_adapter.py)** - Custom data integration
 
 ### Configuration Files
 - **[data_sources.yaml](../config/data_sources.yaml)** - Data source setup
@@ -96,7 +89,7 @@ Data Sources → SDK Adapters → Redis → Agents → Trading
 ### 🔄 In Progress
 - Reddit sentiment analysis
 - ESPN GameCast integration
-- Kalshi production trading
+- Neural production trading
 
 ### 📅 Planned
 - Machine learning models
@@ -107,8 +100,8 @@ Data Sources → SDK Adapters → Redis → Agents → Trading
 
 ### API Keys Required
 ```bash
-KALSHI_API_KEY_ID=xxx        # Trading
-KALSHI_API_KEY=xxx           # Trading
+NEURAL_API_KEY_ID=xxx        # Trading
+NEURAL_PRIVATE_KEY_FILE=xxx  # Trading
 OPENWEATHER_API_KEY=xxx      # Weather (included)
 REDDIT_CLIENT_ID=xxx         # Sentiment (optional)
 REDDIT_CLIENT_SECRET=xxx     # Sentiment (optional)
@@ -117,16 +110,13 @@ REDDIT_CLIENT_SECRET=xxx     # Sentiment (optional)
 ### Key Commands
 ```bash
 # Test SDK
-python scripts/demo_sdk.py
-
-# Start trading
-python scripts/run_agents.py
+python examples/basic_usage.py
 
 # Run backtest
-python scripts/run_backtest.py
+python examples/backtest_strategy.py
 
-# Monitor weather
-python scripts/quick_weather_demo.py
+# Custom data adapter
+python examples/custom_data_adapter.py
 ```
 
 ### Performance Targets
diff --git a/docs/SDK_DOCUMENTATION.md b/docs/SDK_DOCUMENTATION.md
index 33112414..bab44dc8 100644
--- a/docs/SDK_DOCUMENTATION.md
+++ b/docs/SDK_DOCUMENTATION.md
@@ -245,7 +245,7 @@ config:
 
 **Events Generated**:
 - `ODDS_CHANGE`: When lines move significantly
-- Impact: Correlate with Kalshi prices
+- Impact: Correlate with Neural prices
 
 ### Reddit Adapter
 
@@ -470,11 +470,11 @@ class MultiSourceCorrelator:
                 await self.execute_trade(game_id, recent)
     
     def detect_opportunity(self, events):
-        # Check if DraftKings moved but Kalshi hasn't
+        # Check if DraftKings moved but Neural hasn't
         dk_events = [e for e in events if e.source == "DraftKings"]
-        kalshi_events = [e for e in events if e.source == "Kalshi"]
+        neural_events = [e for e in events if e.source == "Neural"]
         
-        if dk_events and not kalshi_events:
+        if dk_events and not neural_events:
             return True  # Opportunity!
 ```
 
diff --git a/docs/SIMPLIFIED_ARCHITECTURE_SUMMARY.md b/docs/SIMPLIFIED_ARCHITECTURE_SUMMARY.md
index 9d1036ac..b041bc8a 100644
--- a/docs/SIMPLIFIED_ARCHITECTURE_SUMMARY.md
+++ b/docs/SIMPLIFIED_ARCHITECTURE_SUMMARY.md
@@ -14,7 +14,7 @@ We've successfully redesigned and implemented a simplified agent architecture th
 ### 2. **Always-On Agents (24/7 Operation)**
 
 #### **DataCoordinator** (`agent_consumers/DataCoordinator/`)
-- Continuously monitors ESPN, Twitter, and Kalshi streams
+- Continuously monitors ESPN, Twitter, and Neural streams
 - Routes high-impact events to appropriate agents
 - Maintains unified data pipeline via StreamManager
 
@@ -112,7 +112,7 @@ External APIs → WebSocket Streams → Redis Pub/Sub
 4. GameAnalyst gathers data:
    - Historical performance
    - Current form and injuries
-   - Market data from Kalshi
+   - Market data from Neural
    - Sentiment from Twitter
    - Weather conditions
 5. LLM analyzes all factors
@@ -196,4 +196,4 @@ We've successfully transformed an over-engineered Agentuity-based system into a
 4. **Ensures reliability** with proper separation of concerns
 5. **Enables scalability** through Redis pub/sub architecture
 
-The system is now production-ready for automated sports betting on Kalshi with proper risk management and intelligent decision-making.
\ No newline at end of file
+The system is now production-ready for automated sports betting on Neural with proper risk management and intelligent decision-making.
\ No newline at end of file
diff --git a/docs/SYSTEM_OVERVIEW.md b/docs/SYSTEM_OVERVIEW.md
index 2a2c57e1..83133f76 100644
--- a/docs/SYSTEM_OVERVIEW.md
+++ b/docs/SYSTEM_OVERVIEW.md
@@ -2,7 +2,7 @@
 
 ## Purpose
 
-This platform is an automated trading system for Kalshi sports prediction markets. It ingests real-time data from multiple sources (game stats, odds, sentiment, weather), correlates events across sources to identify mispricing, and executes trades faster than human reaction time.
+This platform is an automated trading system for Neural sports prediction markets. It ingests real-time data from multiple sources (game stats, odds, sentiment, weather), correlates events across sources to identify mispricing, and executes trades faster than human reaction time.
 
 ---
 
@@ -12,7 +12,7 @@ This platform is an automated trading system for Kalshi sports prediction market
 ┌─────────────────────────────────────────────────────────────────────┐
 │                        DATA INGESTION LAYER                         │
 │                                                                      │
-│  KalshiWebSocket    ESPN GameCast    DraftKings    Reddit    Weather│
+│  NeuralWebSocket    ESPN GameCast    DraftKings    Reddit    Weather│
 │       ↓                  ↓              ↓           ↓          ↓    │
 │  [Market Prices]   [Game Events]   [Pro Odds]  [Sentiment] [Conditions]│
 └─────────────────┬───────────────────────────────────────────────────┘
@@ -30,7 +30,7 @@ This platform is an automated trading system for Kalshi sports prediction market
 │                      DISTRIBUTION LAYER                             │
 │                                                                      │
 │  Redis Pub/Sub Hub                                                  │
-│  ├── Channel: kalshi:markets                                       │
+│  ├── Channel: neural:markets                                       │
 │  ├── Channel: espn:games                                           │
 │  ├── Channel: signals:opportunities                                │
 │  └── 10,000 msg/sec throughput                                     │
@@ -48,7 +48,7 @@ This platform is an automated trading system for Kalshi sports prediction market
 ┌─────────────────────────────────────────────────────────────────────┐
 │                      EXECUTION LAYER                                │
 │                                                                      │
-│  Kalshi Trading API                                                 │
+│  Neural Trading API                                                 │
 │  ├── Order Management                                              │
 │  ├── Position Tracking                                             │
 │  └── Settlement                                                    │
@@ -65,7 +65,7 @@ Each data source provides unique information:
 
 | Source | Data Type | Latency | Purpose |
 |--------|-----------|---------|---------|
-| **Kalshi WebSocket** | Market prices, trades | ~50ms | Current betting prices |
+| **Neural WebSocket** | Market prices, trades | ~50ms | Current betting prices |
 | **ESPN GameCast** | Play-by-play, scores | ~1-2s | Game events |
 | **DraftKings API** | Professional odds | ~500ms | Sharp money movements |
 | **Reddit Streams** | Game thread comments | ~2-5s | Crowd sentiment |
@@ -86,14 +86,14 @@ Redis Pub/Sub acts as our message bus:
 
 ```python
 # Publishing example
-redis_client.publish("kalshi:markets", {
+redis_client.publish("neural:markets", {
     "market": "NFL-KC-BUF",
     "yes_price": 0.65,
     "timestamp": "2024-01-21T18:30:45Z"
 })
 
 # Subscribing example
-pubsub.subscribe("kalshi:markets")
+pubsub.subscribe("neural:markets")
 for message in pubsub.listen():
     process_market_update(message)
 ```
@@ -114,7 +114,7 @@ Two types of agents:
 
 ### **Execution Layer**
 
-Interfaces with Kalshi API for trading:
+Interfaces with Neural API for trading:
 - Places market/limit orders
 - Manages existing positions
 - Handles order fills and cancellations
@@ -136,7 +136,7 @@ Let's trace a touchdown event through the system:
    └── Publishes to "espn:games" channel
    
 4. DataCoordinator Agent (T+0.3s)
-   ├── Correlates with current Kalshi price (0.65)
+   ├── Correlates with current Neural price (0.65)
    ├── Detects price hasn't moved yet
    └── Publishes opportunity signal
    
@@ -151,7 +151,7 @@ Let's trace a touchdown event through the system:
    └── Order filled (T+1.2s)
    
 7. Market Adjustment (T+15s)
-   └── Kalshi price moves to 0.70 (+7.7% profit)
+   └── Neural price moves to 0.70 (+7.7% profit)
 ```
 
 ---
@@ -207,7 +207,7 @@ Total time from event to trade execution:
 ### **Why Multiple Data Sources?**
 
 Each source provides unique alpha:
-- **Kalshi**: Current market consensus
+- **Neural**: Current market consensus
 - **ESPN**: Ground truth of game events  
 - **DraftKings**: Sharp money movements
 - **Reddit**: Retail sentiment extremes
diff --git a/docs/TRADING_LOGIC.md b/docs/TRADING_LOGIC.md
index 80df3c90..07dd4fea 100644
--- a/docs/TRADING_LOGIC.md
+++ b/docs/TRADING_LOGIC.md
@@ -107,7 +107,7 @@ class SignalGenerator:
     def generate_signal(self, correlation: Correlation) -> Optional[Signal]:
         """Create signal from correlated events."""
         
-        # Pattern 1: DraftKings moves, Kalshi hasn't
+        # Pattern 1: DraftKings moves, Neural hasn't
         if self.is_arbitrage_opportunity(correlation):
             return Signal(
                 type=SignalType.ARBITRAGE,
@@ -145,10 +145,10 @@ class SignalGenerator:
     def is_arbitrage_opportunity(self, correlation):
         """Check for price discrepancy."""
         dk_event = correlation.get_event("DraftKings")
-        kalshi_event = correlation.get_event("Kalshi")
+        neural_event = correlation.get_event("Neural")
         
-        if dk_event and not kalshi_event:
-            # DraftKings moved, Kalshi hasn't yet
+        if dk_event and not neural_event:
+            # DraftKings moved, Neural hasn't yet
             if dk_event.data['magnitude'] == 'large':
                 return True
                 
@@ -439,7 +439,7 @@ class OrderExecutor:
             'size': size,
             'time_in_force': 'IOC'  # Immediate or cancel
         }
-        return await self.kalshi_client.place_order(order)
+        return await self.neural_client.place_order(order)
         
     async def aggressive_limit(self, signal, size):
         """Place limit at or better than market."""
@@ -457,7 +457,7 @@ class OrderExecutor:
             'price': limit_price,
             'time_in_force': 'GTC'  # Good till cancelled
         }
-        return await self.kalshi_client.place_order(order)
+        return await self.neural_client.place_order(order)
 ```
 
 ### Order Management
diff --git a/docs/api_reference.md b/docs/api_reference.md
new file mode 100644
index 00000000..f46b1284
--- /dev/null
+++ b/docs/api_reference.md
@@ -0,0 +1,51 @@
+# API Reference
+
+Complete API documentation for the Neural SDK.
+
+## Core Classes
+
+### NeuralSDK
+Main SDK class for trading operations.
+
+### BacktestEngine  
+Event-driven backtesting engine.
+
+### BacktestConfig
+Configuration for backtesting parameters.
+
+## Data Providers
+
+### DataProvider (Base)
+Abstract base class for data providers.
+
+### CSVProvider
+Load data from CSV files.
+
+### ParquetProvider  
+Load data from Parquet files with PyArrow support.
+
+### S3Provider (Optional)
+Load data from Amazon S3 buckets.
+
+### DatabaseProvider (Optional)
+Load data from SQL databases.
+
+## Portfolio Management
+
+### Portfolio
+Portfolio simulation with realistic costs.
+
+### Position
+Individual market position tracking.
+
+### Trade
+Trade execution record.
+
+## Performance Analytics
+
+### PerformanceMetrics
+Comprehensive trading performance metrics.
+
+---
+
+*Full API documentation will be available at [neural-sdk.readthedocs.io](https://neural-sdk.readthedocs.io/)*
\ No newline at end of file
diff --git a/docs/backtesting.md b/docs/backtesting.md
new file mode 100644
index 00000000..f44cbd8a
--- /dev/null
+++ b/docs/backtesting.md
@@ -0,0 +1,47 @@
+# Backtesting Guide
+
+Comprehensive guide to backtesting trading strategies with the Neural SDK.
+
+## Overview
+
+The backtesting module provides:
+- Event-driven simulation engine
+- Multiple data source support  
+- Realistic portfolio simulation
+- Performance analytics and reporting
+
+## Basic Usage
+
+```python
+from neural_sdk.backtesting import BacktestEngine, BacktestConfig
+
+config = BacktestConfig(
+    start_date="2024-01-01",
+    end_date="2024-12-31",
+    initial_capital=10000
+)
+
+engine = BacktestEngine(config)
+engine.add_strategy(my_strategy)
+engine.load_data("csv", path="historical_data.csv")
+results = engine.run()
+```
+
+## Data Sources
+
+- CSV files
+- Parquet files 
+- S3 buckets (with `pip install neural-sdk[s3]`)
+- SQL databases (with `pip install neural-sdk[database]`)
+
+## Performance Metrics
+
+The engine calculates comprehensive metrics including:
+- Sharpe ratio, Sortino ratio
+- Maximum drawdown
+- Win rate, profit factor
+- Value at Risk (VaR)
+
+## Examples
+
+See `examples/backtest_strategy.py` for detailed examples.
\ No newline at end of file
diff --git a/docs/data_sources.md b/docs/data_sources.md
new file mode 100644
index 00000000..1f4b2ddd
--- /dev/null
+++ b/docs/data_sources.md
@@ -0,0 +1,57 @@
+# Data Sources Guide
+
+Guide to setting up and using different data sources with the Neural SDK.
+
+## Supported Sources
+
+| Source | Installation | Use Case |
+|--------|-------------|----------|
+| CSV Files | Built-in | Local historical data |
+| Parquet Files | `pip install neural-sdk[parquet]` | High-performance data |
+| S3 Buckets | `pip install neural-sdk[s3]` | Cloud data storage |
+| SQL Databases | `pip install neural-sdk[database]` | Large datasets |
+
+## Configuration
+
+### CSV Files
+```python
+from neural_sdk.backtesting import DataLoader
+
+loader = DataLoader()
+data = loader.load("csv", path="trades.csv")
+```
+
+### S3 Buckets
+```python
+data = loader.load("s3", bucket="my-data", prefix="trades/2024/")
+```
+
+### SQL Databases
+```python
+data = loader.load("postgres", 
+    connection_string="postgresql://user:pass@host/db",
+    source="trades_table")
+```
+
+## Custom Data Sources
+
+Create custom data providers by inheriting from `DataProvider`:
+
+```python
+from neural_sdk.backtesting.providers import DataProvider
+
+class MyAPIProvider(DataProvider):
+    def fetch(self, source, **kwargs):
+        # Your custom data loading logic
+        return pd.DataFrame(data)
+```
+
+## Data Format
+
+All data sources must provide:
+- `timestamp` (datetime)
+- `symbol` (string)  
+- `price` (float)
+- `volume` (optional, integer)
+
+See `examples/custom_data_adapter.py` for detailed examples.
\ No newline at end of file
diff --git a/docs/strategies.md b/docs/strategies.md
new file mode 100644
index 00000000..01b9f5cf
--- /dev/null
+++ b/docs/strategies.md
@@ -0,0 +1,91 @@
+# Strategy Development Guide
+
+Learn how to build effective trading strategies with the Neural SDK.
+
+## Strategy Basics
+
+A strategy is a function that receives market data and returns trading signals:
+
+```python
+def my_strategy(market_data):
+    prices = market_data['prices']
+    portfolio = market_data['portfolio']
+    
+    for symbol, price in prices.items():
+        if price < 0.3:  # Undervalued
+            return {
+                'action': 'BUY',
+                'symbol': symbol, 
+                'size': 100
+            }
+    
+    return None  # No action
+```
+
+## Strategy Patterns
+
+### Momentum Strategy
+Buy when price is trending up:
+
+```python
+def momentum_strategy(market_data):
+    # Implementation in examples/backtest_strategy.py
+```
+
+### Mean Reversion  
+Buy undervalued markets:
+
+```python
+def mean_reversion_strategy(market_data):
+    # Implementation in examples/backtest_strategy.py
+```
+
+### Multi-Signal Strategy
+Combine multiple indicators:
+
+```python
+def multi_signal_strategy(market_data):
+    # Access additional data fields
+    data_points = market_data.get('data', [])
+    
+    for point in data_points:
+        volume = point.get('volume', 0)
+        price = point.get('price', 0)
+        
+        # Use volume + price signals
+        if volume > 100 and price < 0.4:
+            return signal
+```
+
+## Risk Management
+
+### Position Sizing
+Use Kelly Criterion with safety factors:
+
+```python
+# Built into BacktestEngine
+config = BacktestConfig(
+    position_size_limit=0.05,  # Max 5% per position
+    daily_loss_limit=0.20      # Stop at 20% daily loss
+)
+```
+
+### Stop Loss
+```python
+def strategy_with_stops(market_data):
+    portfolio = market_data['portfolio']
+    
+    # Check existing positions for stop loss
+    for symbol, position in portfolio.positions.items():
+        if position.unrealized_pnl_pct < -10:  # 10% stop loss
+            return {'action': 'SELL', 'symbol': symbol, 'size': position.quantity}
+```
+
+## Testing Strategies
+
+1. **Backtest** with historical data
+2. **Analyze** performance metrics
+3. **Optimize** parameters  
+4. **Paper trade** before going live
+
+See `examples/backtest_strategy.py` for complete examples.
\ No newline at end of file
diff --git a/examples/agent_redis_consumer.py b/examples/agent_redis_consumer.py
index 6eb40e6d..50436785 100644
--- a/examples/agent_redis_consumer.py
+++ b/examples/agent_redis_consumer.py
@@ -7,53 +7,54 @@
 import asyncio
 import json
 import logging
-import redis.asyncio as redis
-from typing import Dict, Any
 from datetime import datetime
+from typing import Any, Dict
+
+import redis.asyncio as redis
 
 logger = logging.getLogger(__name__)
 
 
 class AgentRedisConsumer:
     """Base class for agents to consume Redis streams"""
-    
+
     def __init__(self, agent_name: str, redis_url: str = "redis://localhost:6379"):
         self.agent_name = agent_name
         self.redis_url = redis_url
         self.redis_client = None
         self.pubsub = None
         self.is_running = False
-        
+
     async def connect(self):
         """Connect to Redis"""
         self.redis_client = redis.from_url(self.redis_url)
         self.pubsub = self.redis_client.pubsub()
         logger.info(f"{self.agent_name} connected to Redis")
-        
+
     async def subscribe(self, channels: list):
         """Subscribe to Redis channels"""
         await self.pubsub.subscribe(*channels)
         logger.info(f"{self.agent_name} subscribed to: {channels}")
-        
+
     async def start_consuming(self):
         """Start consuming messages"""
         self.is_running = True
-        
+
         async for message in self.pubsub.listen():
             if not self.is_running:
                 break
-                
-            if message['type'] == 'message':
-                channel = message['channel'].decode('utf-8')
-                data = json.loads(message['data'])
-                
+
+            if message["type"] == "message":
+                channel = message["channel"].decode("utf-8")
+                data = json.loads(message["data"])
+
                 # Route to appropriate handler
                 await self.handle_message(channel, data)
-                
+
     async def handle_message(self, channel: str, data: Dict[str, Any]):
         """Override in subclass to handle messages"""
         pass
-        
+
     async def stop(self):
         """Stop consuming and disconnect"""
         self.is_running = False
@@ -65,30 +66,30 @@ async def stop(self):
 
 class DataEngineerConsumer(AgentRedisConsumer):
     """Example: DataEngineer agent consuming market data"""
-    
+
     def __init__(self):
         super().__init__("DataEngineer")
         self.market_data = {}
-        
+
     async def handle_message(self, channel: str, data: Dict[str, Any]):
         """Process incoming market data"""
-        
+
         if channel == "kalshi:markets":
             # Store latest market data
-            market_ticker = data['data'].get('market_ticker')
+            market_ticker = data["data"].get("market_ticker")
             if market_ticker:
                 self.market_data[market_ticker] = {
-                    'yes_price': data['data'].get('yes_price'),
-                    'no_price': data['data'].get('no_price'),
-                    'volume': data['data'].get('volume'),
-                    'timestamp': data['timestamp']
+                    "yes_price": data["data"].get("yes_price"),
+                    "no_price": data["data"].get("no_price"),
+                    "volume": data["data"].get("volume"),
+                    "timestamp": data["timestamp"],
                 }
                 logger.info(f"Updated market data for {market_ticker}")
-                
+
         elif channel == "kalshi:signals":
             # High-impact event requiring analysis
-            await self.analyze_signal(data['data'])
-            
+            await self.analyze_signal(data["data"])
+
     async def analyze_signal(self, signal: Dict[str, Any]):
         """Analyze high-impact signals"""
         logger.info(f"Analyzing signal: {signal}")
@@ -97,44 +98,44 @@ async def analyze_signal(self, signal: Dict[str, Any]):
 
 class MarketEngineerConsumer(AgentRedisConsumer):
     """Example: MarketEngineer agent identifying opportunities"""
-    
+
     def __init__(self):
         super().__init__("MarketEngineer")
         self.opportunities = []
-        
+
     async def handle_message(self, channel: str, data: Dict[str, Any]):
         """Look for trading opportunities"""
-        
+
         if channel == "kalshi:markets":
-            market_data = data['data']
-            
+            market_data = data["data"]
+
             # Simple opportunity detection
-            yes_price = market_data.get('yes_price', 0)
-            no_price = market_data.get('no_price', 0)
-            
+            yes_price = market_data.get("yes_price", 0)
+            no_price = market_data.get("no_price", 0)
+
             # Check for arbitrage opportunity
             if yes_price > 0 and no_price > 0:
                 total = yes_price + no_price
                 if total < 0.98:  # Arbitrage opportunity
                     opportunity = {
-                        'type': 'arbitrage',
-                        'market': market_data.get('market_ticker'),
-                        'yes_price': yes_price,
-                        'no_price': no_price,
-                        'profit_potential': 1.0 - total,
-                        'timestamp': datetime.utcnow().isoformat()
+                        "type": "arbitrage",
+                        "market": market_data.get("market_ticker"),
+                        "yes_price": yes_price,
+                        "no_price": no_price,
+                        "profit_potential": 1.0 - total,
+                        "timestamp": datetime.utcnow().isoformat(),
                     }
                     self.opportunities.append(opportunity)
                     logger.info(f"Found arbitrage opportunity: {opportunity}")
-                    
+
                     # Publish opportunity for TradeExecutor
                     await self.publish_opportunity(opportunity)
-                    
+
         elif channel == "espn:games":
             # React to game events
-            game_data = data['data']
+            game_data = data["data"]
             logger.info(f"Game update: {game_data}")
-            
+
     async def publish_opportunity(self, opportunity: Dict[str, Any]):
         """Publish trading opportunity"""
         # In real implementation, publish to Redis or call TradeExecutor
@@ -143,46 +144,46 @@ async def publish_opportunity(self, opportunity: Dict[str, Any]):
 
 class TradeExecutorConsumer(AgentRedisConsumer):
     """Example: TradeExecutor agent placing trades"""
-    
+
     def __init__(self):
         super().__init__("TradeExecutor")
         self.pending_trades = []
-        
+
     async def handle_message(self, channel: str, data: Dict[str, Any]):
         """Execute trades based on signals"""
-        
+
         if channel == "kalshi:signals":
-            signal = data['data']
-            
-            if signal.get('action') == 'BUY':
+            signal = data["data"]
+
+            if signal.get("action") == "BUY":
                 await self.place_order(
-                    market=signal.get('market_ticker'),
-                    side='yes' if signal.get('confidence', 0) > 0.5 else 'no',
-                    quantity=self.calculate_position_size(signal)
+                    market=signal.get("market_ticker"),
+                    side="yes" if signal.get("confidence", 0) > 0.5 else "no",
+                    quantity=self.calculate_position_size(signal),
                 )
-                
+
     def calculate_position_size(self, signal: Dict[str, Any]) -> int:
         """Calculate position size using Kelly Criterion"""
         # Simplified Kelly calculation
-        confidence = signal.get('confidence', 0.5)
+        confidence = signal.get("confidence", 0.5)
         kelly_fraction = confidence - (1 - confidence)
-        
+
         # Apply Kelly with safety factor
         position_size = int(kelly_fraction * 100 * 0.25)  # 25% of Kelly
         return max(1, min(position_size, 100))  # Between 1 and 100
-        
+
     async def place_order(self, market: str, side: str, quantity: int):
         """Place order on Kalshi"""
         logger.info(f"Placing order: {market} {side} x{quantity}")
         # In real implementation, call Kalshi API
-        
+
 
 async def run_agent(agent_class, channels):
     """Run an agent consumer"""
     agent = agent_class()
     await agent.connect()
     await agent.subscribe(channels)
-    
+
     try:
         await agent.start_consuming()
     except KeyboardInterrupt:
@@ -194,45 +195,49 @@ async def run_agent(agent_class, channels):
 async def main():
     """Example of running multiple agents"""
     import sys
-    
+
     # Configure logging
     logging.basicConfig(
         level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
     )
-    
+
     if len(sys.argv) < 2:
         print("Usage: python agent_redis_consumer.py [data|market|trade|all]")
         sys.exit(1)
-        
+
     mode = sys.argv[1]
-    
+
     if mode == "data":
         # Run DataEngineer
         await run_agent(DataEngineerConsumer, ["kalshi:markets", "kalshi:signals"])
-        
+
     elif mode == "market":
         # Run MarketEngineer
         await run_agent(MarketEngineerConsumer, ["kalshi:markets", "espn:games"])
-        
+
     elif mode == "trade":
         # Run TradeExecutor
         await run_agent(TradeExecutorConsumer, ["kalshi:signals"])
-        
+
     elif mode == "all":
         # Run all agents concurrently
         tasks = [
-            asyncio.create_task(run_agent(DataEngineerConsumer, ["kalshi:markets", "kalshi:signals"])),
-            asyncio.create_task(run_agent(MarketEngineerConsumer, ["kalshi:markets", "espn:games"])),
-            asyncio.create_task(run_agent(TradeExecutorConsumer, ["kalshi:signals"]))
+            asyncio.create_task(
+                run_agent(DataEngineerConsumer, ["kalshi:markets", "kalshi:signals"])
+            ),
+            asyncio.create_task(
+                run_agent(MarketEngineerConsumer, ["kalshi:markets", "espn:games"])
+            ),
+            asyncio.create_task(run_agent(TradeExecutorConsumer, ["kalshi:signals"])),
         ]
-        
+
         await asyncio.gather(*tasks)
-        
+
     else:
         print(f"Unknown mode: {mode}")
         sys.exit(1)
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
\ No newline at end of file
+    asyncio.run(main())
diff --git a/examples/backtest_strategy.py b/examples/backtest_strategy.py
new file mode 100644
index 00000000..a1833194
--- /dev/null
+++ b/examples/backtest_strategy.py
@@ -0,0 +1,411 @@
+"""
+Comprehensive Backtesting Example
+
+Demonstrates how to use the Neural SDK backtesting module
+to test trading strategies with historical data.
+"""
+
+import logging
+from datetime import datetime, timedelta
+
+import numpy as np
+import pandas as pd
+
+# Import the SDK
+from neural_sdk.backtesting import BacktestConfig, BacktestEngine, DataLoader
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def momentum_strategy(market_data):
+    """
+    Simple momentum trading strategy.
+
+    Logic:
+    - Buy when price is trending up and below 0.6
+    - Sell when price is trending down and above 0.4
+    - Use simple moving average for trend detection
+
+    Args:
+        market_data: Dictionary with current market information
+
+    Returns:
+        Trading signal dictionary or None
+    """
+    # Get current data
+    current_prices = market_data["prices"]
+    portfolio = market_data["portfolio"]
+
+    # Simple strategy: look for NFL winner markets
+    for symbol in current_prices:
+        if "NFL" in symbol and "WINNER" in symbol:
+            price = current_prices[symbol]
+
+            # Get current position
+            position_size = portfolio.get_position_size(symbol)
+
+            # Buy signal: price low and not already long
+            if price < 0.4 and position_size == 0:
+                return {
+                    "action": "BUY",
+                    "market": symbol,
+                    "size": 100,  # Buy 100 contracts
+                    "reason": f"Price {price:.2f} below buy threshold",
+                }
+
+            # Sell signal: price high and currently long
+            elif price > 0.7 and position_size > 0:
+                return {
+                    "action": "SELL",
+                    "market": symbol,
+                    "size": position_size,  # Sell all
+                    "reason": f"Price {price:.2f} above sell threshold",
+                }
+
+    return None
+
+
+def mean_reversion_strategy(market_data):
+    """
+    Mean reversion strategy example.
+
+    Assumes prices will revert to fair value (0.5) over time.
+
+    Args:
+        market_data: Dictionary with current market information
+
+    Returns:
+        Trading signal dictionary or None
+    """
+    current_prices = market_data["prices"]
+    portfolio = market_data["portfolio"]
+
+    for symbol in current_prices:
+        price = current_prices[symbol]
+        position_size = portfolio.get_position_size(symbol)
+
+        # Calculate distance from fair value (0.5)
+        distance_from_fair = abs(price - 0.5)
+
+        # Only trade if price is significantly away from fair value
+        if distance_from_fair < 0.15:
+            continue
+
+        # Buy undervalued markets
+        if price < 0.35 and position_size == 0:
+            return {
+                "action": "BUY",
+                "market": symbol,
+                "size": 50,
+                "reason": f"Undervalued at {price:.2f}",
+            }
+
+        # Sell overvalued markets
+        elif price > 0.65 and position_size == 0:
+            # Short selling (if supported) or just avoid
+            continue
+
+        # Take profits when price moves toward fair value
+        elif position_size > 0 and 0.45 <= price <= 0.55:
+            return {
+                "action": "SELL",
+                "market": symbol,
+                "size": position_size,
+                "reason": f"Taking profit at {price:.2f}",
+            }
+
+    return None
+
+
+def run_basic_backtest():
+    """Run a basic backtest with sample data."""
+
+    print("=== Basic Backtest Example ===\n")
+
+    # 1. Configure the backtest
+    config = BacktestConfig(
+        start_date="2024-01-01",
+        end_date="2024-03-31",
+        initial_capital=10000.0,
+        commission=0.02,  # Kalshi's 2% fee
+        slippage=0.01,  # 1% slippage
+        position_size_limit=0.10,  # Max 10% per position
+        daily_loss_limit=0.15,  # Stop at 15% daily loss
+    )
+
+    # 2. Initialize the backtesting engine
+    engine = BacktestEngine(config)
+
+    # 3. Add a trading strategy
+    engine.add_strategy(momentum_strategy)
+
+    # 4. Create sample data (in real use, load from your data source)
+    print("Creating sample data...")
+    sample_data = create_sample_data()
+    engine.data = sample_data
+
+    # 5. Run the backtest
+    print("Running backtest...")
+    results = engine.run()
+
+    # 6. Analyze results
+    print("\n=== BACKTEST RESULTS ===")
+    print(f"Initial Capital: ${config.initial_capital:,.2f}")
+    print(f"Final Value: ${results.portfolio_value.iloc[-1]:,.2f}")
+    print(f"Total Return: {results.total_return:.2f}%")
+    print(f"Number of Trades: {results.num_trades}")
+
+    print(f"\n=== KEY METRICS ===")
+    for metric, value in results.metrics.items():
+        if isinstance(value, float):
+            print(f"{metric.replace('_', ' ').title()}: {value:.4f}")
+
+    # 7. Export detailed report
+    results.export_report("backtest_report.html")
+    print(f"\nDetailed report saved to: backtest_report.html")
+
+    return results
+
+
+def run_strategy_comparison():
+    """Compare multiple strategies on the same data."""
+
+    print("\n=== Strategy Comparison Example ===\n")
+
+    # Common configuration
+    config = BacktestConfig(
+        start_date="2024-01-01",
+        end_date="2024-06-30",
+        initial_capital=10000.0,
+        commission=0.02,
+        slippage=0.01,
+    )
+
+    strategies = {
+        "Momentum": momentum_strategy,
+        "Mean Reversion": mean_reversion_strategy,
+    }
+
+    results = {}
+    sample_data = create_sample_data()
+
+    for name, strategy_func in strategies.items():
+        print(f"Testing {name} strategy...")
+
+        engine = BacktestEngine(config)
+        engine.add_strategy(strategy_func)
+        engine.data = sample_data
+
+        result = engine.run()
+        results[name] = result
+
+        print(f"  - Total Return: {result.total_return:.2f}%")
+        print(f"  - Sharpe Ratio: {result.metrics.get('sharpe_ratio', 0):.3f}")
+        print(f"  - Max Drawdown: {result.metrics.get('max_drawdown', 0):.2f}%")
+        print(f"  - Win Rate: {result.metrics.get('win_rate', 0):.1f}%")
+
+    # Find best strategy
+    best_strategy = max(results.keys(), key=lambda x: results[x].total_return)
+
+    print(f"\nBest performing strategy: {best_strategy}")
+    print(f"Return: {results[best_strategy].total_return:.2f}%")
+
+    return results
+
+
+def run_data_source_example():
+    """Example of loading data from different sources."""
+
+    print("\n=== Data Source Example ===\n")
+
+    # Initialize data loader
+    loader = DataLoader(cache_dir="~/.kalshi_sdk/cache")
+
+    # Example 1: Load from CSV file
+    try:
+        print("Loading from CSV...")
+        # Create sample CSV first
+        create_sample_csv("sample_trades.csv")
+
+        data = loader.load("csv", path="sample_trades.csv")
+        print(f"Loaded {len(data)} records from CSV")
+
+    except Exception as e:
+        print(f"CSV loading failed: {e}")
+
+    # Example 2: Load from Parquet (more efficient for large datasets)
+    try:
+        print("Loading from Parquet...")
+
+        # Convert CSV to Parquet for demonstration
+        from kalshi_trading_sdk.backtesting.providers import ParquetProvider
+
+        provider = ParquetProvider()
+        provider.convert_csv_to_parquet("sample_trades.csv", "sample_trades.parquet")
+
+        data = loader.load("parquet", path="sample_trades.parquet")
+        print(f"Loaded {len(data)} records from Parquet")
+
+    except Exception as e:
+        print(f"Parquet loading failed: {e}")
+
+    # Example 3: Cache information
+    cache_info = loader.get_cache_info()
+    print(
+        f"\nCache info: {cache_info.get('files', 0)} files, "
+        f"{cache_info.get('total_size_mb', 0):.1f} MB"
+    )
+
+    return data
+
+
+def create_sample_data():
+    """Create sample market data for backtesting."""
+
+    # Generate timestamps (1 hour intervals for 3 months)
+    start_date = datetime(2024, 1, 1)
+    end_date = datetime(2024, 3, 31)
+    timestamps = pd.date_range(start_date, end_date, freq="1H")
+
+    # Sample NFL markets
+    markets = [
+        "NFL-KC-BUF-WINNER",
+        "NFL-KC-BUF-TOTAL",
+        "NFL-SF-DAL-WINNER",
+        "NFL-SF-DAL-TOTAL",
+    ]
+
+    data_rows = []
+
+    for market in markets:
+        # Create realistic price movement (random walk with mean reversion)
+        initial_price = np.random.uniform(0.35, 0.65)
+        prices = [initial_price]
+
+        for i in range(1, len(timestamps)):
+            # Random walk with mean reversion to 0.5
+            current_price = prices[-1]
+            drift = (0.5 - current_price) * 0.01  # Mean reversion
+            noise = np.random.normal(0, 0.005)  # Random noise
+
+            new_price = current_price + drift + noise
+            new_price = max(0.01, min(0.99, new_price))  # Keep in bounds
+            prices.append(new_price)
+
+        # Create data rows
+        for timestamp, price in zip(timestamps, prices):
+            data_rows.append(
+                {
+                    "timestamp": timestamp,
+                    "symbol": market,
+                    "price": price,
+                    "volume": np.random.randint(50, 500),
+                }
+            )
+
+    return pd.DataFrame(data_rows)
+
+
+def create_sample_csv(filename):
+    """Create a sample CSV file for demonstration."""
+
+    sample_data = create_sample_data()
+    sample_data.to_csv(filename, index=False)
+    print(f"Created sample CSV: {filename}")
+
+
+def analyze_strategy_performance(results):
+    """Detailed analysis of strategy performance."""
+
+    print("\n=== DETAILED PERFORMANCE ANALYSIS ===\n")
+
+    # Portfolio value over time
+    portfolio_values = results.portfolio_value
+
+    # Calculate key statistics
+    total_days = len(portfolio_values)
+    trading_days = (portfolio_values.index[-1] - portfolio_values.index[0]).days
+
+    print(f"Trading Period: {trading_days} days ({total_days} data points)")
+    print(f"Start Value: ${portfolio_values.iloc[0]:,.2f}")
+    print(f"End Value: ${portfolio_values.iloc[-1]:,.2f}")
+    print(f"Peak Value: ${portfolio_values.max():,.2f}")
+
+    # Daily statistics
+    daily_returns = results.daily_returns.dropna()
+    if len(daily_returns) > 0:
+        print(f"\nDaily Return Statistics:")
+        print(f"  Mean: {daily_returns.mean():.3f}%")
+        print(f"  Std Dev: {daily_returns.std():.3f}%")
+        print(f"  Best Day: +{daily_returns.max():.2f}%")
+        print(f"  Worst Day: {daily_returns.min():.2f}%")
+
+        positive_days = (daily_returns > 0).sum()
+        print(
+            f"  Positive Days: {positive_days}/{len(daily_returns)} ({positive_days/len(daily_returns)*100:.1f}%)"
+        )
+
+    # Trade analysis
+    if len(results.trades) > 0:
+        print(f"\nTrade Analysis:")
+        trades_df = pd.DataFrame(
+            [
+                {
+                    "timestamp": t.timestamp,
+                    "symbol": t.symbol,
+                    "action": t.action,
+                    "price": t.price,
+                    "pnl": t.pnl,
+                }
+                for t in results.trades
+            ]
+        )
+
+        buy_trades = trades_df[trades_df["action"] == "BUY"]
+        sell_trades = trades_df[trades_df["action"] == "SELL"]
+
+        print(f"  Total Trades: {len(results.trades)}")
+        print(f"  Buy Orders: {len(buy_trades)}")
+        print(f"  Sell Orders: {len(sell_trades)}")
+
+        if len(sell_trades) > 0:
+            profitable_trades = sell_trades[sell_trades["pnl"] > 0]
+            print(f"  Profitable Trades: {len(profitable_trades)}/{len(sell_trades)}")
+
+            if len(profitable_trades) > 0:
+                print(f"  Average Win: ${profitable_trades['pnl'].mean():.2f}")
+                print(f"  Largest Win: ${profitable_trades['pnl'].max():.2f}")
+
+            losing_trades = sell_trades[sell_trades["pnl"] < 0]
+            if len(losing_trades) > 0:
+                print(f"  Average Loss: ${losing_trades['pnl'].mean():.2f}")
+                print(f"  Largest Loss: ${losing_trades['pnl'].min():.2f}")
+
+
+if __name__ == "__main__":
+    # Run all examples
+
+    print("Kalshi Trading SDK - Backtesting Examples")
+    print("=" * 50)
+
+    # 1. Basic backtest
+    basic_results = run_basic_backtest()
+
+    # 2. Strategy comparison
+    comparison_results = run_strategy_comparison()
+
+    # 3. Data loading examples
+    data_example = run_data_source_example()
+
+    # 4. Detailed analysis
+    analyze_strategy_performance(basic_results)
+
+    print("\n" + "=" * 50)
+    print("Examples completed successfully!")
+    print("\nNext steps:")
+    print("1. Modify the strategies to implement your own logic")
+    print("2. Load your own historical data")
+    print("3. Experiment with different configuration parameters")
+    print("4. Use the performance metrics to optimize your strategies")
diff --git a/examples/basic_usage.py b/examples/basic_usage.py
new file mode 100644
index 00000000..d9900e4d
--- /dev/null
+++ b/examples/basic_usage.py
@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+Basic usage example for the Neural SDK.
+
+This example demonstrates:
+- SDK initialization
+- Configuration management
+- Basic trading strategy creation
+- Event handling
+- System startup and monitoring
+"""
+
+import asyncio
+import logging
+from typing import Optional
+
+from neural_sdk import MarketData, NeuralSDK, TradingSignal
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def main():
+    """Main example function demonstrating SDK usage."""
+
+    # Initialize SDK from environment variables
+    logger.info("Initializing Neural SDK...")
+    sdk = NeuralSDK.from_env()
+
+    # Example 1: Simple arbitrage strategy
+    @sdk.strategy
+    async def arbitrage_strategy(market_data: MarketData) -> Optional[TradingSignal]:
+        """
+        Simple arbitrage strategy that looks for pricing inefficiencies.
+
+        If the sum of YES and NO prices is less than 0.98 (allowing for fees),
+        there's an arbitrage opportunity.
+        """
+        total_price = market_data.yes_price + market_data.no_price
+
+        if total_price < 0.98:
+            # Arbitrage opportunity detected
+            logger.info(
+                f"Arbitrage opportunity: {market_data.ticker} = {total_price:.3f}"
+            )
+
+            return sdk.create_signal(
+                action="BUY",
+                market_ticker=market_data.ticker,
+                side="YES",  # Buy YES, sell NO would be arbitrage
+                confidence=min(0.9, (0.98 - total_price) * 50),  # Scale confidence
+                quantity=100,
+                reason=f"Arbitrage: total price {total_price:.3f} < 0.98",
+            )
+
+        return None
+
+    # Example 2: Momentum-based strategy
+    @sdk.strategy
+    async def momentum_strategy(market_data: MarketData) -> Optional[TradingSignal]:
+        """
+        Momentum strategy based on extreme price movements.
+
+        Buys when price drops below 30% (oversold)
+        Sells when price rises above 70% (overbought)
+        """
+        if market_data.yes_price < 0.3:
+            # Potentially oversold - buy signal
+            return sdk.create_signal(
+                action="BUY",
+                market_ticker=market_data.ticker,
+                side="YES",
+                confidence=0.7,
+                quantity=50,
+                reason=f"Oversold signal: price {market_data.yes_price:.3f} < 0.3",
+            )
+
+        elif market_data.yes_price > 0.7:
+            # Potentially overbought - sell signal
+            return sdk.create_signal(
+                action="SELL",
+                market_ticker=market_data.ticker,
+                side="YES",
+                confidence=0.7,
+                quantity=50,
+                reason=f"Overbought signal: price {market_data.yes_price:.3f} > 0.7",
+            )
+
+        return None
+
+    # Example 3: Market data event handler
+    @sdk.on_market_data
+    async def log_market_updates(market_data: MarketData):
+        """Log significant market data updates."""
+        if market_data.yes_price > 0.8 or market_data.yes_price < 0.2:
+            logger.info(
+                f"Extreme price: {market_data.ticker} = {market_data.yes_price:.3f}"
+            )
+
+    # Example 4: Trading signal event handler
+    @sdk.on_signal
+    async def log_signals(signal: TradingSignal):
+        """Log generated trading signals."""
+        logger.info(
+            f"Signal generated: {signal.action} {signal.market_ticker} "
+            f"(confidence: {signal.confidence:.2f})"
+        )
+
+    # Example 5: Trade execution event handler
+    @sdk.on_trade
+    async def log_trades(trade_result):
+        """Log trade execution results."""
+        logger.info(
+            f"Trade {trade_result.status}: {trade_result.market_ticker} "
+            f"x{trade_result.quantity} @ {trade_result.price:.3f}"
+        )
+
+    # Display system status
+    status = sdk.get_system_status()
+    logger.info(f"System status: {status}")
+
+    # Start the trading system
+    logger.info("Starting trading system...")
+    try:
+        await sdk.start_trading_system()
+    except KeyboardInterrupt:
+        logger.info("Received shutdown signal...")
+    finally:
+        # Graceful shutdown
+        await sdk.stop_trading_system()
+        logger.info("Trading system shut down gracefully")
+
+
+async def advanced_example():
+    """Advanced example with custom configuration and multiple strategies."""
+
+    # Custom configuration
+    from kalshi_trading_sdk import SDKConfig
+
+    config = SDKConfig(
+        environment="development",
+        risk_limits__max_position_size_pct=0.03,  # More conservative
+        trading__default_quantity=25,
+        data__redis_url="redis://localhost:6379",
+    )
+
+    sdk = KalshiSDK(config)
+
+    # Advanced strategy with risk management
+    @sdk.strategy
+    async def risk_aware_strategy(market_data: MarketData) -> Optional[TradingSignal]:
+        """Strategy that considers portfolio risk and market conditions."""
+
+        # Check if we have capacity for this trade
+        portfolio_status = await sdk.get_portfolio_status()
+        exposure_pct = portfolio_status.get("exposure_pct", 0)
+
+        # Don't trade if we're already heavily exposed
+        if exposure_pct > 0.8:  # 80% of max exposure
+            return None
+
+        # Only trade high-confidence opportunities
+        if market_data.yes_price < 0.25 and market_data.volume > 1000:
+            return sdk.create_signal(
+                action="BUY",
+                market_ticker=market_data.ticker,
+                side="YES",
+                confidence=0.8,
+                quantity=25,
+                reason="High-confidence oversold with volume",
+            )
+
+        return None
+
+    # Monitor portfolio health
+    @sdk.on_market_data
+    async def monitor_portfolio_health(market_data: MarketData):
+        """Monitor overall portfolio health."""
+        portfolio = await sdk.get_portfolio_status()
+
+        if portfolio["daily_pnl"] < -100:  # Stop loss threshold
+            logger.warning(f"Daily P&L concerning: ${portfolio['daily_pnl']:.2f}")
+
+        if portfolio["exposure_pct"] > 0.9:  # High exposure warning
+            logger.warning(f"High exposure: {portfolio['exposure_pct']:.1%}")
+
+    logger.info("Starting advanced trading system...")
+    try:
+        await sdk.start_trading_system()
+    except KeyboardInterrupt:
+        logger.info("Shutting down...")
+    finally:
+        await sdk.stop_trading_system()
+
+
+if __name__ == "__main__":
+    # Run basic example
+    asyncio.run(main())
+
+    # Uncomment to run advanced example
+    # asyncio.run(advanced_example())
diff --git a/examples/custom_data_adapter.py b/examples/custom_data_adapter.py
new file mode 100644
index 00000000..e4a496c5
--- /dev/null
+++ b/examples/custom_data_adapter.py
@@ -0,0 +1,447 @@
+"""
+Custom Data Adapter Example
+
+Shows how to create a custom data provider for the backtesting module.
+This example demonstrates connecting to a REST API for historical data.
+"""
+
+import json
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+import requests
+
+from neural_sdk.backtesting import BacktestConfig, BacktestEngine
+from neural_sdk.backtesting.providers.base import DataError, DataProvider
+
+logger = logging.getLogger(__name__)
+
+
+class APIProvider(DataProvider):
+    """
+    Custom data provider that fetches historical data from prediction market APIs.
+
+    This is a demonstration of how to create your own data provider
+    for any data source (API, database, file format, etc.).
+    """
+
+    def __init__(self, api_key: str = None, base_url: str = None, **kwargs):
+        """
+        Initialize Kalshi API provider.
+
+        Args:
+            api_key: Kalshi API key (if required)
+            base_url: Base URL for Kalshi API
+        """
+        super().__init__(**kwargs)
+
+        self.api_key = api_key
+        self.base_url = base_url or "https://trading-api.kalshi.com/trade-api/v2"
+
+        # Set up session with authentication
+        self.session = requests.Session()
+        if api_key:
+            self.session.headers.update(
+                {
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json",
+                }
+            )
+
+    def fetch(
+        self,
+        source: str,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Fetch historical data from Kalshi API.
+
+        Args:
+            source: API endpoint or market category (e.g., 'markets', 'trades')
+            symbols: List of market tickers
+            start: Start date (YYYY-MM-DD)
+            end: End date (YYYY-MM-DD)
+
+        Returns:
+            DataFrame with standardized columns
+        """
+        try:
+            # Build API request parameters
+            params = {}
+            if start:
+                params["start_date"] = start
+            if end:
+                params["end_date"] = end
+            if symbols:
+                params["tickers"] = ",".join(symbols)
+
+            # Construct URL
+            url = f"{self.base_url}/{source}"
+
+            # Make API request
+            logger.info(f"Fetching data from Kalshi API: {url}")
+            response = self.session.get(url, params=params)
+            response.raise_for_status()
+
+            # Parse response
+            data = response.json()
+
+            # Convert to DataFrame
+            if source == "markets":
+                df = self._parse_markets_response(data)
+            elif source == "trades":
+                df = self._parse_trades_response(data)
+            else:
+                # Generic parser
+                df = self._parse_generic_response(data)
+
+            # Clean and validate
+            df = self.clean_data(df)
+            self.validate(df)
+
+            logger.info(f"Fetched {len(df)} records from Kalshi API")
+            return df
+
+        except requests.RequestException as e:
+            logger.error(f"API request failed: {e}")
+            raise DataError(f"Failed to fetch from Kalshi API: {e}")
+        except Exception as e:
+            logger.error(f"Data parsing failed: {e}")
+            raise DataError(f"Failed to parse Kalshi API response: {e}")
+
+    def _parse_markets_response(self, data: Dict) -> pd.DataFrame:
+        """Parse markets API response."""
+        markets = data.get("markets", [])
+
+        records = []
+        for market in markets:
+            records.append(
+                {
+                    "timestamp": datetime.now(),  # Use current time or market timestamp
+                    "symbol": market.get("ticker"),
+                    "price": market.get("yes_price", 0)
+                    / 100,  # Convert cents to dollars
+                    "volume": market.get("volume", 0),
+                    "open_interest": market.get("open_interest", 0),
+                    "status": market.get("status"),
+                }
+            )
+
+        return pd.DataFrame(records)
+
+    def _parse_trades_response(self, data: Dict) -> pd.DataFrame:
+        """Parse trades API response."""
+        trades = data.get("trades", [])
+
+        records = []
+        for trade in trades:
+            records.append(
+                {
+                    "timestamp": pd.to_datetime(trade.get("timestamp")),
+                    "symbol": trade.get("ticker"),
+                    "price": trade.get("price", 0) / 100,  # Convert cents to dollars
+                    "volume": trade.get("count", 1),
+                    "side": trade.get("side"),  # YES/NO
+                }
+            )
+
+        return pd.DataFrame(records)
+
+    def _parse_generic_response(self, data: Dict) -> pd.DataFrame:
+        """Generic response parser."""
+        # Handle different response formats
+        if isinstance(data, list):
+            return pd.DataFrame(data)
+        elif "data" in data:
+            return pd.DataFrame(data["data"])
+        else:
+            return pd.DataFrame([data])
+
+
+class MockAPIProvider(DataProvider):
+    """
+    Mock API provider for demonstration purposes.
+    Simulates an external data API without actually making network calls.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def fetch(
+        self,
+        source: str,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        **kwargs,
+    ) -> pd.DataFrame:
+        """Generate mock API data."""
+
+        from datetime import datetime, timedelta
+
+        import numpy as np
+
+        # Generate date range
+        start_date = pd.to_datetime(start) if start else datetime(2024, 1, 1)
+        end_date = pd.to_datetime(end) if end else datetime(2024, 3, 31)
+
+        # Default symbols if none provided
+        if not symbols:
+            symbols = ["NFL-CHIEFS-WINNER", "NBA-LAKERS-WINNER", "PRES-2024-WINNER"]
+
+        # Generate hourly data
+        timestamps = pd.date_range(start_date, end_date, freq="1H")
+
+        records = []
+        for symbol in symbols:
+            # Create realistic price series
+            initial_price = np.random.uniform(0.3, 0.7)
+            prices = [initial_price]
+
+            for i in range(1, len(timestamps)):
+                # Random walk with slight trend
+                change = np.random.normal(0, 0.01)
+                new_price = max(0.01, min(0.99, prices[-1] + change))
+                prices.append(new_price)
+
+            # Create records
+            for timestamp, price in zip(timestamps, prices):
+                records.append(
+                    {
+                        "timestamp": timestamp,
+                        "symbol": symbol,
+                        "price": price,
+                        "volume": np.random.randint(10, 200),
+                        "source": "mock_api",
+                    }
+                )
+
+        return pd.DataFrame(records)
+
+
+class DatabaseProvider(DataProvider):
+    """
+    Database data provider example.
+    Shows how to load data from SQL databases.
+    """
+
+    def __init__(self, connection_string: str, **kwargs):
+        super().__init__(**kwargs)
+        self.connection_string = connection_string
+
+    def fetch(
+        self,
+        source: str,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Fetch data from database.
+
+        Args:
+            source: SQL query or table name
+            symbols: Filter symbols in query
+            start: Start date filter
+            end: End date filter
+        """
+        try:
+            import sqlalchemy
+
+            engine = sqlalchemy.create_engine(self.connection_string)
+
+            # Build query
+            if source.upper().startswith("SELECT"):
+                # Custom SQL query
+                query = source
+            else:
+                # Table name - build query
+                query = f"SELECT * FROM {source}"
+                conditions = []
+
+                if start:
+                    conditions.append(f"timestamp >= '{start}'")
+                if end:
+                    conditions.append(f"timestamp <= '{end}'")
+                if symbols:
+                    symbol_list = "', '".join(symbols)
+                    conditions.append(f"symbol IN ('{symbol_list}')")
+
+                if conditions:
+                    query += " WHERE " + " AND ".join(conditions)
+
+            # Execute query
+            df = pd.read_sql(query, engine)
+
+            # Ensure timestamp is datetime
+            if "timestamp" in df.columns:
+                df["timestamp"] = pd.to_datetime(df["timestamp"])
+
+            logger.info(f"Loaded {len(df)} records from database")
+            return df
+
+        except ImportError:
+            raise DataError(
+                "Database provider requires SQLAlchemy: pip install sqlalchemy"
+            )
+        except Exception as e:
+            raise DataError(f"Database query failed: {e}")
+
+
+def advanced_strategy_with_custom_data(market_data):
+    """
+    Advanced strategy that uses additional data fields from custom provider.
+
+    Demonstrates how to access custom fields in your strategy logic.
+    """
+    prices = market_data["prices"]
+    portfolio = market_data["portfolio"]
+
+    # Access the raw data to get additional fields
+    raw_data = market_data.get("data", [])
+
+    for data_point in raw_data:
+        symbol = data_point.get("symbol")
+        price = data_point.get("price")
+        volume = data_point.get("volume", 0)
+
+        if symbol not in prices:
+            continue
+
+        # Strategy logic using volume data
+        if volume > 100:  # High volume threshold
+            current_position = portfolio.get_position_size(symbol)
+
+            # Buy high-volume, low-price opportunities
+            if price < 0.35 and current_position == 0:
+                return {
+                    "action": "BUY",
+                    "market": symbol,
+                    "size": min(200, int(volume * 0.5)),  # Size based on volume
+                    "reason": f"High volume ({volume}) + low price ({price:.2f})",
+                }
+
+            # Sell when price high regardless of volume
+            elif price > 0.75 and current_position > 0:
+                return {
+                    "action": "SELL",
+                    "market": symbol,
+                    "size": current_position,
+                    "reason": f"High price exit at {price:.2f}",
+                }
+
+    return None
+
+
+def run_custom_provider_example():
+    """Demonstrate custom data provider usage."""
+
+    print("=== Custom Data Provider Example ===\n")
+
+    # 1. Test Mock API Provider
+    print("Testing Mock API Provider...")
+    mock_provider = MockAPIProvider()
+
+    mock_data = mock_provider.fetch(
+        source="markets",
+        symbols=["NFL-KC-BUF-WINNER", "NBA-LAL-GSW-WINNER"],
+        start="2024-01-01",
+        end="2024-01-31",
+    )
+
+    print(f"Mock API returned {len(mock_data)} records")
+    print(f"Columns: {list(mock_data.columns)}")
+    print(
+        f"Date range: {mock_data['timestamp'].min()} to {mock_data['timestamp'].max()}"
+    )
+
+    # 2. Register custom provider with data loader
+    from kalshi_trading_sdk.backtesting import DataLoader
+
+    loader = DataLoader()
+    loader.providers["mock_api"] = mock_provider
+
+    # Load data through the loader
+    loaded_data = loader.load("mock_api", source="markets")
+    print(f"Data loader returned {len(loaded_data)} records")
+
+    # 3. Run backtest with custom data
+    print("\nRunning backtest with custom data...")
+
+    config = BacktestConfig(
+        start_date="2024-01-01",
+        end_date="2024-01-31",
+        initial_capital=10000.0,
+        commission=0.02,
+    )
+
+    engine = BacktestEngine(config)
+    engine.add_strategy(advanced_strategy_with_custom_data)
+    engine.data = loaded_data
+
+    results = engine.run()
+
+    print(f"Backtest Results:")
+    print(f"  Total Return: {results.total_return:.2f}%")
+    print(f"  Number of Trades: {results.num_trades}")
+    print(f"  Sharpe Ratio: {results.metrics.get('sharpe_ratio', 0):.3f}")
+
+    return results
+
+
+def create_custom_csv_provider():
+    """Example of customizing the CSV provider."""
+
+    from kalshi_trading_sdk.backtesting.providers import CSVProvider
+
+    # Custom column mapping for your specific CSV format
+    custom_csv = CSVProvider(
+        column_mapping={
+            "date_time": "timestamp",
+            "market_id": "symbol",
+            "last_price": "price",
+            "traded_volume": "volume",
+            "bid_price": "bid",
+            "ask_price": "ask",
+        },
+        csv_options={"sep": "\t", "decimal": ".", "thousands": ","},  # Tab-separated
+    )
+
+    print("Custom CSV provider created with tab-separated format")
+    return custom_csv
+
+
+if __name__ == "__main__":
+
+    print("Kalshi Trading SDK - Custom Data Provider Examples")
+    print("=" * 55)
+
+    # Set up logging
+    logging.basicConfig(level=logging.INFO)
+
+    try:
+        # Run the main example
+        results = run_custom_provider_example()
+
+        # Show how to customize existing providers
+        custom_csv = create_custom_csv_provider()
+
+        print("\n" + "=" * 55)
+        print("Custom provider examples completed!")
+        print("\nKey takeaways:")
+        print("1. Inherit from DataProvider base class")
+        print("2. Implement the fetch() method")
+        print("3. Return DataFrame with standard columns (timestamp, symbol, price)")
+        print("4. Add custom columns for advanced strategies")
+        print("5. Register provider with DataLoader for easy use")
+
+    except Exception as e:
+        logger.error(f"Example failed: {e}")
+        print(f"\nExample failed: {e}")
+        print("This is normal if you don't have all dependencies installed.")
diff --git a/examples/espn_playbyplay.py b/examples/espn_playbyplay.py
index ca75a3f7..8979a96d 100644
--- a/examples/espn_playbyplay.py
+++ b/examples/espn_playbyplay.py
@@ -5,6 +5,7 @@
 
 import asyncio
 import logging
+
 from data_pipeline.data_sources.espn import ESPNClient, ESPNStreamAdapter, EventType
 from data_pipeline.utils import setup_logging
 
@@ -13,63 +14,71 @@ async def fetch_game_data():
     """Example of fetching play-by-play data for a specific game"""
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
+
     client = ESPNClient()
-    
+
     try:
         # Get live NFL games
         logger.info("Fetching live NFL games...")
         live_games = await client.get_live_games("nfl")
-        
+
         if not live_games:
             logger.info("No live games found. Fetching recent games...")
             scoreboard = await client.get_scoreboard("nfl")
-            games = scoreboard.get('events', [])[:3]  # Get first 3 games
-            
+            games = scoreboard.get("events", [])[:3]  # Get first 3 games
+
             for game in games:
-                game_id = game['id']
+                game_id = game["id"]
                 logger.info(f"\nGame: {game.get('name', 'Unknown')}")
-                
+
                 # Get play-by-play
                 pbp = await client.get_play_by_play(game_id)
-                
+
                 logger.info(f"  Total Plays: {pbp['total_plays']}")
                 logger.info(f"  Scoring Plays: {len(pbp['scoring_plays'])}")
                 logger.info(f"  High Impact Plays: {len(pbp['high_impact_plays'])}")
-                
+
                 # Show some high-impact plays
-                for play in pbp['high_impact_plays'][:3]:
+                for play in pbp["high_impact_plays"][:3]:
                     logger.info(f"    → {play.text} (Impact: {play.impact_score:.2f})")
         else:
             # Analyze live game
             game = live_games[0]
-            game_id = game['id']
+            game_id = game["id"]
             logger.info(f"\nLive Game: {game['name']}")
             logger.info(f"  Status: Q{game['period']} - {game['clock']}")
-            
+
             # Get detailed data
             pbp = await client.get_play_by_play(game_id)
-            game_state = pbp['game_state']
-            
+            game_state = pbp["game_state"]
+
             logger.info("\nGame State:")
-            logger.info(f"  Score: {game_state.home_team} {game_state.home_score} - {game_state.away_team} {game_state.away_score}")
-            logger.info(f"  Win Probability: {game_state.home_team} {game_state.home_win_probability:.1f}%")
-            logger.info(f"  Situation: {game_state.down} & {game_state.distance} at {game_state.yard_line}")
-            
+            logger.info(
+                f"  Score: {game_state.home_team} {game_state.home_score} - {game_state.away_team} {game_state.away_score}"
+            )
+            logger.info(
+                f"  Win Probability: {game_state.home_team} {game_state.home_win_probability:.1f}%"
+            )
+            logger.info(
+                f"  Situation: {game_state.down} & {game_state.distance} at {game_state.yard_line}"
+            )
+
             # Get recent high-impact plays
             logger.info("\nRecent High-Impact Plays:")
-            for play in pbp['high_impact_plays'][-5:]:
+            for play in pbp["high_impact_plays"][-5:]:
                 logger.info(f"  {play.quarter}Q {play.clock}: {play.text[:100]}...")
                 logger.info(f"    Events: {[e.value for e in play.events]}")
                 logger.info(f"    Impact Score: {play.impact_score:.2f}")
-            
+
             # Get injuries
             injuries = await client.get_injuries(game_id)
             if injuries:
                 logger.info("\nInjuries (Market Impact):")
                 for injury in injuries:
-                    logger.info(f"  {injury['player']} ({injury['team']}): {injury['status']}")
-    
+                    logger.info(
+                        f"  {injury['player']} ({injury['team']}): {injury['status']}"
+                    )
+
     finally:
         await client.close()
 
@@ -78,7 +87,7 @@ async def stream_live_games():
     """Example of streaming live game events"""
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
+
     # Event handler
     async def handle_game_event(event):
         # Only log high-impact events
@@ -87,9 +96,13 @@ async def handle_game_event(event):
             logger.info(f"  Type: {event.type.value}")
             logger.info(f"  Description: {event.description}")
             logger.info(f"  Impact Score: {event.impact_score:.2f}")
-            logger.info(f"  Game State: {event.game_state.home_team} {event.game_state.home_score} - {event.game_state.away_team} {event.game_state.away_score}")
-            logger.info(f"  Win Prob: {event.game_state.home_team} {event.game_state.home_win_probability:.1f}%")
-            
+            logger.info(
+                f"  Game State: {event.game_state.home_team} {event.game_state.home_score} - {event.game_state.away_team} {event.game_state.away_score}"
+            )
+            logger.info(
+                f"  Win Prob: {event.game_state.home_team} {event.game_state.home_win_probability:.1f}%"
+            )
+
             # Special alerts for critical events
             if event.type == EventType.TOUCHDOWN:
                 logger.info("  💥 TOUCHDOWN! Major market impact expected!")
@@ -97,22 +110,22 @@ async def handle_game_event(event):
                 logger.info("  🔄 INTERCEPTION! Momentum shift detected!")
             elif event.type == EventType.INJURY:
                 logger.info("  🚑 INJURY! Check for market overreaction!")
-    
+
     # Create stream adapter
     stream = ESPNStreamAdapter(on_event=handle_game_event)
-    
+
     try:
         # Start streaming
         await stream.start()
-        
+
         # Monitor all NFL games
         logger.info("Starting NFL game monitoring...")
         await stream.monitor_sport("nfl")
-        
+
         # Run for 5 minutes
         logger.info("Streaming live events for 5 minutes...")
         await asyncio.sleep(300)
-        
+
     finally:
         await stream.stop()
 
@@ -121,71 +134,77 @@ async def analyze_game_momentum():
     """Example of analyzing game momentum and critical situations"""
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
+
     client = ESPNClient()
-    
+
     try:
         # Get a game
         scoreboard = await client.get_scoreboard("nfl")
-        games = scoreboard.get('events', [])
-        
+        games = scoreboard.get("events", [])
+
         if not games:
             logger.info("No games available")
             return
-        
+
         game = games[0]
-        game_id = game['id']
+        game_id = game["id"]
         logger.info(f"Analyzing: {game.get('name', 'Unknown')}")
-        
+
         # Get win probability history
         win_prob_history = await client.get_win_probability_history(game_id)
-        
+
         if win_prob_history:
             logger.info("\nWin Probability Swings:")
-            
+
             # Find biggest swings
             biggest_swing = 0
             swing_play = None
-            
+
             for i in range(1, len(win_prob_history)):
-                prev = win_prob_history[i-1]
+                prev = win_prob_history[i - 1]
                 curr = win_prob_history[i]
-                
-                swing = abs(curr['home_win_percentage'] - prev['home_win_percentage'])
+
+                swing = abs(curr["home_win_percentage"] - prev["home_win_percentage"])
                 if swing > biggest_swing:
                     biggest_swing = swing
                     swing_play = curr
-            
+
             if swing_play:
                 logger.info(f"  Biggest Swing: {biggest_swing:.1f}%")
                 logger.info(f"  Play: {swing_play['play_text'][:100]}...")
-            
+
             # Current probability
             if win_prob_history:
                 current = win_prob_history[-1]
                 logger.info("\nCurrent Win Probability:")
                 logger.info(f"  Home: {current['home_win_percentage']:.1f}%")
                 logger.info(f"  Away: {current['away_win_percentage']:.1f}%")
-        
+
         # Get game leaders
         leaders = await client.get_game_leaders(game_id)
-        
+
         if leaders:
             logger.info("\nGame Leaders (Key Players):")
             for category, players in leaders.items():
                 if players:
                     leader = players[0]
-                    logger.info(f"  {category}: {leader['player']} - {leader['displayValue']}")
-        
+                    logger.info(
+                        f"  {category}: {leader['player']} - {leader['displayValue']}"
+                    )
+
         # Get scoring plays
         scoring_plays = await client.get_scoring_plays(game_id)
-        
+
         if scoring_plays:
             logger.info("\nScoring Summary:")
             for play in scoring_plays[-5:]:  # Last 5 scores
-                logger.info(f"  Q{play['quarter']} {play['clock']}: {play['text'][:80]}...")
-                logger.info(f"    Score after: {play['home_score']}-{play['away_score']}")
-    
+                logger.info(
+                    f"  Q{play['quarter']} {play['clock']}: {play['text'][:80]}..."
+                )
+                logger.info(
+                    f"    Score after: {play['home_score']}-{play['away_score']}"
+                )
+
     finally:
         await client.close()
 
@@ -195,27 +214,27 @@ async def main():
     print("=" * 60)
     print("ESPN Play-by-Play Examples")
     print("=" * 60)
-    
+
     print("\n1. Fetching Game Data...")
     print("-" * 40)
     await fetch_game_data()
-    
+
     print("\n2. Analyzing Game Momentum...")
     print("-" * 40)
     await analyze_game_momentum()
-    
+
     print("\n3. Streaming Live Events (30 seconds demo)...")
     print("-" * 40)
-    
+
     # Create a shorter streaming demo
     stream = ESPNStreamAdapter()
     await stream.start()
     await stream.monitor_sport("nfl")
     await asyncio.sleep(30)  # 30 second demo
     await stream.stop()
-    
+
     print("\n✅ Examples completed!")
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
\ No newline at end of file
+    asyncio.run(main())
diff --git a/examples/fetch_markets.py b/examples/fetch_markets.py
index cbbe89cd..6c998d95 100644
--- a/examples/fetch_markets.py
+++ b/examples/fetch_markets.py
@@ -3,6 +3,7 @@
 """
 
 import logging
+
 from data_pipeline.data_sources.kalshi import KalshiClient
 from data_pipeline.utils import setup_logging
 
@@ -11,32 +12,32 @@ def main():
     # Setup logging
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
+
     # Create HTTP client
     client = KalshiClient()
-    
+
     try:
         # Get first 10 markets
         logger.info("Fetching first 10 markets...")
         response = client.get_markets(limit=10)
-        
-        markets = response.get('markets', [])
+
+        markets = response.get("markets", [])
         logger.info(f"Found {len(markets)} markets")
-        
+
         for market in markets:
-            ticker = market.get('ticker')
-            title = market.get('title')
-            status = market.get('status')
+            ticker = market.get("ticker")
+            title = market.get("title")
+            status = market.get("status")
             logger.info(f"  {ticker}: {title} (Status: {status})")
-        
+
         # Get all markets with pagination
         logger.info("\nFetching all markets with pagination...")
         all_markets = client.get_all_markets(batch_size=100)
         logger.info(f"Total markets found: {len(all_markets)}")
-        
+
     finally:
         client.close()
 
 
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    main()
diff --git a/examples/market_correlation.py b/examples/market_correlation.py
index 6f7bb756..5c0c9e8d 100644
--- a/examples/market_correlation.py
+++ b/examples/market_correlation.py
@@ -5,8 +5,9 @@
 
 import asyncio
 import logging
-from data_pipeline.unified_stream import UnifiedStreamManager, MarketCorrelation
+
 from data_pipeline.data_sources.espn.models import EventType
+from data_pipeline.unified_stream import MarketCorrelation, UnifiedStreamManager
 from data_pipeline.utils import setup_logging
 
 
@@ -14,68 +15,76 @@ async def track_game_with_markets():
     """Example of tracking a specific game with its Kalshi markets"""
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
+
     manager = UnifiedStreamManager()
-    
+
     # Track correlations
     correlations_found = []
-    
+
     async def handle_correlation(correlation: MarketCorrelation):
         """Handle detected correlations"""
         correlations_found.append(correlation)
-        
+
         logger.info("=" * 60)
         logger.info("🎯 MARKET CORRELATION DETECTED!")
         logger.info(f"Game Event: {correlation.event.type.value}")
         logger.info(f"Description: {correlation.event.description}")
         logger.info(f"Impact Score: {correlation.event.impact_score:.2f}")
         logger.info(f"Market: {correlation.market_ticker}")
-        logger.info(f"Price Movement: {correlation.price_before:.3f} → {correlation.price_after:.3f}")
+        logger.info(
+            f"Price Movement: {correlation.price_before:.3f} → {correlation.price_after:.3f}"
+        )
         logger.info(f"Change: {correlation.price_change_pct:+.2f}%")
         logger.info(f"Latency: {correlation.latency_ms}ms")
         logger.info("=" * 60)
-    
+
     async def handle_game_event(event):
         """Handle game events"""
         if event.impact_score > 0.6:
-            logger.info(f"⚡ High Impact Event: {event.description} (Score: {event.impact_score:.2f})")
-    
+            logger.info(
+                f"⚡ High Impact Event: {event.description} (Score: {event.impact_score:.2f})"
+            )
+
     async def handle_market_update(update):
         """Handle market updates"""
-        if abs(update['change']) > 0.02:  # Log significant changes
-            logger.info(f"📊 Market Move: {update['ticker']} {update['change']:+.3f} to {update['price']:.3f}")
-    
+        if abs(update["change"]) > 0.02:  # Log significant changes
+            logger.info(
+                f"📊 Market Move: {update['ticker']} {update['change']:+.3f} to {update['price']:.3f}"
+            )
+
     # Set callbacks
     manager.on_correlation = handle_correlation
     manager.on_game_event = handle_game_event
     manager.on_market_update = handle_market_update
-    
+
     try:
         await manager.start()
-        
+
         # Example: Track an NFL game with winner and total points markets
         # You would replace these with actual game ID and market tickers
         game_id = "401547435"  # Example game ID
         market_tickers = [
             "NFL-2024-WEEK1-HOMETEAM-WIN",  # Home team win market
-            "NFL-2024-WEEK1-TOTAL-OVER-45"  # Total points over/under
+            "NFL-2024-WEEK1-TOTAL-OVER-45",  # Total points over/under
         ]
-        
+
         logger.info(f"Tracking game {game_id} with markets: {market_tickers}")
         await manager.track_game(game_id, market_tickers, "nfl")
-        
+
         # Run for 2 minutes
         await asyncio.sleep(120)
-        
+
         # Print correlation summary
         if correlations_found:
             logger.info("\n" + "=" * 60)
             logger.info("CORRELATION SUMMARY")
             logger.info("=" * 60)
-            
+
             for corr in correlations_found:
-                logger.info(f"• {corr.event.type.value}: {corr.price_change_pct:+.2f}% on {corr.market_ticker}")
-            
+                logger.info(
+                    f"• {corr.event.type.value}: {corr.price_change_pct:+.2f}% on {corr.market_ticker}"
+                )
+
             # Calculate average impact by event type
             by_type = {}
             for corr in correlations_found:
@@ -83,12 +92,12 @@ async def handle_market_update(update):
                 if event_type not in by_type:
                     by_type[event_type] = []
                 by_type[event_type].append(abs(corr.price_change_pct))
-            
+
             logger.info("\nAverage Price Impact by Event Type:")
             for event_type, changes in by_type.items():
                 avg_change = sum(changes) / len(changes)
                 logger.info(f"  {event_type.value}: {avg_change:.2f}%")
-    
+
     finally:
         await manager.stop()
 
@@ -97,70 +106,73 @@ async def monitor_all_nfl_games():
     """Example of monitoring all NFL games for patterns"""
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
+
     manager = UnifiedStreamManager()
-    
+
     # Pattern tracking
     touchdown_impacts = []
     turnover_impacts = []
-    
+
     async def handle_correlation(correlation: MarketCorrelation):
         """Track patterns in correlations"""
         if correlation.event.type == EventType.TOUCHDOWN:
             touchdown_impacts.append(abs(correlation.price_change_pct))
         elif correlation.event.type in [EventType.INTERCEPTION, EventType.FUMBLE]:
             turnover_impacts.append(abs(correlation.price_change_pct))
-        
+
         # Log significant correlations
         if abs(correlation.price_change_pct) > 3:  # 3% threshold
-            logger.info(f"💥 Significant Impact: {correlation.event.type.value} caused {correlation.price_change_pct:+.2f}% move in {correlation.market_ticker}")
-    
+            logger.info(
+                f"💥 Significant Impact: {correlation.event.type.value} caused {correlation.price_change_pct:+.2f}% move in {correlation.market_ticker}"
+            )
+
     manager.on_correlation = handle_correlation
-    
+
     try:
         await manager.start()
-        
+
         # Monitor all NFL games
         logger.info("Monitoring all NFL games for market patterns...")
         await manager.track_sport("nfl")
-        
+
         # For demo, we'll also track some example markets
         # In production, you'd dynamically subscribe based on live games
-        example_markets = [
-            "NFL-GENERIC-HOME-WIN",
-            "NFL-GENERIC-TOTAL-OVER"
-        ]
+        example_markets = ["NFL-GENERIC-HOME-WIN", "NFL-GENERIC-TOTAL-OVER"]
         await manager.kalshi_ws.subscribe_markets(example_markets)
-        
+
         # Run for 3 minutes
         await asyncio.sleep(180)
-        
+
         # Print pattern analysis
         logger.info("\n" + "=" * 60)
         logger.info("PATTERN ANALYSIS")
         logger.info("=" * 60)
-        
+
         if touchdown_impacts:
             avg_td_impact = sum(touchdown_impacts) / len(touchdown_impacts)
-            logger.info(f"Touchdowns: {len(touchdown_impacts)} events, avg impact {avg_td_impact:.2f}%")
-        
+            logger.info(
+                f"Touchdowns: {len(touchdown_impacts)} events, avg impact {avg_td_impact:.2f}%"
+            )
+
         if turnover_impacts:
             avg_to_impact = sum(turnover_impacts) / len(turnover_impacts)
-            logger.info(f"Turnovers: {len(turnover_impacts)} events, avg impact {avg_to_impact:.2f}%")
-        
+            logger.info(
+                f"Turnovers: {len(turnover_impacts)} events, avg impact {avg_to_impact:.2f}%"
+            )
+
         # Get overall statistics
         stats = manager.get_correlation_stats()
         logger.info("\nOverall Statistics:")
         logger.info(f"  Total Correlations: {stats['total_correlations']}")
         logger.info(f"  Average Price Change: {stats['avg_price_change']:.3f}")
         logger.info(f"  Average Latency: {stats['avg_latency_ms']}ms")
-        
-        if stats['strongest_correlation']:
-            strongest = stats['strongest_correlation']
+
+        if stats["strongest_correlation"]:
+            strongest = stats["strongest_correlation"]
             logger.info("\nStrongest Correlation:")
             logger.info(f"  Event: {strongest.event.description}")
             logger.info(f"  Impact: {strongest.price_change_pct:+.2f}%")
-    
+
     finally:
         await manager.stop()
 
@@ -169,9 +181,9 @@ async def simulate_correlation_scenarios():
     """Simulate different correlation scenarios for testing"""
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
-    from data_pipeline.data_sources.espn.models import GameState, GameEvent
-    
+
+    from data_pipeline.data_sources.espn.models import GameEvent, GameState
+
     # Create a mock game state
     game_state = GameState(
         game_id="TEST123",
@@ -182,75 +194,75 @@ async def simulate_correlation_scenarios():
         quarter=3,
         clock="7:30",
         home_win_probability=65.0,
-        away_win_probability=35.0
+        away_win_probability=35.0,
     )
-    
+
     # Simulate different events and their typical market impacts
     scenarios = [
         {
-            'event': GameEvent(
+            "event": GameEvent(
                 type=EventType.TOUCHDOWN,
                 game_id="TEST123",
                 description="Home team scores touchdown!",
                 impact_score=0.9,
-                game_state=game_state
+                game_state=game_state,
             ),
-            'expected_impact': 5.0  # 5% price movement
+            "expected_impact": 5.0,  # 5% price movement
         },
         {
-            'event': GameEvent(
+            "event": GameEvent(
                 type=EventType.INTERCEPTION,
                 game_id="TEST123",
                 description="Away team throws interception in red zone!",
                 impact_score=0.85,
-                game_state=game_state
+                game_state=game_state,
             ),
-            'expected_impact': -4.5  # -4.5% price movement
+            "expected_impact": -4.5,  # -4.5% price movement
         },
         {
-            'event': GameEvent(
+            "event": GameEvent(
                 type=EventType.INJURY,
                 game_id="TEST123",
                 description="Star quarterback injured",
                 impact_score=0.8,
-                game_state=game_state
+                game_state=game_state,
             ),
-            'expected_impact': -6.0  # -6% price movement
+            "expected_impact": -6.0,  # -6% price movement
         },
         {
-            'event': GameEvent(
+            "event": GameEvent(
                 type=EventType.FIELD_GOAL_MISSED,
                 game_id="TEST123",
                 description="Home team misses 35-yard field goal",
                 impact_score=0.5,
-                game_state=game_state
+                game_state=game_state,
             ),
-            'expected_impact': -2.0  # -2% price movement
-        }
+            "expected_impact": -2.0,  # -2% price movement
+        },
     ]
-    
+
     logger.info("=" * 60)
     logger.info("CORRELATION SCENARIO SIMULATION")
     logger.info("=" * 60)
-    
+
     for scenario in scenarios:
-        event = scenario['event']
-        expected = scenario['expected_impact']
-        
+        event = scenario["event"]
+        expected = scenario["expected_impact"]
+
         logger.info(f"\nScenario: {event.type.value}")
         logger.info(f"  Description: {event.description}")
         logger.info(f"  Impact Score: {event.impact_score:.2f}")
         logger.info(f"  Expected Market Impact: {expected:+.1f}%")
-        
+
         # Simulate market reaction
         if event.game_state.is_critical_situation():
             actual_impact = expected * 1.5  # Amplified in critical situations
             logger.info("  🔥 Critical Situation Multiplier: 1.5x")
         else:
             actual_impact = expected
-        
+
         logger.info(f"  Simulated Actual Impact: {actual_impact:+.1f}%")
-        
+
         # Determine trading opportunity
         if abs(actual_impact) > 4:
             logger.info("  💰 TRADING OPPORTUNITY: Strong correlation detected!")
@@ -258,7 +270,7 @@ async def simulate_correlation_scenarios():
             logger.info("  📊 Moderate correlation - monitor closely")
         else:
             logger.info("  📉 Weak correlation - no immediate action")
-    
+
     logger.info("\n" + "=" * 60)
     logger.info("Key Insights:")
     logger.info("• Touchdowns typically move markets 3-7%")
@@ -273,15 +285,15 @@ async def main():
     print("=" * 60)
     print("ESPN to Kalshi Market Correlation Examples")
     print("=" * 60)
-    
+
     # Choose which example to run
     print("\nSelect an example to run:")
     print("1. Track specific game with markets")
     print("2. Monitor all NFL games for patterns")
     print("3. Simulate correlation scenarios")
-    
+
     choice = input("\nEnter choice (1-3): ").strip()
-    
+
     if choice == "1":
         await track_game_with_markets()
     elif choice == "2":
@@ -294,4 +306,4 @@ async def main():
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
\ No newline at end of file
+    asyncio.run(main())
diff --git a/examples/stream_markets.py b/examples/stream_markets.py
index ff393eb6..f724da3f 100644
--- a/examples/stream_markets.py
+++ b/examples/stream_markets.py
@@ -4,6 +4,7 @@
 
 import asyncio
 import logging
+
 from data_pipeline.streaming import KalshiWebSocket
 from data_pipeline.utils import setup_logging
 
@@ -12,30 +13,27 @@ async def main():
     # Setup logging
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
+
     # Create WebSocket client
     ws = KalshiWebSocket()
-    
+
     try:
         # Connect to WebSocket
         await ws.connect()
-        
+
         # Subscribe to some test markets
-        test_markets = [
-            "KXQUICKSETTLE-23DEC29-T0001",
-            "KXQUICKSETTLE-23DEC29-T0002"
-        ]
-        
+        test_markets = ["KXQUICKSETTLE-23DEC29-T0001", "KXQUICKSETTLE-23DEC29-T0002"]
+
         await ws.subscribe_markets(test_markets)
-        
+
         # Run for 60 seconds
         logger.info("Streaming market data for 60 seconds...")
         await asyncio.sleep(60)
-        
+
     finally:
         # Disconnect
         await ws.disconnect()
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
\ No newline at end of file
+    asyncio.run(main())
diff --git a/examples/track_sports_example.py b/examples/track_sports_example.py
new file mode 100644
index 00000000..79be4dc7
--- /dev/null
+++ b/examples/track_sports_example.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+Sports Tracking Example
+Demonstrates standardized approach to track NFL and CFP markets
+"""
+
+import asyncio
+import logging
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+from src.data_pipeline.orchestration.unified_stream_manager import StreamManager
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def track_nfl_example():
+    """Example: Track all NFL markets"""
+    logger.info("=== NFL Market Tracking Example ===")
+
+    # Initialize stream manager
+    stream_manager = StreamManager()
+
+    try:
+        # Start the stream manager
+        await stream_manager.start()
+
+        # Track all NFL markets (limit to 10 for demo)
+        tracked_markets = await stream_manager.track_nfl_markets(limit=10)
+        logger.info(f"Tracking {len(tracked_markets)} NFL markets")
+
+        # Run for 30 seconds to see live data
+        logger.info("Streaming live data for 30 seconds...")
+        await asyncio.sleep(30)
+
+    finally:
+        await stream_manager.stop()
+
+
+async def track_eagles_cowboys_example():
+    """Example: Track specific Eagles vs Cowboys game"""
+    logger.info("=== Eagles vs Cowboys Game Tracking ===")
+
+    # Initialize stream manager
+    stream_manager = StreamManager()
+
+    try:
+        # Start the stream manager
+        await stream_manager.start()
+
+        # Track Eagles vs Cowboys markets specifically
+        tracked_markets = await stream_manager.track_game_markets("nfl", "PHI", "DAL")
+        logger.info(f"Tracking {len(tracked_markets)} Eagles vs Cowboys markets")
+
+        for ticker in tracked_markets:
+            logger.info(f"  - {ticker}")
+
+        # Run for 30 seconds to see live data
+        logger.info("Streaming live Eagles vs Cowboys data for 30 seconds...")
+        await asyncio.sleep(30)
+
+    finally:
+        await stream_manager.stop()
+
+
+async def track_team_example():
+    """Example: Track all markets for a specific team"""
+    logger.info("=== Team Market Tracking (Eagles) ===")
+
+    # Initialize stream manager
+    stream_manager = StreamManager()
+
+    try:
+        # Start the stream manager
+        await stream_manager.start()
+
+        # Track all Eagles markets
+        tracked_markets = await stream_manager.track_team_markets("nfl", "PHI")
+        logger.info(f"Tracking {len(tracked_markets)} Eagles markets")
+
+        # Run for 30 seconds to see live data
+        logger.info("Streaming live Eagles data for 30 seconds...")
+        await asyncio.sleep(30)
+
+    finally:
+        await stream_manager.stop()
+
+
+async def discover_markets_example():
+    """Example: Just discover markets without tracking"""
+    logger.info("=== Market Discovery Example ===")
+
+    from src.data_pipeline.data_sources.kalshi.market_discovery import (
+        discover_nfl_markets,
+    )
+
+    # Discover NFL markets
+    markets = await discover_nfl_markets()
+    logger.info(f"Found {len(markets)} NFL markets")
+
+    # Show first 5 markets
+    for market in markets[:5]:
+        logger.info(f"  {market.display_name} - {market.ticker}")
+        if market.yes_bid and market.yes_ask:
+            logger.info(f"    Bid: ${market.yes_bid:.3f}, Ask: ${market.yes_ask:.3f}")
+
+
+async def main():
+    """Run examples"""
+    logger.info("🏈 Sports Tracking Examples")
+    logger.info("=" * 50)
+
+    try:
+        # Example 1: Market discovery only
+        await discover_markets_example()
+        await asyncio.sleep(2)
+
+        # Example 2: Track specific game
+        await track_eagles_cowboys_example()
+        await asyncio.sleep(2)
+
+        # Example 3: Track team markets
+        await track_team_example()
+        await asyncio.sleep(2)
+
+        # Example 4: Track all NFL (uncomment to run)
+        # await track_nfl_example()
+
+    except KeyboardInterrupt:
+        logger.info("Stopped by user")
+    except Exception as e:
+        logger.error(f"Example failed: {e}")
+
+
+if __name__ == "__main__":
+    print("🏈 NFL Market Tracking Examples")
+    print("This demonstrates the standardized sports tracking approach")
+    print("Press Ctrl+C to stop\n")
+
+    asyncio.run(main())
diff --git a/examples/twitter_sentiment_stream.py b/examples/twitter_sentiment_stream.py
index d95257db..680eabb1 100644
--- a/examples/twitter_sentiment_stream.py
+++ b/examples/twitter_sentiment_stream.py
@@ -3,13 +3,14 @@
 Real-time sentiment analysis for game monitoring
 """
 
-import os
 import asyncio
 import logging
+import os
+
 from data_pipeline.data_sources.twitter import (
-    TwitterStreamAdapter,
+    FilterManager,
     SentimentAnalyzer,
-    FilterManager
+    TwitterStreamAdapter,
 )
 from data_pipeline.utils import setup_logging
 
@@ -18,80 +19,92 @@ async def basic_sentiment_stream():
     """Basic example of streaming Twitter sentiment"""
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
+
     # Check for API key
-    if not (os.getenv('TWITTERAPI_KEY') or os.getenv('TWITTER_BEARER_TOKEN')):
+    if not (os.getenv("TWITTERAPI_KEY") or os.getenv("TWITTER_BEARER_TOKEN")):
         logger.error(
             "Twitter API key not set. For this integration, add TWITTERAPI_KEY (TwitterAPI.io) "
             "or set TWITTER_BEARER_TOKEN if you intend to reuse it as the API key."
         )
         return
-    
+
     # Create stream adapter
     stream = TwitterStreamAdapter()
-    
+
     # Define callbacks
     async def handle_sentiment_event(event):
         logger.info("=" * 60)
         logger.info("SENTIMENT UPDATE")
-        logger.info(f"  Period: {event.start_time.strftime('%H:%M:%S')} - {event.end_time.strftime('%H:%M:%S')}")
-        logger.info(f"  Tweets: {event.tweet_count} from {event.unique_authors} authors")
+        logger.info(
+            f"  Period: {event.start_time.strftime('%H:%M:%S')} - {event.end_time.strftime('%H:%M:%S')}"
+        )
+        logger.info(
+            f"  Tweets: {event.tweet_count} from {event.unique_authors} authors"
+        )
         logger.info(f"  Sentiment: {event.avg_sentiment_score:+.2f}")
         logger.info(f"  Velocity: {event.tweets_per_minute:.1f} tweets/min")
         logger.info(f"  Impact: {event.market_impact.value}")
-        
+
         if event.trending_keywords:
             logger.info(f"  Trending: {', '.join(event.trending_keywords[:5])}")
-        
+
         # Show sentiment distribution
         dist = event.sentiment_distribution
         total = sum(dist.values())
         if total > 0:
-            logger.info(f"  Distribution: "
-                       f"Positive {dist.get('positive', 0)/total*100:.0f}% | "
-                       f"Neutral {dist.get('neutral', 0)/total*100:.0f}% | "
-                       f"Negative {dist.get('negative', 0)/total*100:.0f}%")
-    
+            logger.info(
+                f"  Distribution: "
+                f"Positive {dist.get('positive', 0)/total*100:.0f}% | "
+                f"Neutral {dist.get('neutral', 0)/total*100:.0f}% | "
+                f"Negative {dist.get('negative', 0)/total*100:.0f}%"
+            )
+
     async def handle_sentiment_shift(shift):
         logger.warning("🔄 SENTIMENT SHIFT DETECTED!")
         logger.warning(f"  Type: {shift['type']}")
         logger.warning(f"  Magnitude: {shift['magnitude']:.2f}")
-        logger.warning(f"  From: {shift['from_sentiment']:+.2f} To: {shift['to_sentiment']:+.2f}")
+        logger.warning(
+            f"  From: {shift['from_sentiment']:+.2f} To: {shift['to_sentiment']:+.2f}"
+        )
         logger.warning(f"  Tweet surge: {shift.get('tweet_surge', 1):.1f}x normal")
-    
+
     async def handle_high_impact(tweet, sentiment):
         logger.info("💥 HIGH IMPACT TWEET")
-        logger.info(f"  Author: @{tweet.author.username} ({tweet.author.followers_count:,} followers)")
+        logger.info(
+            f"  Author: @{tweet.author.username} ({tweet.author.followers_count:,} followers)"
+        )
         logger.info(f"  Text: {tweet.text[:200]}...")
-        logger.info(f"  Sentiment: {sentiment.score:+.2f} ({sentiment.sentiment_label})")
+        logger.info(
+            f"  Sentiment: {sentiment.score:+.2f} ({sentiment.sentiment_label})"
+        )
         if sentiment.market_keywords:
             logger.info(f"  Market Keywords: {sentiment.market_keywords}")
         logger.info(f"  Engagement: {tweet.metrics.engagement_score:.2f}")
-    
+
     # Set callbacks
     stream.on_sentiment_event = handle_sentiment_event
     stream.on_sentiment_shift = handle_sentiment_shift
     stream.on_high_impact_tweet = handle_high_impact
-    
+
     try:
         # Start streaming
         await stream.start()
-        
+
         # Monitor a game (example teams)
         await stream.monitor_game(
             game_id="GAME123",
             home_team="Chiefs",
             away_team="Bills",
             sport="nfl",
-            players=["Patrick Mahomes", "Josh Allen", "Travis Kelce", "Stefon Diggs"]
+            players=["Patrick Mahomes", "Josh Allen", "Travis Kelce", "Stefon Diggs"],
         )
-        
+
         logger.info("Streaming Twitter sentiment for Chiefs vs Bills...")
         logger.info("Monitoring key players and team accounts...")
-        
+
         # Run for 5 minutes
         await asyncio.sleep(300)
-        
+
         # Get final stats
         stats = stream.get_stats()
         logger.info("\n" + "=" * 60)
@@ -99,7 +112,7 @@ async def handle_high_impact(tweet, sentiment):
         logger.info(f"  Total tweets: {stats['tweets_received']}")
         logger.info(f"  Rate: {stats.get('tweets_per_minute', 0):.1f} tweets/min")
         logger.info(f"  Current sentiment: {stats.get('current_sentiment', 0):+.2f}")
-        
+
     finally:
         await stream.stop()
 
@@ -108,63 +121,64 @@ async def game_sentiment_tracking():
     """Track sentiment throughout a game"""
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
-    if not (os.getenv('TWITTERAPI_KEY') or os.getenv('TWITTER_BEARER_TOKEN')):
+
+    if not (os.getenv("TWITTERAPI_KEY") or os.getenv("TWITTER_BEARER_TOKEN")):
         logger.error("Twitter API key not set (TWITTERAPI_KEY or TWITTER_BEARER_TOKEN)")
         return
-    
+
     stream = TwitterStreamAdapter()
-    
+
     # Track key moments
     key_moments = []
-    
+
     async def handle_sentiment_event(event):
         # Track significant moments
-        if event.market_impact.value in ['high', 'critical']:
-            key_moments.append({
-                'time': event.end_time,
-                'sentiment': event.avg_sentiment_score,
-                'impact': event.market_impact.value,
-                'tweets': event.tweet_count
-            })
-            
-            logger.info(f"📍 Key Moment: Sentiment {event.avg_sentiment_score:+.2f}, "
-                       f"Impact: {event.market_impact.value}")
-    
+        if event.market_impact.value in ["high", "critical"]:
+            key_moments.append(
+                {
+                    "time": event.end_time,
+                    "sentiment": event.avg_sentiment_score,
+                    "impact": event.market_impact.value,
+                    "tweets": event.tweet_count,
+                }
+            )
+
+            logger.info(
+                f"📍 Key Moment: Sentiment {event.avg_sentiment_score:+.2f}, "
+                f"Impact: {event.market_impact.value}"
+            )
+
     stream.on_sentiment_event = handle_sentiment_event
-    
+
     try:
         await stream.start()
-        
+
         # Set up game monitoring
         game_id = "NFL_2024_WK1_KC_BUF"
         await stream.monitor_game(
-            game_id=game_id,
-            home_team="Chiefs",
-            away_team="Bills",
-            sport="nfl"
+            game_id=game_id, home_team="Chiefs", away_team="Bills", sport="nfl"
         )
-        
+
         logger.info("Tracking game sentiment...")
-        
+
         # Simulate game quarters (30 seconds each for demo)
         quarters = ["Q1", "Q2", "Halftime", "Q3", "Q4"]
-        
+
         for quarter in quarters:
             logger.info(f"\n{'='*40}")
             logger.info(f"📢 {quarter}")
             await asyncio.sleep(30)
-            
+
             # Get current sentiment
             current = stream.get_current_sentiment()
             trend = stream.get_sentiment_trend(periods=3)
-            
+
             if current is not None:
                 logger.info(f"Current sentiment: {current:+.2f}")
                 if len(trend) > 1:
                     direction = "📈" if trend[-1] > trend[0] else "📉"
                     logger.info(f"Trend: {direction} {trend}")
-        
+
         # Get game summary
         summary = stream.get_game_summary(game_id)
         if summary:
@@ -172,23 +186,27 @@ async def handle_sentiment_event(event):
             logger.info("GAME SENTIMENT SUMMARY")
             logger.info(f"  Total tweets: {summary.total_tweets}")
             logger.info(f"  Unique authors: {summary.unique_authors}")
-            
+
             # Show momentum shifts
             shifts = summary.calculate_momentum_shifts()
             if shifts:
                 logger.info("\nMomentum Shifts:")
                 for shift in shifts:
-                    logger.info(f"  {shift['time'].strftime('%H:%M:%S')}: "
-                               f"{shift['from_sentiment']:+.2f} → {shift['to_sentiment']:+.2f}")
-            
+                    logger.info(
+                        f"  {shift['time'].strftime('%H:%M:%S')}: "
+                        f"{shift['from_sentiment']:+.2f} → {shift['to_sentiment']:+.2f}"
+                    )
+
             # Show key moments
             if key_moments:
                 logger.info("\nKey Moments:")
                 for moment in key_moments:
-                    logger.info(f"  {moment['time'].strftime('%H:%M:%S')}: "
-                               f"Sentiment {moment['sentiment']:+.2f}, "
-                               f"Impact: {moment['impact']}")
-    
+                    logger.info(
+                        f"  {moment['time'].strftime('%H:%M:%S')}: "
+                        f"Sentiment {moment['sentiment']:+.2f}, "
+                        f"Impact: {moment['impact']}"
+                    )
+
     finally:
         await stream.stop()
 
@@ -197,94 +215,98 @@ async def player_injury_monitoring():
     """Monitor for player injury news"""
     setup_logging(level="INFO")
     logger = logging.getLogger(__name__)
-    
-    if not (os.getenv('TWITTERAPI_KEY') or os.getenv('TWITTER_BEARER_TOKEN')):
+
+    if not (os.getenv("TWITTERAPI_KEY") or os.getenv("TWITTER_BEARER_TOKEN")):
         logger.error("Twitter API key not set (TWITTERAPI_KEY or TWITTER_BEARER_TOKEN)")
         return
-    
+
     # Set up filter manager
     filter_manager = FilterManager()
-    
+
     # Create player-specific filter
     key_players = [
         "Patrick Mahomes",
         "Josh Allen",
         "Justin Jefferson",
         "Tyreek Hill",
-        "Nick Chubb"
+        "Nick Chubb",
     ]
-    
+
     logger.info("Setting up injury monitoring for key players...")
-    
+
     for player in key_players:
         rule = await filter_manager.create_player_filter(
             player_name=player,
-            keywords=['injury', 'injured', 'questionable', 'doubtful', 'out', 'return']
+            keywords=["injury", "injured", "questionable", "doubtful", "out", "return"],
         )
         logger.info(f"  Monitoring: {player} (Rule: {rule.tag})")
-    
+
     # Create sentiment analyzer
     analyzer = SentimentAnalyzer()
-    
+
     # Set up WebSocket client
     from data_pipeline.data_sources.twitter.client import AsyncTwitterWebSocketClient
-    
+
     client = AsyncTwitterWebSocketClient()
-    
+
     injury_alerts = []
-    
+
     def handle_tweet(tweet):
         # Check for injury keywords
-        injury_keywords = ['injury', 'injured', 'out', 'questionable', 'doubtful']
+        injury_keywords = ["injury", "injured", "out", "questionable", "doubtful"]
         text_lower = tweet.text.lower()
-        
+
         if any(kw in text_lower for kw in injury_keywords):
             # Analyze sentiment
             sentiment = analyzer.analyze_tweet(tweet)
-            
+
             # High-impact injury news
             if tweet.author.verified or tweet.author.followers_count > 10000:
                 alert = {
-                    'player': next((p for p in key_players if p.lower() in text_lower), 'Unknown'),
-                    'author': tweet.author.username,
-                    'text': tweet.text[:200],
-                    'sentiment': sentiment.score,
-                    'impact': 'HIGH' if tweet.author.verified else 'MEDIUM',
-                    'time': tweet.created_at
+                    "player": next(
+                        (p for p in key_players if p.lower() in text_lower), "Unknown"
+                    ),
+                    "author": tweet.author.username,
+                    "text": tweet.text[:200],
+                    "sentiment": sentiment.score,
+                    "impact": "HIGH" if tweet.author.verified else "MEDIUM",
+                    "time": tweet.created_at,
                 }
-                
+
                 injury_alerts.append(alert)
-                
+
                 logger.warning("🚨 INJURY ALERT!")
                 logger.warning(f"  Player: {alert['player']}")
                 logger.warning(f"  Source: @{alert['author']}")
                 logger.warning(f"  Message: {alert['text']}...")
                 logger.warning(f"  Impact: {alert['impact']}")
-    
+
     client.on_tweet(handle_tweet)
-    
+
     try:
         await client.connect()
-        
+
         logger.info("Monitoring for injury news...")
-        
+
         # Run for 3 minutes
         await asyncio.sleep(180)
-        
+
         # Summary
         if injury_alerts:
             logger.info("\n" + "=" * 60)
             logger.info("INJURY ALERTS SUMMARY")
             for alert in injury_alerts:
-                logger.info(f"\n{alert['time'].strftime('%H:%M:%S')} - {alert['player']}")
+                logger.info(
+                    f"\n{alert['time'].strftime('%H:%M:%S')} - {alert['player']}"
+                )
                 logger.info(f"  Source: @{alert['author']} ({alert['impact']})")
                 logger.info(f"  Sentiment: {alert['sentiment']:+.2f}")
         else:
             logger.info("\nNo injury alerts detected")
-    
+
     finally:
         await client.disconnect()
-        
+
         # Clean up old filter rules
         await filter_manager.cleanup_old_rules(hours=1)
 
@@ -294,14 +316,14 @@ async def main():
     print("=" * 60)
     print("Twitter Sentiment Streaming Examples")
     print("=" * 60)
-    
+
     print("\nSelect an example:")
     print("1. Basic sentiment streaming")
     print("2. Game sentiment tracking")
     print("3. Player injury monitoring")
-    
+
     choice = input("\nEnter choice (1-3): ").strip()
-    
+
     if choice == "1":
         await basic_sentiment_stream()
     elif choice == "2":
diff --git a/neural_sdk/README.md b/neural_sdk/README.md
new file mode 100644
index 00000000..85dd2d3b
--- /dev/null
+++ b/neural_sdk/README.md
@@ -0,0 +1,346 @@
+# Kalshi Trading SDK
+
+[![PyPI version](https://badge.fury.io/py/kalshi-trading-sdk.svg)](https://pypi.org/project/kalshi-trading-sdk/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Open-source SDK for algorithmic sports trading on Kalshi**
+
+The Kalshi Trading SDK provides a comprehensive framework for building algorithmic trading systems for Kalshi sports event contracts. It features real-time data streaming, agent-based architecture, risk management, and an extensible plugin system.
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install kalshi-trading-sdk
+```
+
+### Basic Usage
+
+```python
+from kalshi_trading_sdk import KalshiSDK
+
+# Initialize SDK
+sdk = KalshiSDK.from_env()
+
+# Create a simple trading strategy
+@sdk.strategy
+async def arbitrage_strategy(market_data):
+    if market_data.yes_price + market_data.no_price < 0.98:
+        return sdk.create_signal("BUY", market_data.ticker)
+
+# Start trading
+await sdk.start_trading_system()
+```
+
+### CLI Usage
+
+```bash
+# Initialize configuration
+kalshi-sdk init
+
+# Start trading system
+kalshi-sdk start
+
+# Check system status
+kalshi-sdk status
+
+# Validate configuration
+kalshi-sdk validate
+```
+
+## 📋 Features
+
+### ✅ Core Features
+- **Real-time Data Streaming** - WebSocket connections to Kalshi, ESPN, and other sources
+- **Agent-based Architecture** - Always-on and on-demand agents for different use cases
+- **Risk Management** - Position limits, stop-loss, portfolio monitoring
+- **Redis Integration** - Scalable pub/sub messaging infrastructure
+- **Configuration Management** - Environment-based and file-based configuration
+- **CLI Interface** - Command-line tools for management and monitoring
+
+### 🔄 Architecture
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│  Data Sources   │ -> │   SDK Core      │ -> │   Strategies    │
+│                 │    │                 │    │                 │
+│ • Kalshi API    │    │ • Agent System  │    │ • Arbitrage     │
+│ • ESPN Streams  │    │ • Risk Mgmt     │    │ • Sentiment     │
+│ • Twitter API   │    │ • Redis Pub/Sub │    │ • Custom        │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+                              │
+                              ▼
+                       ┌─────────────────┐
+                       │   Trade         │
+                       │   Execution     │
+                       │                 │
+                       │ • Kalshi API    │
+                       │ • Position Mgmt │
+                       │ • P&L Tracking  │
+                       └─────────────────┘
+```
+
+## 🏗️ SDK Structure
+
+```
+kalshi_trading_sdk/
+├── core/                    # Core SDK functionality
+│   ├── client.py           # Main SDK client
+│   ├── config.py           # Configuration management
+│   └── exceptions.py       # Custom exceptions
+├── agents/                  # Agent framework
+│   ├── base.py             # Base agent classes
+│   ├── orchestrator.py     # Agent management
+│   └── types.py            # Agent type definitions
+├── trading/                # Trading functionality
+│   ├── kalshi.py           # Kalshi API wrapper
+│   ├── portfolio.py        # Portfolio management
+│   └── risk.py             # Risk management
+├── data/                   # Data sources & processing
+│   ├── sources/            # Data source adapters
+│   └── pipeline.py         # Data processing pipeline
+├── strategies/             # Trading strategies
+│   ├── base.py             # Base strategy class
+│   └── examples/           # Example strategies
+└── utils/                  # Utilities
+    ├── redis.py            # Redis utilities
+    └── logging.py          # Logging configuration
+```
+
+## 📖 Documentation
+
+### Configuration
+
+The SDK supports multiple configuration methods:
+
+#### Environment Variables
+```bash
+export KALSHI_API_KEY_ID="your_api_key"
+export KALSHI_API_SECRET="your_secret"
+export KALSHI_REDIS_URL="redis://localhost:6379"
+export KALSHI_ENVIRONMENT="development"
+```
+
+#### Configuration File
+```yaml
+# kalshi_config.yaml
+kalshi_api_key_id: "your_api_key"
+kalshi_api_secret: "your_secret"
+environment: "development"
+risk_limits:
+  max_position_size_pct: 0.05
+  max_daily_loss_pct: 0.20
+  kelly_fraction: 0.25
+```
+
+#### Programmatic Configuration
+```python
+from kalshi_trading_sdk import SDKConfig, KalshiSDK
+
+config = SDKConfig(
+    kalshi_api_key_id="your_api_key",
+    kalshi_api_secret="your_secret",
+    environment="development"
+)
+
+sdk = KalshiSDK(config)
+```
+
+### Trading Strategies
+
+Create custom trading strategies using the strategy decorator:
+
+```python
+@sdk.strategy
+async def momentum_strategy(market_data):
+    """Simple momentum-based strategy"""
+    if market_data.yes_price > 0.7:
+        return sdk.create_signal(
+            action="SELL",
+            market_ticker=market_data.ticker,
+            confidence=0.8,
+            quantity=100
+        )
+    elif market_data.yes_price < 0.3:
+        return sdk.create_signal(
+            action="BUY",
+            market_ticker=market_data.ticker,
+            confidence=0.8,
+            quantity=100
+        )
+```
+
+### Event Handlers
+
+Register handlers for different events:
+
+```python
+@sdk.on_market_data
+async def handle_market_update(market_data):
+    """Process market data updates"""
+    print(f"Market update: {market_data.ticker} = {market_data.yes_price}")
+
+@sdk.on_signal
+async def handle_trading_signal(signal):
+    """Process trading signals"""
+    print(f"Signal generated: {signal.action} {signal.market_ticker}")
+
+@sdk.on_trade
+async def handle_trade_execution(trade_result):
+    """Process trade execution results"""
+    print(f"Trade executed: {trade_result.status}")
+```
+
+## 🔧 Development
+
+### Setup Development Environment
+
+```bash
+# Clone repository
+git clone https://github.com/kalshi/kalshi-trading-sdk.git
+cd kalshi-trading-sdk
+
+# Install development dependencies
+pip install -e .[dev]
+
+# Run tests
+pytest
+
+# Run linting
+black kalshi_trading_sdk/
+isort kalshi_trading_sdk/
+mypy kalshi_trading_sdk/
+```
+
+### Building Documentation
+
+```bash
+# Install docs dependencies
+pip install -e .[docs]
+
+# Build documentation
+cd docs
+sphinx-build -b html . _build/html
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](../CONTRIBUTING.md) for details.
+
+### Development Workflow
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for new functionality
+5. Ensure all tests pass
+6. Submit a pull request
+
+### Code Style
+
+This project uses:
+- **Black** for code formatting
+- **isort** for import sorting
+- **mypy** for type checking
+- **pytest** for testing
+
+## 📊 Performance
+
+### Benchmarks
+- **Latency**: <100ms end-to-end (market data to trade execution)
+- **Throughput**: 10K+ messages/second
+- **Memory**: <50MB baseline usage
+- **CPU**: <5% average utilization
+
+### Scaling
+- Horizontal scaling via Redis pub/sub
+- Support for multiple data sources
+- Configurable agent pools
+- Database integration for historical data
+
+## 🔒 Security
+
+### API Key Management
+- Environment variable configuration
+- No hardcoded credentials
+- Secure key rotation support
+- Audit logging for sensitive operations
+
+### Risk Controls
+- Position size limits
+- Daily loss limits
+- Automatic circuit breakers
+- Manual override capabilities
+
+## 📈 Roadmap
+
+### Phase 1 (Current) - Foundation ✅
+- Core SDK architecture
+- Basic agent framework
+- Configuration management
+- CLI interface
+
+### Phase 2 - Advanced Features 🔄
+- Advanced strategy framework
+- Machine learning integration
+- Multi-exchange support
+- Performance analytics
+
+### Phase 3 - Enterprise Features 📅
+- High-frequency trading
+- Advanced risk models
+- Institutional features
+- Cloud deployment
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**Configuration Errors**
+```bash
+# Validate configuration
+kalshi-sdk validate
+
+# Check environment variables
+kalshi-sdk config show
+```
+
+**Connection Issues**
+```bash
+# Check Redis connectivity
+redis-cli ping
+
+# Check system status
+kalshi-sdk status
+```
+
+**Trading Issues**
+```bash
+# Check portfolio status
+kalshi-sdk status --watch
+
+# Review recent trades
+kalshi-sdk logs --tail 50
+```
+
+## 📞 Support
+
+- **Documentation**: [Read the Docs](https://kalshi-trading-sdk.readthedocs.io/)
+- **Issues**: [GitHub Issues](https://github.com/kalshi/kalshi-trading-sdk/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/kalshi/kalshi-trading-sdk/discussions)
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](../LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Kalshi for providing the trading platform
+- The open-source community for inspiration and tools
+- Contributors and early adopters
+
+---
+
+**Built with ❤️ for the algorithmic trading community**
\ No newline at end of file
diff --git a/neural_sdk/__init__.py b/neural_sdk/__init__.py
new file mode 100644
index 00000000..47015b62
--- /dev/null
+++ b/neural_sdk/__init__.py
@@ -0,0 +1,72 @@
+"""
+Neural SDK - Open-source SDK for algorithmic prediction market trading
+
+This SDK provides a comprehensive framework for building algorithmic trading
+systems for prediction markets. It includes:
+
+- Real-time data streaming from multiple sources
+- Strategy development framework with backtesting
+- Risk management and portfolio monitoring
+- Multiple data source integrations
+- Comprehensive performance analytics
+
+Example:
+    ```python
+    from neural_sdk import NeuralSDK
+    from neural_sdk.backtesting import BacktestEngine, BacktestConfig
+
+    # Initialize SDK
+    sdk = NeuralSDK.from_env()
+
+    # Create a trading strategy
+    def my_strategy(market_data):
+        for symbol, price in market_data.prices.items():
+            if price < 0.3:
+                return {'action': 'BUY', 'symbol': symbol, 'size': 100}
+
+    # Backtest the strategy
+    config = BacktestConfig(start_date="2024-01-01", end_date="2024-12-31")
+    engine = BacktestEngine(config)
+    engine.add_strategy(my_strategy)
+    engine.load_data("csv", path="historical_data.csv")
+    results = engine.run()
+
+    # Deploy live (optional)
+    await sdk.start_trading()
+    ```
+"""
+
+__version__ = "1.0.0"
+__author__ = "Neural SDK Team"
+__email__ = "sdk@neural.dev"
+
+from .core.client import MarketData, NeuralSDK, TradeResult, TradingSignal
+from .core.config import SDKConfig
+from .core.exceptions import (
+    ConfigurationError,
+    ConnectionError,
+    SDKError,
+    TradingError,
+    ValidationError,
+)
+
+# Import strategies and utilities
+from .strategies import BaseStrategy, StrategySignal
+from .utils import setup_logging
+
+# Convenience imports for common use cases
+__all__ = [
+    "NeuralSDK",
+    "SDKConfig",
+    "TradingSignal",
+    "MarketData",
+    "TradeResult",
+    "SDKError",
+    "ConfigurationError",
+    "ConnectionError",
+    "TradingError",
+    "ValidationError",
+    "BaseStrategy",
+    "StrategySignal",
+    "setup_logging",
+]
diff --git a/neural_sdk/agents/__init__.py b/neural_sdk/agents/__init__.py
new file mode 100644
index 00000000..0af9ef41
--- /dev/null
+++ b/neural_sdk/agents/__init__.py
@@ -0,0 +1,21 @@
+"""
+Agent framework for the Neural Trading SDK.
+
+This module provides the core agent architecture including:
+- BaseAgentRedisConsumer: Core agent with Redis pub/sub
+- AgentOrchestrator: Multi-agent coordination
+- Always-on agents: DataCoordinator, PortfolioMonitor
+- On-demand agents: GameAnalyst, ArbitrageHunter
+- TriggerService: Agent activation coordination
+"""
+
+from .base import AgentOrchestrator, BaseAgentRedisConsumer
+from .types import AgentStatus, AgentType, TriggerPriority
+
+__all__ = [
+    "BaseAgentRedisConsumer",
+    "AgentOrchestrator",
+    "AgentType",
+    "AgentStatus",
+    "TriggerPriority",
+]
diff --git a/src/agents/base_consumer.py b/neural_sdk/agents/base.py
similarity index 74%
rename from src/agents/base_consumer.py
rename to neural_sdk/agents/base.py
index e156230a..f85ed7ee 100644
--- a/src/agents/base_consumer.py
+++ b/neural_sdk/agents/base.py
@@ -1,44 +1,74 @@
 """
-Base Redis Consumer Module for Agent System
-
-This module provides the foundational Redis pub/sub integration for all trading agents.
-It handles connection management, message routing, error recovery, and statistics tracking.
-
-The base consumer implements:
-- Automatic reconnection with exponential backoff
-- Channel-specific message routing
-- Health monitoring and statistics
-- Integration with Agentuity KV storage
-- Standardized publishing methods for signals, trades, and alerts
-
-Example:
-    ```python
-    from src.agents.base_consumer import BaseAgentRedisConsumer
-    
-    class MyAgentConsumer(BaseAgentRedisConsumer):
-        async def process_message(self, channel: str, data: Dict[str, Any]):
-            if channel == "kalshi:markets":
-                await self.analyze_market(data)
-    
-    # Usage
-    consumer = MyAgentConsumer("MyAgent")
-    await consumer.connect()
-    await consumer.subscribe(["kalshi:markets", "kalshi:signals"])
-    await consumer.start_consuming()
-    ```
-
-References:
-    Redis Pub/Sub Documentation: https://redis.io/docs/manual/pubsub/
-    Agentuity Platform: https://agentuity.dev/
+Base agent classes for the Neural Trading SDK.
+
+This module provides the core agent infrastructure including:
+- BaseAgentRedisConsumer: Core agent with Redis pub/sub
+- AgentOrchestrator: Multi-agent coordination
+- Abstract base classes for different agent types
 """
 
 import asyncio
 import json
 import logging
-import redis.asyncio as redis
-from typing import Dict, Any, Optional, List, Callable
-from datetime import datetime
 from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+
+import redis.asyncio as redis
+
+
+# Placeholder types for now - will be replaced with full implementation
+class AgentStatus:
+    RUNNING = "running"
+    STOPPED = "stopped"
+    ERROR = "error"
+
+
+class AgentStats:
+    def __init__(
+        self,
+        agent_name: str,
+        status: str,
+        messages_received: int = 0,
+        messages_processed: int = 0,
+        messages_published: int = 0,
+        last_message_time=None,
+    ):
+        self.agent_name = agent_name
+        self.status = status
+        self.messages_received = messages_received
+        self.messages_processed = messages_processed
+        self.messages_published = messages_published
+        self.last_message_time = last_message_time
+
+
+class AgentConfig:
+    def __init__(
+        self, agent_type=None, name: str = "", redis_url: str = "redis://localhost:6379"
+    ):
+        self.agent_type = agent_type
+        self.name = name
+        self.redis_url = redis_url
+
+
+class OrchestratorConfig:
+    def __init__(self, redis_url: str = "redis://localhost:6379"):
+        self.redis_url = redis_url
+
+
+class AgentMessage:
+    def __init__(
+        self,
+        message_type: str,
+        source_agent: str,
+        data: Optional[Dict[str, Any]] = None,
+        timestamp: Optional[datetime] = None,
+    ):
+        self.message_type = message_type
+        self.source_agent = source_agent
+        self.data = data if data is not None else {}
+        self.timestamp = timestamp
+
 
 logger = logging.getLogger(__name__)
 
@@ -46,14 +76,13 @@ async def process_message(self, channel: str, data: Dict[str, Any]):
 class BaseAgentRedisConsumer(ABC):
     """
     Abstract base class for Redis-based agent consumers.
-    
+
     This class provides the infrastructure for agents to consume real-time data
     from Redis pub/sub channels and publish trading decisions back to the system.
-    
+
     Attributes:
         agent_name (str): Unique identifier for the agent
         redis_url (str): Redis connection URL
-        agent_context (Optional[Any]): Agentuity context for KV storage
         redis_client (Optional[redis.Redis]): Primary Redis connection for subscriptions
         publisher (Optional[redis.Redis]): Separate connection for publishing
         pubsub (Optional[redis.PubSub]): Pub/sub handler
@@ -64,95 +93,98 @@ class BaseAgentRedisConsumer(ABC):
         messages_published (int): Published messages counter
         last_message_time (Optional[datetime]): Timestamp of last received message
         channel_handlers (Dict[str, Callable]): Channel-specific message handlers
-    
+
     Configuration:
         The consumer can be configured via environment variables:
         - REDIS_URL: Redis connection string (default: redis://localhost:6379)
         - REDIS_MAX_RETRIES: Maximum reconnection attempts (default: 5)
         - REDIS_RETRY_DELAY: Initial retry delay in seconds (default: 1)
-    
+
     Thread Safety:
         This class is designed for async operation and is not thread-safe.
         Use within a single event loop context.
     """
-    
+
     def __init__(
         self,
         agent_name: str,
         redis_url: str = "redis://localhost:6379",
-        agent_context: Optional[Any] = None
+        config: Optional[AgentConfig] = None,
     ):
         """
         Initialize a new Redis consumer for an agent.
-        
+
         This sets up the consumer infrastructure but does not establish connections.
         Call connect() to establish Redis connections.
-        
+
         Args:
             agent_name: Unique identifier for this agent instance.
-                       Used for logging and statistics tracking.
+                        Used for logging and statistics tracking.
             redis_url: Redis connection URL in format redis://[user]:[password]@[host]:[port]/[db].
-                      Defaults to local Redis on standard port.
-            agent_context: Agentuity platform context for accessing KV storage and other services.
-                         Optional - consumer works without it but won't persist statistics.
-        
+                       Defaults to local Redis on standard port.
+            config: Agent configuration object
+
         Raises:
             ValueError: If agent_name is empty or contains invalid characters.
-        
+
         Example:
             >>> consumer = MyConsumer(
             ...     agent_name="DataCoordinator",
             ...     redis_url="redis://localhost:6379",
-            ...     agent_context=agentuity_context
+            ...     config=AgentConfig(...)
             ... )
         """
         if not agent_name or not agent_name.strip():
             raise ValueError("Agent name cannot be empty")
-            
+
         self.agent_name = agent_name
         self.redis_url = redis_url
-        self.agent_context = agent_context
-        
-        # Redis connections
+        self.config = config or AgentConfig(
+            agent_type=None,  # Will be set by subclasses
+            name=agent_name,
+            redis_url=redis_url,
+        )
+
+        # Redis connections will be initialized in connect()
         self.redis_client: Optional[redis.Redis] = None
         self.publisher: Optional[redis.Redis] = None
-        self.pubsub: Optional[redis.PubSub] = None
-        
+        self.pubsub: Optional[Any] = None
+
         # State
         self.is_running = False
         self.subscribed_channels: List[str] = []
-        
+
         # Statistics
         self.messages_received = 0
         self.messages_processed = 0
         self.messages_published = 0
         self.last_message_time: Optional[datetime] = None
-        
+
         # Message handlers by channel
         self.channel_handlers: Dict[str, Callable] = {}
-        
+
         logger.info(f"{agent_name} Redis consumer initialized")
-    
+
     async def connect(self, max_retries: int = 5, initial_delay: float = 1.0) -> None:
         """
         Establish connections to Redis with automatic retry logic.
-        
+
         Creates separate connections for publishing and subscribing to avoid
         blocking issues. Implements exponential backoff for connection failures.
-        
+
         Args:
             max_retries: Maximum number of connection attempts before giving up.
-                        Set to 0 for infinite retries.
+                         Set to 0 for infinite retries.
             initial_delay: Initial delay between retries in seconds.
-                          Doubles after each failed attempt.
-        
+                           Doubles after each failed attempt.
+
         Raises:
             redis.ConnectionError: If unable to connect after all retry attempts.
             redis.AuthenticationError: If Redis authentication fails.
-        
+
         Example:
             >>> await consumer.connect(max_retries=10, initial_delay=2.0)
-        
+
         Note:
             This method is idempotent - calling it multiple times will not
             create duplicate connections if already connected.
@@ -160,58 +192,63 @@ async def connect(self, max_retries: int = 5, initial_delay: float = 1.0) -> Non
         if self.redis_client:
             logger.debug(f"{self.agent_name} already connected")
             return
-            
+
         retry_delay = initial_delay
         attempt = 0
-        
+
         while max_retries == 0 or attempt < max_retries:
             try:
                 # Create separate connections for sub and pub to avoid blocking
                 self.redis_client = redis.from_url(self.redis_url)
                 self.publisher = redis.from_url(self.redis_url)
-                self.pubsub = self.redis_client.pubsub()
-                
+                # Create pubsub instance - will be properly initialized when needed
+                self.pubsub = None
+
                 # Test connection
                 await self.redis_client.ping()
-                
+
                 logger.info(f"{self.agent_name} connected to Redis")
                 return
-                
+
             except redis.AuthenticationError:
                 logger.error(f"{self.agent_name} Redis authentication failed")
                 raise
-                
+
             except Exception as e:
                 attempt += 1
-                logger.warning(f"{self.agent_name} connection attempt {attempt} failed: {e}")
-                
+                logger.warning(
+                    f"{self.agent_name} connection attempt {attempt} failed: {e}"
+                )
+
                 if max_retries > 0 and attempt >= max_retries:
-                    raise redis.ConnectionError(f"Failed to connect after {max_retries} attempts")
-                    
+                    raise redis.ConnectionError(
+                        f"Failed to connect after {max_retries} attempts"
+                    )
+
                 await asyncio.sleep(retry_delay)
                 retry_delay = min(retry_delay * 2, 60)  # Cap at 60 seconds
-    
+
     async def disconnect(self) -> None:
         """
         Gracefully disconnect from Redis and clean up resources.
-        
+
         This method:
         1. Stops message consumption
         2. Unsubscribes from all channels
         3. Closes all Redis connections
         4. Resets internal state
-        
+
         Safe to call multiple times - subsequent calls are no-ops.
-        
+
         Example:
             >>> await consumer.disconnect()
-        
+
         Note:
             Always call this method when shutting down to ensure
             clean resource cleanup and avoid connection leaks.
         """
         self.is_running = False
-        
+
         if self.pubsub:
             try:
                 await self.pubsub.unsubscribe()
@@ -220,7 +257,7 @@ async def disconnect(self) -> None:
                 logger.debug(f"Error closing pubsub: {e}")
             finally:
                 self.pubsub = None
-        
+
         if self.redis_client:
             try:
                 await self.redis_client.close()
@@ -228,7 +265,7 @@ async def disconnect(self) -> None:
                 logger.debug(f"Error closing Redis client: {e}")
             finally:
                 self.redis_client = None
-        
+
         if self.publisher:
             try:
                 await self.publisher.close()
@@ -236,93 +273,95 @@ async def disconnect(self) -> None:
                 logger.debug(f"Error closing publisher: {e}")
             finally:
                 self.publisher = None
-        
+
         self.subscribed_channels = []
         logger.info(f"{self.agent_name} disconnected from Redis")
-    
+
     async def subscribe(self, channels: List[str]) -> None:
         """
         Subscribe to one or more Redis pub/sub channels.
-        
+
         Args:
             channels: List of channel names to subscribe to.
-                     Channel names should follow the pattern "source:type".
-                     Examples: ["kalshi:markets", "espn:games", "twitter:sentiment"]
-        
+                      Channel names should follow the pattern "source:type".
+                      Examples: ["neural:markets", "espn:games", "twitter:sentiment"]
+
         Raises:
             RuntimeError: If not connected to Redis.
             ValueError: If channels list is empty.
-        
+
         Example:
             >>> await consumer.subscribe([
-            ...     "kalshi:markets",
-            ...     "kalshi:signals",
+            ...     "neural:markets",
+            ...     "neural:signals",
             ...     "espn:games"
             ... ])
-        
+
         Note:
             Subscribing to new channels will replace any existing subscriptions.
             To add channels, get current channels first and append new ones.
         """
         if not self.pubsub:
-            raise RuntimeError("Not connected to Redis. Call connect() first.")
-        
+            if not self.redis_client:
+                raise RuntimeError("Not connected to Redis. Call connect() first.")
+            self.pubsub = self.redis_client.pubsub()
+
         if not channels:
             raise ValueError("Channels list cannot be empty")
-        
-        await self.pubsub.subscribe(*channels)
+
+        if self.pubsub:
+            await self.pubsub.subscribe(*channels)
         self.subscribed_channels = channels
         logger.info(f"{self.agent_name} subscribed to: {channels}")
-    
+
     async def start_consuming(self) -> None:
         """
         Start consuming messages from subscribed channels.
-        
+
         This method runs an infinite loop processing incoming messages.
         It should be run as a background task in production.
-        
+
         The consumption loop:
         1. Waits for messages on subscribed channels
         2. Parses and validates incoming messages
         3. Routes to appropriate handlers
         4. Tracks statistics
         5. Handles errors gracefully
-        
+
         Raises:
             RuntimeError: If not connected to Redis or no channels subscribed.
-        
+
         Example:
             >>> # Run as background task
             >>> task = asyncio.create_task(consumer.start_consuming())
-            >>> 
             >>> # Or await directly (blocks)
             >>> await consumer.start_consuming()
-        
+
         Note:
             Call stop_consuming() or disconnect() to stop the consumption loop.
             The loop will also stop if the Redis connection is lost.
         """
         if not self.pubsub:
             raise RuntimeError("Not connected to Redis")
-        
+
         if not self.subscribed_channels:
             logger.warning(f"{self.agent_name} no channels subscribed")
-        
+
         self.is_running = True
         logger.info(f"{self.agent_name} starting message consumption")
-        
+
         try:
             async for message in self.pubsub.listen():
                 if not self.is_running:
                     logger.info(f"{self.agent_name} stopping consumption")
                     break
-                
+
                 # Skip non-message types (subscribe confirmations, etc)
-                if message['type'] not in ('message', 'pmessage'):
+                if message["type"] not in ("message", "pmessage"):
                     continue
-                    
+
                 await self._handle_message(message)
-                
+
         except asyncio.CancelledError:
             logger.info(f"{self.agent_name} consumption cancelled")
             raise
@@ -330,74 +369,74 @@ async def start_consuming(self) -> None:
             logger.error(f"{self.agent_name} consumption error: {e}")
             self.is_running = False
             raise
-    
+
     async def _handle_message(self, message: Dict[str, Any]) -> None:
         """
         Internal method to handle incoming Redis messages.
-        
+
         Parses the message, updates statistics, and routes to appropriate
         handler. Errors in message processing are logged but don't stop
         the consumer.
-        
+
         Args:
             message: Raw message dict from Redis with keys:
                     - type: Message type (message, pmessage, subscribe, etc)
                     - channel: Channel name (bytes)
                     - data: Message payload (bytes)
-        
+
         Note:
             This method should not be called directly. It's invoked by
             the consumption loop in start_consuming().
         """
         try:
-            channel = message['channel'].decode('utf-8')
-            data = json.loads(message['data'])
-            
+            channel = message["channel"].decode("utf-8")
+            data = json.loads(message["data"])
+
             self.messages_received += 1
             self.last_message_time = datetime.utcnow()
-            
+
             # Log message receipt (debug level to avoid spam)
-            logger.debug(f"{self.agent_name} received on {channel}: {data.get('type', 'unknown')}")
-            
+            logger.debug(
+                f"{self.agent_name} received on {channel}: {data.get('type', 'unknown')}"
+            )
+
             # Route to channel-specific handler if registered
             if channel in self.channel_handlers:
                 await self.channel_handlers[channel](data)
             else:
                 # Default routing to process_message
                 await self.process_message(channel, data)
-            
+
             self.messages_processed += 1
-            
-            # Save stats to KV if Agentuity context available
-            if self.agent_context and self.messages_processed % 100 == 0:
-                await self._save_stats()
-                
+
         except json.JSONDecodeError as e:
             logger.error(f"{self.agent_name} invalid JSON in message: {e}")
         except Exception as e:
-            logger.error(f"{self.agent_name} error processing message: {e}", exc_info=True)
-    
+            logger.error(
+                f"{self.agent_name} error processing message: {e}", exc_info=True
+            )
+
     @abstractmethod
     async def process_message(self, channel: str, data: Dict[str, Any]) -> None:
         """
         Process an incoming message from a Redis channel.
-        
+
         This method must be implemented by all subclasses to define
         agent-specific message processing logic.
-        
+
         Args:
             channel: The Redis channel the message was received from.
-                    Format: "source:type" (e.g., "kalshi:markets")
+                    Format: "source:type" (e.g., "neural:markets")
             data: Parsed message data containing:
                  - timestamp: ISO format timestamp
                  - type: Message type (market_update, trade, signal, etc)
                  - data: Message-specific payload
                  - source: Originating service
-        
+
         Example Implementation:
             ```python
             async def process_message(self, channel: str, data: Dict[str, Any]):
-                if channel == "kalshi:markets":
+                if channel == "neural:markets":
                     market_data = data['data']
                     if self.detect_arbitrage(market_data):
                         await self.publish_signal({
@@ -408,34 +447,34 @@ async def process_message(self, channel: str, data: Dict[str, Any]):
                 elif channel == "espn:games":
                     await self.handle_game_event(data['data'])
             ```
-        
+
         Note:
             - This method should not raise exceptions - handle errors internally
             - Long-running operations should be offloaded to background tasks
             - Consider using channel_handlers for better organization
         """
         pass
-    
+
     async def publish(self, channel: str, data: Dict[str, Any]) -> bool:
         """
         Publish a message to a Redis channel.
-        
+
         Wraps the data with metadata (timestamp, source) before publishing.
-        
+
         Args:
-            channel: Target channel name (e.g., "kalshi:signals")
+            channel: Target channel name (e.g., "neural:signals")
             data: Message payload to publish
-        
+
         Returns:
             bool: True if published successfully, False otherwise
-        
+
         Example:
-            >>> success = await consumer.publish("kalshi:signals", {
+            >>> success = await consumer.publish("neural:signals", {
             ...     "type": "BUY_SIGNAL",
             ...     "market": "NFL-WINNER",
             ...     "confidence": 0.75
             ... })
-        
+
         Note:
             Publishing is fire-and-forget - no guarantee of delivery.
             Use appropriate channel conventions for your system.
@@ -443,13 +482,13 @@ async def publish(self, channel: str, data: Dict[str, Any]) -> bool:
         if not self.publisher:
             logger.warning(f"{self.agent_name} not connected, cannot publish")
             return False
-        
+
         message = {
             "timestamp": datetime.utcnow().isoformat(),
             "source": self.agent_name,
-            "data": data
+            "data": data,
         }
-        
+
         try:
             await self.publisher.publish(channel, json.dumps(message))
             self.messages_published += 1
@@ -458,14 +497,14 @@ async def publish(self, channel: str, data: Dict[str, Any]) -> bool:
         except Exception as e:
             logger.error(f"{self.agent_name} publish error: {e}")
             return False
-    
+
     async def publish_signal(self, signal: Dict[str, Any]) -> bool:
         """
         Publish a trading signal to the signals channel.
-        
+
         Convenience method for publishing trading signals with
         standardized format.
-        
+
         Args:
             signal: Signal data containing:
                    - action: BUY, SELL, HOLD
@@ -473,10 +512,10 @@ async def publish_signal(self, signal: Dict[str, Any]) -> bool:
                    - confidence: Signal confidence (0-1)
                    - size: Optional position size
                    - reason: Optional explanation
-        
+
         Returns:
             bool: True if published successfully
-        
+
         Example:
             >>> await consumer.publish_signal({
             ...     "action": "BUY",
@@ -487,15 +526,12 @@ async def publish_signal(self, signal: Dict[str, Any]) -> bool:
             ...     "reason": "Arbitrage opportunity detected"
             ... })
         """
-        return await self.publish("kalshi:signals", {
-            "type": "signal",
-            **signal
-        })
-    
+        return await self.publish("neural:signals", {"type": "signal", **signal})
+
     async def publish_trade(self, trade: Dict[str, Any]) -> bool:
         """
         Publish a trade execution to the trades channel.
-        
+
         Args:
             trade: Trade data containing:
                   - market: Market ticker
@@ -504,10 +540,10 @@ async def publish_trade(self, trade: Dict[str, Any]) -> bool:
                   - quantity: Number of contracts
                   - order_id: Order identifier
                   - status: PENDING, FILLED, CANCELLED
-        
+
         Returns:
             bool: True if published successfully
-        
+
         Example:
             >>> await consumer.publish_trade({
             ...     "market": "NFL-CHAMPIONSHIP",
@@ -518,25 +554,22 @@ async def publish_trade(self, trade: Dict[str, Any]) -> bool:
             ...     "status": "FILLED"
             ... })
         """
-        return await self.publish("kalshi:trades", {
-            "type": "trade",
-            **trade
-        })
-    
+        return await self.publish("neural:trades", {"type": "trade", **trade})
+
     async def publish_risk_alert(self, alert: Dict[str, Any]) -> bool:
         """
         Publish a risk management alert.
-        
+
         Args:
             alert: Alert data containing:
                   - severity: LOW, MEDIUM, HIGH, CRITICAL
                   - type: POSITION_LIMIT, DRAWDOWN, CORRELATION, etc
                   - message: Human-readable alert message
                   - data: Alert-specific data
-        
+
         Returns:
             bool: True if published successfully
-        
+
         Example:
             >>> await consumer.publish_risk_alert({
             ...     "severity": "HIGH",
@@ -545,108 +578,68 @@ async def publish_risk_alert(self, alert: Dict[str, Any]) -> bool:
             ...     "data": {"current": 0.18, "limit": 0.20}
             ... })
         """
-        return await self.publish("kalshi:risk", {
-            "type": "risk_alert",
-            **alert
-        })
-    
+        return await self.publish("neural:risk", {"type": "risk_alert", **alert})
+
     def register_handler(self, channel: str, handler: Callable) -> None:
         """
         Register a custom handler for a specific channel.
-        
+
         Allows channel-specific processing logic without modifying
         the main process_message method.
-        
+
         Args:
             channel: Channel name to handle
             handler: Async function that accepts message data dict
-        
+
         Example:
             >>> async def handle_markets(data: Dict[str, Any]):
             ...     print(f"Market update: {data}")
-            >>> 
-            >>> consumer.register_handler("kalshi:markets", handle_markets)
-        
+            >>>
+            >>> consumer.register_handler("neural:markets", handle_markets)
+
         Note:
             Handlers override the default process_message routing.
             Only one handler per channel is supported.
         """
         self.channel_handlers[channel] = handler
         logger.info(f"{self.agent_name} registered handler for {channel}")
-    
-    async def _save_stats(self) -> None:
-        """
-        Save consumer statistics to Agentuity KV storage.
-        
-        Internal method called periodically to persist statistics
-        for monitoring and debugging.
-        """
-        if not self.agent_context:
-            return
-        
-        try:
-            stats = {
-                "messages_received": self.messages_received,
-                "messages_processed": self.messages_processed,
-                "messages_published": self.messages_published,
-                "last_message_time": self.last_message_time.isoformat() if self.last_message_time else None,
-                "subscribed_channels": self.subscribed_channels
-            }
-            
-            await self.agent_context.kv.set(
-                "agent_stats",
-                f"{self.agent_name}_redis",
-                stats
-            )
-        except Exception as e:
-            logger.debug(f"Could not save stats: {e}")
-    
-    def get_stats(self) -> Dict[str, Any]:
+
+    def get_stats(self) -> AgentStats:
         """
         Get current consumer statistics.
-        
+
         Returns:
-            Dict containing:
-            - agent: Agent name
-            - connected: Connection status
-            - running: Processing status
-            - messages_received: Total received
-            - messages_processed: Successfully processed
-            - messages_published: Total published
-            - last_message_time: Last message timestamp
-            - subscribed_channels: List of channels
-        
+            AgentStats object with current metrics
+
         Example:
             >>> stats = consumer.get_stats()
-            >>> print(f"Processed {stats['messages_processed']} messages")
-        """
-        return {
-            "agent": self.agent_name,
-            "connected": self.redis_client is not None,
-            "running": self.is_running,
-            "messages_received": self.messages_received,
-            "messages_processed": self.messages_processed,
-            "messages_published": self.messages_published,
-            "last_message_time": self.last_message_time.isoformat() if self.last_message_time else None,
-            "subscribed_channels": self.subscribed_channels
-        }
-    
+            >>> print(f"Processed {stats.messages_processed} messages")
+        """
+        return AgentStats(
+            agent_name=self.agent_name,
+            status=AgentStatus.RUNNING if self.is_running else AgentStatus.STOPPED,
+            messages_received=self.messages_received,
+            messages_processed=self.messages_processed,
+            messages_published=self.messages_published,
+            last_message_time=self.last_message_time,
+        )
+
     async def health_check(self) -> bool:
         """
         Check if the consumer is healthy and operational.
-        
+
         Performs a Redis ping to verify connectivity.
-        
+
         Returns:
             bool: True if healthy (connected and responsive), False otherwise
-        
+
         Example:
             >>> if not await consumer.health_check():
             ...     await consumer.connect()  # Try to reconnect
         """
         if not self.redis_client:
             return False
-        
+
         try:
             await self.redis_client.ping()
             return True
@@ -654,161 +647,157 @@ async def health_check(self) -> bool:
             return False
 
 
-class AgentRedisOrchestrator:
+class AgentOrchestrator:
     """
     Orchestrates multiple agent Redis consumers for coordinated operation.
-    
+
     This class manages the lifecycle of multiple consumers, allowing them
     to be started, stopped, and monitored as a group. Useful for running
     the complete agent system.
-    
+
     Attributes:
         redis_url (str): Redis connection URL shared by all consumers
         consumers (Dict[str, BaseAgentRedisConsumer]): Registered consumers by name
         tasks (List[asyncio.Task]): Background tasks for each consumer
-    
+
     Example:
         ```python
-        orchestrator = AgentRedisOrchestrator()
+        orchestrator = AgentOrchestrator()
         orchestrator.register_consumer(DataCoordinatorConsumer())
         orchestrator.register_consumer(MarketEngineerConsumer())
         orchestrator.register_consumer(TradeExecutorConsumer())
-        
+
         await orchestrator.start_all()
-        
+
         # Run for some time...
         stats = orchestrator.get_all_stats()
-        
+
         await orchestrator.stop_all()
         ```
     """
-    
-    def __init__(self, redis_url: str = "redis://localhost:6379"):
+
+    def __init__(self, config: Optional[OrchestratorConfig] = None):
         """
         Initialize the orchestrator.
-        
+
         Args:
-            redis_url: Redis connection URL to be used by all consumers
+            config: Orchestrator configuration
         """
-        self.redis_url = redis_url
+        self.config = config or OrchestratorConfig()
         self.consumers: Dict[str, BaseAgentRedisConsumer] = {}
         self.tasks: List[asyncio.Task] = []
-        
+
     def register_consumer(self, consumer: BaseAgentRedisConsumer) -> None:
         """
         Register a consumer to be managed by the orchestrator.
-        
+
         Args:
             consumer: Consumer instance to register
-        
+
         Raises:
             ValueError: If a consumer with the same name is already registered
-        
+
         Example:
             >>> orchestrator.register_consumer(MyConsumer("Agent1"))
         """
         if consumer.agent_name in self.consumers:
             raise ValueError(f"Consumer {consumer.agent_name} already registered")
-            
+
         self.consumers[consumer.agent_name] = consumer
         logger.info(f"Registered consumer: {consumer.agent_name}")
-    
+
     async def start_all(self) -> None:
         """
         Start all registered consumers concurrently.
-        
+
         Each consumer:
         1. Connects to Redis
         2. Subscribes to its channels
         3. Starts consuming in a background task
-        
+
         Raises:
             RuntimeError: If no consumers are registered
-        
+
         Example:
             >>> await orchestrator.start_all()
             >>> # All consumers now running in background
         """
         if not self.consumers:
             raise RuntimeError("No consumers registered")
-            
+
         for name, consumer in self.consumers.items():
             logger.info(f"Starting {name}...")
-            
+
             # Connect and subscribe
             await consumer.connect()
-            
+
             # Start consuming in background
             task = asyncio.create_task(
-                consumer.start_consuming(),
-                name=f"consumer_{name}"
+                consumer.start_consuming(), name=f"consumer_{name}"
             )
             self.tasks.append(task)
-        
+
         logger.info(f"Started {len(self.consumers)} consumers")
-    
+
     async def stop_all(self) -> None:
         """
         Stop all consumers gracefully.
-        
+
         Process:
         1. Signal all consumers to stop
         2. Cancel background tasks
         3. Disconnect from Redis
         4. Clean up resources
-        
+
         Safe to call multiple times.
-        
+
         Example:
             >>> await orchestrator.stop_all()
         """
         # Signal consumers to stop
         for consumer in self.consumers.values():
             consumer.is_running = False
-        
+
         # Give consumers time to finish current message
         await asyncio.sleep(0.1)
-        
+
         # Cancel tasks
         for task in self.tasks:
             if not task.done():
                 task.cancel()
-        
+
         # Wait for tasks to complete
         if self.tasks:
             await asyncio.gather(*self.tasks, return_exceptions=True)
-        
+
         # Disconnect all consumers
         for consumer in self.consumers.values():
             await consumer.disconnect()
-        
+
         self.tasks.clear()
         logger.info("All consumers stopped")
-    
-    def get_all_stats(self) -> Dict[str, Any]:
+
+    def get_all_stats(self) -> Dict[str, AgentStats]:
         """
         Get statistics from all registered consumers.
-        
+
         Returns:
             Dict mapping agent names to their statistics
-        
+
         Example:
             >>> stats = orchestrator.get_all_stats()
             >>> for agent, data in stats.items():
-            ...     print(f"{agent}: {data['messages_processed']} processed")
+            ...     print(f"{agent}: {data.messages_processed} processed")
         """
-        return {
-            name: consumer.get_stats()
-            for name, consumer in self.consumers.items()
-        }
-    
+        return {name: consumer.get_stats() for name, consumer in self.consumers.items()}
+
     async def health_check_all(self) -> Dict[str, bool]:
         """
         Perform health checks on all consumers.
-        
+
         Returns:
             Dict mapping agent names to health status (True/False)
-        
+
         Example:
             >>> health = await orchestrator.health_check_all()
             >>> unhealthy = [name for name, ok in health.items() if not ok]
@@ -818,4 +807,25 @@ async def health_check_all(self) -> Dict[str, bool]:
         results = {}
         for name, consumer in self.consumers.items():
             results[name] = await consumer.health_check()
-        return results
\ No newline at end of file
+        return results
+
+    def get_consumer(self, name: str) -> Optional[BaseAgentRedisConsumer]:
+        """
+        Get a specific consumer by name.
+
+        Args:
+            name: Consumer name
+
+        Returns:
+            Consumer instance or None if not found
+        """
+        return self.consumers.get(name)
+
+    def list_consumers(self) -> List[str]:
+        """
+        List all registered consumer names.
+
+        Returns:
+            List of consumer names
+        """
+        return list(self.consumers.keys())
diff --git a/neural_sdk/agents/types.py b/neural_sdk/agents/types.py
new file mode 100644
index 00000000..0a742cd3
--- /dev/null
+++ b/neural_sdk/agents/types.py
@@ -0,0 +1,142 @@
+"""
+Type definitions and enums for the agent framework.
+
+This module defines the core types, enums, and data structures
+used throughout the agent system.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional
+
+
+class AgentType(Enum):
+    """Types of agents in the system."""
+
+    DATA_COORDINATOR = "data_coordinator"
+    PORTFOLIO_MONITOR = "portfolio_monitor"
+    GAME_ANALYST = "game_analyst"
+    ARBITRAGE_HUNTER = "arbitrage_hunter"
+    STRATEGY_OPTIMIZER = "strategy_optimizer"
+    RISK_MANAGER = "risk_manager"
+    MARKET_ENGINEER = "market_engineer"
+
+
+class AgentStatus(Enum):
+    """Status of an agent."""
+
+    INITIALIZING = "initializing"
+    RUNNING = "running"
+    PAUSED = "paused"
+    STOPPED = "stopped"
+    ERROR = "error"
+
+
+class TriggerPriority(Enum):
+    """Priority levels for agent activation triggers."""
+
+    CRITICAL = 1
+    HIGH = 2
+    MEDIUM = 3
+    LOW = 4
+
+
+@dataclass
+class AgentStats:
+    """Statistics for an agent."""
+
+    agent_name: str
+    status: AgentStatus
+    messages_received: int = 0
+    messages_processed: int = 0
+    messages_published: int = 0
+    last_message_time: Optional[datetime] = None
+    uptime_seconds: float = 0.0
+    error_count: int = 0
+    last_error: Optional[str] = None
+
+    @property
+    def processing_rate(self) -> float:
+        """Calculate messages processed per second."""
+        if self.uptime_seconds == 0:
+            return 0.0
+        return self.messages_processed / self.uptime_seconds
+
+
+@dataclass
+class TriggerCondition:
+    """Represents a trigger condition for agent activation."""
+
+    name: str
+    condition_func: Callable[[Dict[str, Any]], bool]
+    agent_type: AgentType
+    priority: TriggerPriority
+    cooldown_seconds: int = 60
+    last_triggered: Optional[datetime] = None
+    trigger_count: int = 0
+
+    def can_trigger(self) -> bool:
+        """Check if trigger is off cooldown."""
+        if self.last_triggered is None:
+            return True
+
+        elapsed = (datetime.now() - self.last_triggered).total_seconds()
+        return elapsed >= self.cooldown_seconds
+
+    def evaluate(self, data: Dict[str, Any]) -> bool:
+        """Evaluate if condition is met."""
+        if not self.can_trigger():
+            return False
+
+        try:
+            return self.condition_func(data)
+        except Exception:
+            return False
+
+    def mark_triggered(self):
+        """Mark this trigger as having fired."""
+        self.last_triggered = datetime.now()
+        self.trigger_count += 1
+
+
+@dataclass
+class AgentMessage:
+    """Standardized message format for agent communication."""
+
+    message_type: str
+    source_agent: str
+    target_agent: Optional[str] = None
+    data: Dict[str, Any] = field(default_factory=dict)
+    timestamp: datetime = field(default_factory=datetime.utcnow)
+    correlation_id: Optional[str] = None
+    priority: TriggerPriority = TriggerPriority.MEDIUM
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for an individual agent."""
+
+    agent_type: AgentType
+    name: str
+    redis_url: str = "redis://localhost:6379"
+    channels: List[str] = field(default_factory=list)
+    max_concurrent_tasks: int = 10
+    enable_health_checks: bool = True
+    health_check_interval: int = 30
+    enable_metrics: bool = True
+    custom_config: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class OrchestratorConfig:
+    """Configuration for the agent orchestrator."""
+
+    redis_url: str = "redis://localhost:6379"
+    enable_auto_restart: bool = True
+    max_restart_attempts: int = 3
+    restart_delay_seconds: int = 5
+    enable_health_monitoring: bool = True
+    health_check_interval: int = 30
+    enable_metrics_collection: bool = True
+    metrics_retention_hours: int = 24
diff --git a/neural_sdk/backtesting/__init__.py b/neural_sdk/backtesting/__init__.py
new file mode 100644
index 00000000..93d9e559
--- /dev/null
+++ b/neural_sdk/backtesting/__init__.py
@@ -0,0 +1,49 @@
+"""
+Neural SDK - Backtesting Module
+
+Comprehensive backtesting framework for prediction market trading strategies.
+
+Features:
+- Event-driven backtesting engine
+- Multiple data source support
+- Portfolio simulation
+- Performance analytics
+- Risk metrics
+- Strategy comparison tools
+
+Example:
+    ```python
+    from neural_sdk.backtesting import BacktestEngine, BacktestConfig
+
+    config = BacktestConfig(
+        start_date="2024-01-01",
+        end_date="2024-12-31",
+        initial_capital=10000
+    )
+
+    engine = BacktestEngine(config)
+    engine.add_strategy(my_strategy)
+    engine.load_data("file", path="data/nfl_2024.parquet")
+
+    results = engine.run()
+    metrics = engine.analyze()
+    ```
+"""
+
+from .data_loader import DataLoader
+from .engine import BacktestConfig, BacktestEngine, BacktestResults
+from .metrics import PerformanceMetrics
+from .portfolio import Portfolio, Position, Trade
+from .providers.base import DataProvider
+
+__all__ = [
+    "BacktestEngine",
+    "BacktestConfig",
+    "BacktestResults",
+    "Portfolio",
+    "Position",
+    "Trade",
+    "PerformanceMetrics",
+    "DataLoader",
+    "DataProvider",
+]
diff --git a/neural_sdk/backtesting/data_loader.py b/neural_sdk/backtesting/data_loader.py
new file mode 100644
index 00000000..44abab70
--- /dev/null
+++ b/neural_sdk/backtesting/data_loader.py
@@ -0,0 +1,400 @@
+"""
+Data Loader for Backtesting Module
+
+Unified interface for loading historical data from multiple sources.
+Handles data validation, caching, and format standardization.
+"""
+
+import hashlib
+import logging
+import pickle
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import pandas as pd
+
+from .providers.base import DataError, DataProvider
+from .providers.csv_provider import CSVProvider
+from .providers.parquet_provider import ParquetProvider
+
+logger = logging.getLogger(__name__)
+
+try:
+    from .providers.s3_provider import S3Provider
+
+    S3_AVAILABLE = True
+except ImportError:
+    S3_AVAILABLE = False
+
+try:
+    from .providers.database_provider import DatabaseProvider
+
+    DATABASE_AVAILABLE = True
+except ImportError:
+    DATABASE_AVAILABLE = False
+
+
+class DataLoader:
+    """
+    Unified data loader with caching and multi-source support.
+
+    Supports:
+    - CSV files
+    - Parquet files
+    - S3 buckets
+    - PostgreSQL databases
+    - Data caching for performance
+    - Format validation
+
+    Example:
+        ```python
+        loader = DataLoader(cache_dir="~/.neural_sdk/cache")
+
+        # Load from CSV
+        data = loader.load("file", path="trades.csv")
+
+        # Load from S3 with caching
+        data = loader.load("s3", bucket="my-data", prefix="2024/")
+
+        # Load from database
+        data = loader.load("postgres",
+                          connection_string="postgresql://...",
+                          query="SELECT * FROM trades")
+        ```
+    """
+
+    def __init__(
+        self,
+        cache_dir: Optional[str] = None,
+        cache_ttl_hours: int = 24,
+        enable_cache: bool = True,
+    ):
+        """
+        Initialize data loader.
+
+        Args:
+            cache_dir: Directory for data cache (None to disable)
+            cache_ttl_hours: Cache time-to-live in hours
+            enable_cache: Enable/disable caching
+        """
+        self.enable_cache = enable_cache and cache_dir is not None
+        self.cache_ttl = timedelta(hours=cache_ttl_hours)
+
+        if self.enable_cache:
+            self.cache_dir = Path(cache_dir).expanduser()
+            self.cache_dir.mkdir(parents=True, exist_ok=True)
+            logger.info(f"Data cache enabled: {self.cache_dir}")
+        else:
+            self.cache_dir = None
+            logger.info("Data cache disabled")
+
+        # Initialize providers
+        self.providers = {
+            "file": CSVProvider(),
+            "csv": CSVProvider(),
+            "parquet": ParquetProvider(),
+        }
+
+        # Add optional providers if available
+        if S3_AVAILABLE:
+            self.providers["s3"] = None  # Lazy initialization
+        if DATABASE_AVAILABLE:
+            self.providers["postgres"] = None
+            self.providers["database"] = None
+
+        logger.info(
+            f"Initialized data loader with providers: {list(self.providers.keys())}"
+        )
+
+    def load(
+        self,
+        source_type: str,
+        cache_key: Optional[str] = None,
+        force_refresh: bool = False,
+        **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Load data from specified source.
+
+        Args:
+            source_type: Type of data source ('file', 'csv', 'parquet', 's3', 'postgres')
+            cache_key: Custom cache key (auto-generated if not provided)
+            force_refresh: Force reload even if cached data exists
+            **kwargs: Source-specific parameters
+
+        Returns:
+            DataFrame with standardized columns
+
+        Raises:
+            ValueError: If source type is not supported
+            DataError: If data loading fails
+        """
+        # Generate cache key if not provided
+        if cache_key is None:
+            cache_key = self._generate_cache_key(source_type, kwargs)
+
+        # Try to load from cache first
+        if self.enable_cache and not force_refresh:
+            cached_data = self._load_from_cache(cache_key)
+            if cached_data is not None:
+                logger.info(f"Loaded data from cache: {cache_key}")
+                return cached_data
+
+        # Load data from source
+        data = self._load_from_source(source_type, **kwargs)
+
+        # Cache the loaded data
+        if self.enable_cache:
+            self._save_to_cache(cache_key, data)
+
+        return data
+
+    def _load_from_source(self, source_type: str, **kwargs) -> pd.DataFrame:
+        """Load data from the specified source type."""
+        if source_type not in self.providers:
+            raise ValueError(
+                f"Unsupported source type: {source_type}. Available: {list(self.providers.keys())}"
+            )
+
+        # Lazy initialization of providers
+        provider = self.providers[source_type]
+        if provider is None:
+            provider = self._initialize_provider(source_type, **kwargs)
+
+        # Extract source parameter
+        source = kwargs.pop("path", None) or kwargs.pop("source", None)
+        if source is None and source_type in ["file", "csv", "parquet"]:
+            raise ValueError(f"'path' parameter required for {source_type} source")
+
+        # Load data using provider
+        data = provider.fetch(source, **kwargs)
+
+        # Validate standard format
+        self._validate_data_format(data)
+
+        logger.info(f"Loaded {len(data)} records from {source_type} source")
+        return data
+
+    def _initialize_provider(self, source_type: str, **kwargs) -> DataProvider:
+        """Initialize provider with configuration."""
+        if source_type == "s3":
+            if not S3_AVAILABLE:
+                raise ImportError("S3 provider requires boto3: pip install boto3")
+            from .providers.s3_provider import S3Provider
+
+            provider = S3Provider(**kwargs)
+        elif source_type in ["postgres", "database"]:
+            if not DATABASE_AVAILABLE:
+                raise ImportError(
+                    "Database provider requires sqlalchemy: pip install sqlalchemy"
+                )
+            from .providers.database_provider import DatabaseProvider
+
+            provider = DatabaseProvider(**kwargs)
+        else:
+            raise ValueError(f"Cannot initialize provider for: {source_type}")
+
+        self.providers[source_type] = provider
+        return provider
+
+    def _validate_data_format(self, data: pd.DataFrame):
+        """Validate data has required columns and format."""
+        required_columns = ["timestamp", "symbol", "price"]
+        missing_columns = [col for col in required_columns if col not in data.columns]
+
+        if missing_columns:
+            raise DataError(f"Data missing required columns: {missing_columns}")
+
+        # Ensure timestamp is datetime
+        if not pd.api.types.is_datetime64_any_dtype(data["timestamp"]):
+            data["timestamp"] = pd.to_datetime(data["timestamp"])
+
+        # Validate data types
+        if not pd.api.types.is_numeric_dtype(data["price"]):
+            raise DataError("Price column must be numeric")
+
+    def _generate_cache_key(self, source_type: str, kwargs: Dict[str, Any]) -> str:
+        """Generate unique cache key for the data request."""
+        # Create hash from source type and parameters
+        cache_input = f"{source_type}_{sorted(kwargs.items())}"
+        return hashlib.md5(cache_input.encode()).hexdigest()[:12]
+
+    def _load_from_cache(self, cache_key: str) -> Optional[pd.DataFrame]:
+        """Load data from cache if available and fresh."""
+        cache_file = self.cache_dir / f"{cache_key}.pkl"
+
+        if not cache_file.exists():
+            return None
+
+        # Check if cache is still fresh
+        cache_age = datetime.now() - datetime.fromtimestamp(cache_file.stat().st_mtime)
+        if cache_age > self.cache_ttl:
+            logger.debug(f"Cache expired: {cache_key}")
+            cache_file.unlink()  # Remove expired cache
+            return None
+
+        try:
+            with open(cache_file, "rb") as f:
+                data = pickle.load(f)
+            return data
+        except Exception as e:
+            logger.warning(f"Failed to load cache {cache_key}: {e}")
+            cache_file.unlink()  # Remove corrupted cache
+            return None
+
+    def _save_to_cache(self, cache_key: str, data: pd.DataFrame):
+        """Save data to cache."""
+        cache_file = self.cache_dir / f"{cache_key}.pkl"
+
+        try:
+            with open(cache_file, "wb") as f:
+                pickle.dump(data, f)
+            logger.debug(f"Saved to cache: {cache_key}")
+        except Exception as e:
+            logger.warning(f"Failed to save cache {cache_key}: {e}")
+
+    def clear_cache(self, cache_key: Optional[str] = None):
+        """
+        Clear cache files.
+
+        Args:
+            cache_key: Specific cache key to clear (None to clear all)
+        """
+        if not self.enable_cache:
+            logger.info("Cache is disabled")
+            return
+
+        if cache_key:
+            cache_file = self.cache_dir / f"{cache_key}.pkl"
+            if cache_file.exists():
+                cache_file.unlink()
+                logger.info(f"Cleared cache: {cache_key}")
+        else:
+            # Clear all cache files
+            cache_files = list(self.cache_dir.glob("*.pkl"))
+            for cache_file in cache_files:
+                cache_file.unlink()
+            logger.info(f"Cleared {len(cache_files)} cache files")
+
+    def get_cache_info(self) -> Dict[str, Any]:
+        """Get information about cached data."""
+        if not self.enable_cache:
+            return {"enabled": False}
+
+        cache_files = list(self.cache_dir.glob("*.pkl"))
+        total_size = sum(f.stat().st_size for f in cache_files)
+
+        cache_info = {
+            "enabled": True,
+            "directory": str(self.cache_dir),
+            "files": len(cache_files),
+            "total_size_mb": total_size / (1024 * 1024),
+            "ttl_hours": self.cache_ttl.total_seconds() / 3600,
+        }
+
+        # Get details of each cache file
+        cache_details = []
+        for cache_file in cache_files:
+            stat = cache_file.stat()
+            age_hours = (datetime.now().timestamp() - stat.st_mtime) / 3600
+
+            cache_details.append(
+                {
+                    "key": cache_file.stem,
+                    "size_mb": stat.st_size / (1024 * 1024),
+                    "age_hours": age_hours,
+                    "expired": age_hours > self.cache_ttl.total_seconds() / 3600,
+                }
+            )
+
+        cache_info["details"] = cache_details
+        return cache_info
+
+    def preload_data(
+        self, sources: List[Dict[str, Any]], parallel: bool = True
+    ) -> Dict[str, pd.DataFrame]:
+        """
+        Preload multiple data sources.
+
+        Args:
+            sources: List of source configurations
+                    [{'type': 'csv', 'path': 'data.csv'}, {...}]
+            parallel: Load sources in parallel (if supported)
+
+        Returns:
+            Dictionary mapping source names to DataFrames
+        """
+        results = {}
+
+        for i, source_config in enumerate(sources):
+            source_type = source_config.pop("type")
+            source_name = source_config.pop("name", f"source_{i}")
+
+            try:
+                data = self.load(source_type, **source_config)
+                results[source_name] = data
+                logger.info(f"Preloaded {source_name}: {len(data)} records")
+            except Exception as e:
+                logger.error(f"Failed to preload {source_name}: {e}")
+                results[source_name] = None
+
+        return results
+
+    def get_supported_sources(self) -> List[str]:
+        """Get list of supported data source types."""
+        return list(self.providers.keys())
+
+    def validate_source_config(self, source_type: str, **kwargs) -> Dict[str, Any]:
+        """
+        Validate source configuration without loading data.
+
+        Args:
+            source_type: Type of data source
+            **kwargs: Source configuration
+
+        Returns:
+            Validation results
+        """
+        validation = {"valid": False, "errors": [], "warnings": []}
+
+        try:
+            # Check if source type is supported
+            if source_type not in self.providers:
+                validation["errors"].append(f"Unsupported source type: {source_type}")
+                return validation
+
+            # Basic parameter validation
+            if source_type in ["file", "csv", "parquet"]:
+                if "path" not in kwargs:
+                    validation["errors"].append("'path' parameter required")
+                else:
+                    path = Path(kwargs["path"])
+                    if not path.exists():
+                        validation["errors"].append(f"File not found: {path}")
+                    elif path.is_dir():
+                        validation["errors"].append(
+                            f"Path is directory, not file: {path}"
+                        )
+
+            elif source_type == "s3":
+                required_params = ["bucket"]
+                missing = [p for p in required_params if p not in kwargs]
+                if missing:
+                    validation["errors"].append(
+                        f"Missing required parameters: {missing}"
+                    )
+
+            elif source_type in ["postgres", "database"]:
+                if "connection_string" not in kwargs and "host" not in kwargs:
+                    validation["errors"].append(
+                        "Database connection parameters required"
+                    )
+
+            if not validation["errors"]:
+                validation["valid"] = True
+
+        except Exception as e:
+            validation["errors"].append(f"Validation error: {e}")
+
+        return validation
diff --git a/neural_sdk/backtesting/engine.py b/neural_sdk/backtesting/engine.py
new file mode 100644
index 00000000..985613e9
--- /dev/null
+++ b/neural_sdk/backtesting/engine.py
@@ -0,0 +1,471 @@
+"""
+Backtesting Engine for Neural SDK Trading Strategies
+
+Event-driven backtesting with realistic order execution and portfolio simulation.
+"""
+
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+from .data_loader import DataLoader
+from .metrics import PerformanceMetrics
+from .portfolio import Portfolio, Trade
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BacktestConfig:
+    """Configuration for backtesting engine."""
+
+    start_date: str
+    end_date: str
+    initial_capital: float = 10000.0
+    commission: float = 0.02  # Default 2% commission
+    slippage: float = 0.01  # 1% slippage estimate
+    data_frequency: str = "1min"
+    max_positions: int = 20
+    position_size_limit: float = 0.05  # Max 5% per position
+    stop_loss: Optional[float] = None  # Global stop loss
+    take_profit: Optional[float] = None  # Global take profit
+
+    # Risk management
+    daily_loss_limit: float = 0.20  # Stop at 20% daily loss
+    max_drawdown_limit: float = 0.30  # Stop at 30% drawdown
+
+    # Market impact simulation
+    liquidity_adjustment: bool = True
+    market_hours_only: bool = False
+
+    def __post_init__(self):
+        """Validate configuration."""
+        if pd.to_datetime(self.start_date) >= pd.to_datetime(self.end_date):
+            raise ValueError("start_date must be before end_date")
+        if self.initial_capital <= 0:
+            raise ValueError("initial_capital must be positive")
+        if not 0 <= self.commission <= 1:
+            raise ValueError("commission must be between 0 and 1")
+
+
+@dataclass
+class BacktestResults:
+    """Results from backtesting run."""
+
+    portfolio_value: pd.Series
+    trades: List[Trade]
+    positions: pd.DataFrame
+    daily_returns: pd.Series
+    metrics: Dict[str, float]
+    config: BacktestConfig
+    start_time: datetime
+    end_time: datetime
+
+    @property
+    def duration(self) -> timedelta:
+        """Duration of backtest."""
+        return self.end_time - self.start_time
+
+    @property
+    def total_return(self) -> float:
+        """Total return percentage."""
+        return (self.portfolio_value.iloc[-1] / self.portfolio_value.iloc[0] - 1) * 100
+
+    @property
+    def num_trades(self) -> int:
+        """Total number of trades."""
+        return len(self.trades)
+
+    def plot(self, save_path: Optional[str] = None):
+        """Plot backtest results."""
+        try:
+            import matplotlib.pyplot as plt
+            import seaborn as sns
+
+            fig, axes = plt.subplots(2, 2, figsize=(15, 10))
+
+            # Portfolio value over time
+            axes[0, 0].plot(self.portfolio_value.index, self.portfolio_value.values)
+            axes[0, 0].set_title("Portfolio Value Over Time")
+            axes[0, 0].set_ylabel("Value ($)")
+
+            # Daily returns distribution
+            axes[0, 1].hist(self.daily_returns.dropna(), bins=50, alpha=0.7)
+            axes[0, 1].set_title("Daily Returns Distribution")
+            axes[0, 1].set_xlabel("Daily Return (%)")
+
+            # Cumulative returns
+            cum_returns = self.daily_returns.cumsum()
+            axes[1, 0].plot(cum_returns.index, cum_returns.values)
+            axes[1, 0].set_title("Cumulative Returns")
+            axes[1, 0].set_ylabel("Cumulative Return (%)")
+
+            # Drawdown
+            rolling_max = self.portfolio_value.expanding().max()
+            drawdown = (self.portfolio_value - rolling_max) / rolling_max * 100
+            axes[1, 1].fill_between(drawdown.index, drawdown.values, 0, alpha=0.3)
+            axes[1, 1].set_title("Drawdown")
+            axes[1, 1].set_ylabel("Drawdown (%)")
+
+            plt.tight_layout()
+
+            if save_path:
+                plt.savefig(save_path, dpi=300, bbox_inches="tight")
+            else:
+                plt.show()
+
+        except ImportError:
+            logger.warning("Matplotlib not available. Cannot plot results.")
+
+    def export_report(self, path: str):
+        """Export detailed HTML report."""
+        html = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>Neural SDK Backtest Report</title>
+            <style>
+                body {{ font-family: Arial, sans-serif; margin: 40px; }}
+                .metric {{ margin: 10px 0; }}
+                .highlight {{ color: #007bff; font-weight: bold; }}
+                table {{ border-collapse: collapse; width: 100%; margin: 20px 0; }}
+                th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
+                th {{ background-color: #f2f2f2; }}
+            </style>
+        </head>
+        <body>
+            <h1>Neural SDK Backtest Report</h1>
+            
+            <h2>Summary</h2>
+            <div class="metric">Period: <span class="highlight">{self.config.start_date} to {self.config.end_date}</span></div>
+            <div class="metric">Initial Capital: <span class="highlight">${self.config.initial_capital:,.2f}</span></div>
+            <div class="metric">Final Value: <span class="highlight">${self.portfolio_value.iloc[-1]:,.2f}</span></div>
+            <div class="metric">Total Return: <span class="highlight">{self.total_return:.2f}%</span></div>
+            <div class="metric">Total Trades: <span class="highlight">{self.num_trades}</span></div>
+            
+            <h2>Performance Metrics</h2>
+            <table>
+                <tr><th>Metric</th><th>Value</th></tr>
+        """
+
+        for metric, value in self.metrics.items():
+            if isinstance(value, float):
+                html += f"<tr><td>{metric.replace('_', ' ').title()}</td><td>{value:.4f}</td></tr>"
+            else:
+                html += f"<tr><td>{metric.replace('_', ' ').title()}</td><td>{value}</td></tr>"
+
+        html += """
+            </table>
+            
+            <h2>Trade History</h2>
+            <table>
+                <tr>
+                    <th>Date</th>
+                    <th>Symbol</th>
+                    <th>Action</th>
+                    <th>Quantity</th>
+                    <th>Price</th>
+                    <th>Value</th>
+                    <th>P&L</th>
+                </tr>
+        """
+
+        for trade in self.trades[-50:]:  # Last 50 trades
+            pnl = trade.pnl if trade.pnl else 0
+            html += f"""
+                <tr>
+                    <td>{trade.timestamp.strftime('%Y-%m-%d %H:%M')}</td>
+                    <td>{trade.symbol}</td>
+                    <td>{trade.action}</td>
+                    <td>{trade.quantity}</td>
+                    <td>${trade.price:.2f}</td>
+                    <td>${trade.value:.2f}</td>
+                    <td>${pnl:.2f}</td>
+                </tr>
+            """
+
+        html += """
+            </table>
+        </body>
+        </html>
+        """
+
+        with open(path, "w") as f:
+            f.write(html)
+
+
+class BacktestEngine:
+    """
+    High-performance backtesting engine for prediction market trading strategies.
+
+    Features:
+    - Event-driven simulation
+    - Realistic order execution
+    - Portfolio tracking
+    - Risk management
+    - Performance analytics
+    """
+
+    def __init__(self, config: BacktestConfig):
+        self.config = config
+        self.portfolio = Portfolio(config.initial_capital)
+        self.data_loader = DataLoader()
+        self.strategy = None
+        self.data = None
+        self.current_time = None
+        self.results = None
+
+        # Performance tracking
+        self.daily_values = []
+        self.trades = []
+
+        # Risk management state
+        self.daily_start_value = config.initial_capital
+        self.max_portfolio_value = config.initial_capital
+
+        logger.info(
+            f"Initialized backtest engine: {config.start_date} to {config.end_date}"
+        )
+
+    def add_strategy(
+        self, strategy: Callable[[Dict[str, Any]], Optional[Dict[str, Any]]]
+    ):
+        """
+        Add trading strategy to backtest.
+
+        Args:
+            strategy: Function that takes market data and returns trading signals
+                     Should return dict with keys: action, size, market, price (optional)
+        """
+        self.strategy = strategy
+        logger.info("Added trading strategy")
+
+    def load_data(self, source: str, **kwargs) -> pd.DataFrame:
+        """
+        Load historical data from various sources.
+
+        Args:
+            source: Data source type ('file', 's3', 'postgres', 'api')
+            **kwargs: Source-specific parameters
+
+        Returns:
+            DataFrame with OHLCV data
+        """
+        self.data = self.data_loader.load(source, **kwargs)
+
+        # Validate data
+        required_columns = ["timestamp", "symbol", "price", "volume"]
+        missing_cols = [col for col in required_columns if col not in self.data.columns]
+        if missing_cols:
+            raise ValueError(f"Data missing required columns: {missing_cols}")
+
+        # Filter by date range
+        self.data["timestamp"] = pd.to_datetime(self.data["timestamp"])
+        mask = (self.data["timestamp"] >= self.config.start_date) & (
+            self.data["timestamp"] <= self.config.end_date
+        )
+        self.data = self.data[mask].sort_values("timestamp")
+
+        logger.info(f"Loaded {len(self.data)} data points from {source}")
+        return self.data
+
+    def run(self) -> BacktestResults:
+        """
+        Execute backtest and return results.
+
+        Returns:
+            BacktestResults object with portfolio performance and trades
+        """
+        if self.strategy is None:
+            raise ValueError("No strategy added. Use add_strategy() first.")
+        if self.data is None or len(self.data) == 0:
+            raise ValueError("No data loaded. Use load_data() first.")
+
+        logger.info("Starting backtest execution...")
+        start_time = datetime.now()
+
+        # Group data by timestamp for event-driven simulation
+        for timestamp, group in self.data.groupby("timestamp"):
+            self.current_time = timestamp
+
+            # Check risk limits before processing
+            if self._should_stop_trading():
+                logger.warning(f"Risk limit hit at {timestamp}. Stopping backtest.")
+                break
+
+            # Process market data for this timestamp
+            market_data = self._prepare_market_data(group)
+
+            # Generate trading signals
+            signals = self.strategy(market_data)
+            if signals:
+                self._execute_signals(signals, market_data)
+
+            # Update daily tracking
+            if self._is_new_day(timestamp):
+                self._update_daily_metrics()
+
+            # Record portfolio value
+            current_value = self.portfolio.total_value(market_data)
+            self.daily_values.append(
+                {"timestamp": timestamp, "portfolio_value": current_value}
+            )
+
+        end_time = datetime.now()
+
+        # Calculate final metrics
+        metrics = self._calculate_metrics()
+
+        # Create results object
+        portfolio_df = pd.DataFrame(self.daily_values)
+        portfolio_df.set_index("timestamp", inplace=True)
+
+        daily_returns = portfolio_df["portfolio_value"].pct_change() * 100
+
+        self.results = BacktestResults(
+            portfolio_value=portfolio_df["portfolio_value"],
+            trades=self.trades,
+            positions=self.portfolio.positions_df(),
+            daily_returns=daily_returns,
+            metrics=metrics,
+            config=self.config,
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+        logger.info(f"Backtest completed in {end_time - start_time}")
+        logger.info(
+            f"Final portfolio value: ${self.results.portfolio_value.iloc[-1]:,.2f}"
+        )
+        logger.info(f"Total return: {self.results.total_return:.2f}%")
+
+        return self.results
+
+    def _prepare_market_data(self, group: pd.DataFrame) -> Dict[str, Any]:
+        """Prepare market data for strategy."""
+        return {
+            "timestamp": self.current_time,
+            "data": group.to_dict("records"),
+            "symbols": group["symbol"].unique().tolist(),
+            "prices": dict(zip(group["symbol"], group["price"])),
+            "volumes": dict(zip(group["symbol"], group["volume"])),
+            "portfolio": self.portfolio,
+        }
+
+    def _execute_signals(self, signals: Dict[str, Any], market_data: Dict[str, Any]):
+        """Execute trading signals with realistic constraints."""
+        if not isinstance(signals, dict):
+            return
+
+        action = signals.get("action", "").upper()
+        symbol = signals.get("market") or signals.get("symbol")
+        size = signals.get("size", 0)
+        price = signals.get("price")
+
+        if not all([action, symbol, size]):
+            return
+
+        # Get market price if not specified
+        if price is None:
+            price = market_data["prices"].get(symbol)
+            if price is None:
+                logger.warning(f"No price available for {symbol}")
+                return
+
+        # Apply slippage
+        if action == "BUY":
+            execution_price = price * (1 + self.config.slippage)
+        else:
+            execution_price = price * (1 - self.config.slippage)
+
+        # Execute trade through portfolio
+        success = False
+        if action == "BUY":
+            success = self.portfolio.buy(
+                symbol, size, execution_price, self.current_time
+            )
+        elif action == "SELL":
+            success = self.portfolio.sell(
+                symbol, size, execution_price, self.current_time
+            )
+
+        if success:
+            # Record trade
+            trade_value = size * execution_price
+            commission = trade_value * self.config.commission
+
+            trade = Trade(
+                timestamp=self.current_time,
+                symbol=symbol,
+                action=action,
+                quantity=size,
+                price=execution_price,
+                commission=commission,
+                value=trade_value,
+            )
+            self.trades.append(trade)
+
+            logger.debug(f"Executed: {action} {size} {symbol} @ ${execution_price:.2f}")
+
+    def _should_stop_trading(self) -> bool:
+        """Check if trading should stop due to risk limits."""
+        current_value = self.portfolio.cash + sum(
+            pos.quantity * pos.current_price
+            for pos in self.portfolio.positions.values()
+        )
+
+        # Daily loss limit
+        daily_loss = (current_value - self.daily_start_value) / self.daily_start_value
+        if daily_loss <= -self.config.daily_loss_limit:
+            return True
+
+        # Max drawdown limit
+        if current_value > self.max_portfolio_value:
+            self.max_portfolio_value = current_value
+        drawdown = (self.max_portfolio_value - current_value) / self.max_portfolio_value
+        if drawdown >= self.config.max_drawdown_limit:
+            return True
+
+        return False
+
+    def _is_new_day(self, timestamp: datetime) -> bool:
+        """Check if this is a new trading day."""
+        if not hasattr(self, "_last_day"):
+            self._last_day = timestamp.date()
+            return True
+        if timestamp.date() > self._last_day:
+            self._last_day = timestamp.date()
+            return True
+        return False
+
+    def _update_daily_metrics(self):
+        """Update daily performance metrics."""
+        current_value = self.portfolio.cash + sum(
+            pos.quantity * pos.current_price
+            for pos in self.portfolio.positions.values()
+        )
+        self.daily_start_value = current_value
+
+    def _calculate_metrics(self) -> Dict[str, float]:
+        """Calculate comprehensive performance metrics."""
+        if not self.daily_values:
+            return {}
+
+        values = pd.DataFrame(self.daily_values)
+        values.set_index("timestamp", inplace=True)
+
+        returns = values["portfolio_value"].pct_change().dropna()
+
+        metrics = PerformanceMetrics.calculate_all(
+            returns=returns,
+            portfolio_values=values["portfolio_value"],
+            trades=self.trades,
+            config=self.config,
+        )
+
+        return metrics
diff --git a/neural_sdk/backtesting/metrics.py b/neural_sdk/backtesting/metrics.py
new file mode 100644
index 00000000..ee7f304a
--- /dev/null
+++ b/neural_sdk/backtesting/metrics.py
@@ -0,0 +1,471 @@
+"""
+Performance Metrics for Backtesting
+
+Comprehensive financial metrics for strategy evaluation:
+- Return metrics
+- Risk metrics
+- Risk-adjusted returns
+- Drawdown analysis
+- Trade analysis
+"""
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PerformanceMetrics:
+    """Container for performance metrics with calculation methods."""
+
+    @staticmethod
+    def calculate_all(
+        returns: pd.Series, portfolio_values: pd.Series, trades: List[Any], config: Any
+    ) -> Dict[str, float]:
+        """
+        Calculate comprehensive performance metrics.
+
+        Args:
+            returns: Series of period returns (as percentages)
+            portfolio_values: Series of portfolio values over time
+            trades: List of Trade objects
+            config: BacktestConfig object
+
+        Returns:
+            Dictionary of all performance metrics
+        """
+        metrics = {}
+
+        try:
+            # Basic return metrics
+            metrics.update(
+                PerformanceMetrics.calculate_return_metrics(returns, portfolio_values)
+            )
+
+            # Risk metrics
+            metrics.update(
+                PerformanceMetrics.calculate_risk_metrics(returns, portfolio_values)
+            )
+
+            # Risk-adjusted metrics
+            metrics.update(PerformanceMetrics.calculate_risk_adjusted_metrics(returns))
+
+            # Drawdown metrics
+            metrics.update(
+                PerformanceMetrics.calculate_drawdown_metrics(portfolio_values)
+            )
+
+            # Trade-based metrics
+            metrics.update(PerformanceMetrics.calculate_trade_metrics(trades))
+
+            # Time-based metrics
+            metrics.update(
+                PerformanceMetrics.calculate_time_metrics(returns, portfolio_values)
+            )
+
+            # Risk management metrics
+            metrics.update(
+                PerformanceMetrics.calculate_risk_management_metrics(returns, config)
+            )
+
+        except Exception as e:
+            logger.error(f"Error calculating metrics: {e}")
+
+        return metrics
+
+    @staticmethod
+    def calculate_return_metrics(
+        returns: pd.Series, portfolio_values: pd.Series
+    ) -> Dict[str, float]:
+        """Calculate return-based metrics."""
+        if len(returns) == 0 or len(portfolio_values) == 0:
+            return {}
+
+        initial_value = portfolio_values.iloc[0]
+        final_value = portfolio_values.iloc[-1]
+
+        return {
+            "total_return": ((final_value / initial_value) - 1) * 100,
+            "total_return_abs": final_value - initial_value,
+            "annualized_return": PerformanceMetrics._annualized_return(returns),
+            "avg_daily_return": returns.mean(),
+            "median_daily_return": returns.median(),
+            "geometric_mean_return": PerformanceMetrics._geometric_mean(returns),
+            "compound_annual_growth_rate": PerformanceMetrics._cagr(portfolio_values),
+        }
+
+    @staticmethod
+    def calculate_risk_metrics(
+        returns: pd.Series, portfolio_values: pd.Series
+    ) -> Dict[str, float]:
+        """Calculate risk-based metrics."""
+        if len(returns) == 0:
+            return {}
+
+        return {
+            "volatility": returns.std(),
+            "annualized_volatility": returns.std()
+            * np.sqrt(252),  # Assuming daily returns
+            "downside_volatility": PerformanceMetrics._downside_deviation(returns),
+            "value_at_risk_5": returns.quantile(0.05),
+            "value_at_risk_1": returns.quantile(0.01),
+            "conditional_value_at_risk_5": returns[
+                returns <= returns.quantile(0.05)
+            ].mean(),
+            "skewness": returns.skew(),
+            "kurtosis": returns.kurtosis(),
+            "positive_periods": (returns > 0).sum(),
+            "negative_periods": (returns < 0).sum(),
+            "zero_periods": (returns == 0).sum(),
+        }
+
+    @staticmethod
+    def calculate_risk_adjusted_metrics(
+        returns: pd.Series, risk_free_rate: float = 0.02
+    ) -> Dict[str, float]:
+        """Calculate risk-adjusted return metrics."""
+        if len(returns) == 0:
+            return {}
+
+        # Convert annual risk-free rate to daily
+        daily_rf = (1 + risk_free_rate) ** (1 / 252) - 1
+        excess_returns = returns - daily_rf
+
+        metrics = {}
+
+        # Sharpe Ratio
+        if returns.std() != 0:
+            metrics["sharpe_ratio"] = (
+                excess_returns.mean() / returns.std() * np.sqrt(252)
+            )
+        else:
+            metrics["sharpe_ratio"] = 0
+
+        # Sortino Ratio
+        downside_dev = PerformanceMetrics._downside_deviation(returns)
+        if downside_dev != 0:
+            metrics["sortino_ratio"] = (
+                excess_returns.mean() / downside_dev * np.sqrt(252)
+            )
+        else:
+            metrics["sortino_ratio"] = 0
+
+        # Calmar Ratio (annual return / max drawdown)
+        annual_return = PerformanceMetrics._annualized_return(returns)
+        max_dd = PerformanceMetrics._max_drawdown_from_returns(returns)
+        if max_dd != 0:
+            metrics["calmar_ratio"] = annual_return / abs(max_dd)
+        else:
+            metrics["calmar_ratio"] = 0
+
+        return metrics
+
+    @staticmethod
+    def calculate_drawdown_metrics(portfolio_values: pd.Series) -> Dict[str, float]:
+        """Calculate drawdown-based metrics."""
+        if len(portfolio_values) == 0:
+            return {}
+
+        # Calculate drawdown series
+        rolling_max = portfolio_values.expanding().max()
+        drawdown = (portfolio_values - rolling_max) / rolling_max * 100
+
+        return {
+            "max_drawdown": drawdown.min(),
+            "avg_drawdown": (
+                drawdown[drawdown < 0].mean() if (drawdown < 0).any() else 0
+            ),
+            "drawdown_periods": (drawdown < 0).sum(),
+            "max_drawdown_duration": PerformanceMetrics._max_drawdown_duration(
+                drawdown
+            ),
+            "recovery_factor": (
+                (portfolio_values.iloc[-1] / portfolio_values.iloc[0] - 1)
+                / abs(drawdown.min())
+                if drawdown.min() != 0
+                else 0
+            ),
+            "current_drawdown": drawdown.iloc[-1],
+        }
+
+    @staticmethod
+    def calculate_trade_metrics(trades: List[Any]) -> Dict[str, float]:
+        """Calculate trade-based metrics."""
+        if not trades:
+            return {}
+
+        # Extract realized P&L from completed trades
+        realized_pnls = [
+            trade.pnl
+            for trade in trades
+            if hasattr(trade, "pnl") and trade.pnl is not None
+        ]
+
+        if not realized_pnls:
+            return {"total_trades": len(trades)}
+
+        realized_pnls = np.array(realized_pnls)
+        winning_trades = realized_pnls[realized_pnls > 0]
+        losing_trades = realized_pnls[realized_pnls < 0]
+
+        metrics = {
+            "total_trades": len(trades),
+            "completed_trades": len(realized_pnls),
+            "winning_trades": len(winning_trades),
+            "losing_trades": len(losing_trades),
+            "win_rate": (
+                len(winning_trades) / len(realized_pnls) * 100
+                if len(realized_pnls) > 0
+                else 0
+            ),
+            "avg_win": winning_trades.mean() if len(winning_trades) > 0 else 0,
+            "avg_loss": losing_trades.mean() if len(losing_trades) > 0 else 0,
+            "largest_win": winning_trades.max() if len(winning_trades) > 0 else 0,
+            "largest_loss": losing_trades.min() if len(losing_trades) > 0 else 0,
+            "total_realized_pnl": realized_pnls.sum(),
+        }
+
+        # Profit factor (gross profit / gross loss)
+        gross_profit = winning_trades.sum() if len(winning_trades) > 0 else 0
+        gross_loss = abs(losing_trades.sum()) if len(losing_trades) > 0 else 0
+        metrics["profit_factor"] = (
+            gross_profit / gross_loss
+            if gross_loss > 0
+            else float("inf") if gross_profit > 0 else 0
+        )
+
+        # Average win/loss ratio
+        if len(losing_trades) > 0 and metrics["avg_loss"] != 0:
+            metrics["avg_win_loss_ratio"] = abs(
+                metrics["avg_win"] / metrics["avg_loss"]
+            )
+        else:
+            metrics["avg_win_loss_ratio"] = 0
+
+        return metrics
+
+    @staticmethod
+    def calculate_time_metrics(
+        returns: pd.Series, portfolio_values: pd.Series
+    ) -> Dict[str, float]:
+        """Calculate time-based metrics."""
+        if len(returns) == 0:
+            return {}
+
+        return {
+            "total_periods": len(returns),
+            "start_date": returns.index[0] if len(returns) > 0 else None,
+            "end_date": returns.index[-1] if len(returns) > 0 else None,
+            "trading_days": len(returns),
+            "best_day": returns.max(),
+            "worst_day": returns.min(),
+            "consecutive_wins": PerformanceMetrics._max_consecutive_periods(
+                returns > 0
+            ),
+            "consecutive_losses": PerformanceMetrics._max_consecutive_periods(
+                returns < 0
+            ),
+        }
+
+    @staticmethod
+    def calculate_risk_management_metrics(
+        returns: pd.Series, config: Any
+    ) -> Dict[str, float]:
+        """Calculate risk management specific metrics."""
+        if len(returns) == 0:
+            return {}
+
+        metrics = {}
+
+        # Check against configured limits
+        if hasattr(config, "daily_loss_limit"):
+            daily_losses = returns[returns < 0]
+            worst_daily_loss = daily_losses.min() if len(daily_losses) > 0 else 0
+            metrics["worst_daily_loss_pct"] = worst_daily_loss
+            metrics["daily_loss_limit_breached"] = (
+                worst_daily_loss < -config.daily_loss_limit * 100
+            )
+
+        # Calculate tail risk metrics
+        if len(returns) > 0:
+            metrics["tail_ratio"] = (
+                abs(returns.quantile(0.95) / returns.quantile(0.05))
+                if returns.quantile(0.05) != 0
+                else 0
+            )
+
+        return metrics
+
+    # Helper methods
+    @staticmethod
+    def _annualized_return(returns: pd.Series, periods_per_year: int = 252) -> float:
+        """Calculate annualized return."""
+        if len(returns) == 0:
+            return 0
+        total_periods = len(returns)
+        compound_return = (1 + returns / 100).prod()
+        return (compound_return ** (periods_per_year / total_periods) - 1) * 100
+
+    @staticmethod
+    def _geometric_mean(returns: pd.Series) -> float:
+        """Calculate geometric mean return."""
+        if len(returns) == 0:
+            return 0
+        return ((1 + returns / 100).prod() ** (1 / len(returns)) - 1) * 100
+
+    @staticmethod
+    def _cagr(portfolio_values: pd.Series) -> float:
+        """Calculate Compound Annual Growth Rate."""
+        if len(portfolio_values) < 2:
+            return 0
+
+        initial_value = portfolio_values.iloc[0]
+        final_value = portfolio_values.iloc[-1]
+
+        # Calculate number of years
+        time_diff = portfolio_values.index[-1] - portfolio_values.index[0]
+        years = time_diff.days / 365.25
+
+        if years == 0 or initial_value == 0:
+            return 0
+
+        return ((final_value / initial_value) ** (1 / years) - 1) * 100
+
+    @staticmethod
+    def _downside_deviation(returns: pd.Series, target_return: float = 0) -> float:
+        """Calculate downside deviation."""
+        downside_returns = returns[returns < target_return]
+        if len(downside_returns) == 0:
+            return 0
+        return ((downside_returns - target_return) ** 2).mean() ** 0.5
+
+    @staticmethod
+    def _max_drawdown_from_returns(returns: pd.Series) -> float:
+        """Calculate max drawdown from returns series."""
+        cumulative = (1 + returns / 100).cumprod()
+        running_max = cumulative.expanding().max()
+        drawdown = (cumulative - running_max) / running_max * 100
+        return drawdown.min()
+
+    @staticmethod
+    def _max_drawdown_duration(drawdown: pd.Series) -> int:
+        """Calculate maximum drawdown duration in periods."""
+        if len(drawdown) == 0:
+            return 0
+
+        # Find periods where we're in drawdown
+        in_drawdown = drawdown < 0
+
+        if not in_drawdown.any():
+            return 0
+
+        # Find consecutive drawdown periods
+        groups = (in_drawdown != in_drawdown.shift()).cumsum()
+        drawdown_periods = in_drawdown.groupby(groups).sum()
+
+        return int(drawdown_periods.max()) if len(drawdown_periods) > 0 else 0
+
+    @staticmethod
+    def _max_consecutive_periods(condition: pd.Series) -> int:
+        """Calculate maximum consecutive periods meeting condition."""
+        if len(condition) == 0:
+            return 0
+
+        groups = (condition != condition.shift()).cumsum()
+        consecutive_counts = condition.groupby(groups).sum()
+        return int(consecutive_counts.max()) if len(consecutive_counts) > 0 else 0
+
+    @staticmethod
+    def format_metrics(metrics: Dict[str, Any], precision: int = 4) -> Dict[str, str]:
+        """
+        Format metrics for display with appropriate precision.
+
+        Args:
+            metrics: Raw metrics dictionary
+            precision: Decimal places for rounding
+
+        Returns:
+            Formatted metrics dictionary
+        """
+        formatted = {}
+
+        for key, value in metrics.items():
+            if isinstance(value, (int, float)):
+                if "ratio" in key.lower() or "factor" in key.lower():
+                    formatted[key] = f"{value:.{precision}f}"
+                elif (
+                    "rate" in key.lower()
+                    or "return" in key.lower()
+                    or "pct" in key.lower()
+                ):
+                    formatted[key] = f"{value:.2f}%"
+                elif "pnl" in key.lower() or "value" in key.lower():
+                    formatted[key] = f"${value:,.2f}"
+                elif "periods" in key.lower() or "trades" in key.lower():
+                    formatted[key] = f"{int(value):,}"
+                else:
+                    formatted[key] = f"{value:.{precision}f}"
+            elif isinstance(value, datetime):
+                formatted[key] = value.strftime("%Y-%m-%d")
+            else:
+                formatted[key] = str(value)
+
+        return formatted
+
+    @staticmethod
+    def create_summary_report(metrics: Dict[str, Any]) -> str:
+        """Create a formatted summary report."""
+        formatted = PerformanceMetrics.format_metrics(metrics)
+
+        report = """
+PERFORMANCE SUMMARY
+===================
+
+Return Metrics:
+- Total Return: {total_return}
+- Annualized Return: {annualized_return}
+- CAGR: {compound_annual_growth_rate}
+
+Risk Metrics:
+- Volatility (Ann.): {annualized_volatility}
+- Max Drawdown: {max_drawdown}
+- VaR (5%): {value_at_risk_5}
+
+Risk-Adjusted:
+- Sharpe Ratio: {sharpe_ratio}
+- Sortino Ratio: {sortino_ratio}
+- Calmar Ratio: {calmar_ratio}
+
+Trade Analysis:
+- Total Trades: {total_trades}
+- Win Rate: {win_rate}
+- Profit Factor: {profit_factor}
+- Avg Win/Loss: {avg_win_loss_ratio}
+        """.format(
+            **{
+                k: formatted.get(k, "N/A")
+                for k in [
+                    "total_return",
+                    "annualized_return",
+                    "compound_annual_growth_rate",
+                    "annualized_volatility",
+                    "max_drawdown",
+                    "value_at_risk_5",
+                    "sharpe_ratio",
+                    "sortino_ratio",
+                    "calmar_ratio",
+                    "total_trades",
+                    "win_rate",
+                    "profit_factor",
+                    "avg_win_loss_ratio",
+                ]
+            }
+        )
+
+        return report.strip()
diff --git a/neural_sdk/backtesting/portfolio.py b/neural_sdk/backtesting/portfolio.py
new file mode 100644
index 00000000..8f0decba
--- /dev/null
+++ b/neural_sdk/backtesting/portfolio.py
@@ -0,0 +1,494 @@
+"""
+Portfolio Management for Backtesting
+
+Realistic portfolio simulation with:
+- Position tracking
+- Cash management
+- Trade execution
+- P&L calculation
+- Risk metrics
+"""
+
+import logging
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Position:
+    """Represents a position in a specific market."""
+
+    symbol: str
+    quantity: int
+    avg_cost: float
+    current_price: float = 0.0
+    timestamp: datetime = field(default_factory=datetime.now)
+
+    @property
+    def market_value(self) -> float:
+        """Current market value of position."""
+        return self.quantity * self.current_price
+
+    @property
+    def cost_basis(self) -> float:
+        """Total cost basis of position."""
+        return self.quantity * self.avg_cost
+
+    @property
+    def unrealized_pnl(self) -> float:
+        """Unrealized profit/loss."""
+        return self.market_value - self.cost_basis
+
+    @property
+    def unrealized_pnl_pct(self) -> float:
+        """Unrealized P&L as percentage."""
+        if self.cost_basis == 0:
+            return 0.0
+        return (self.unrealized_pnl / self.cost_basis) * 100
+
+    def update_price(self, new_price: float):
+        """Update current market price."""
+        self.current_price = new_price
+
+
+@dataclass
+class Trade:
+    """Represents a completed trade."""
+
+    timestamp: datetime
+    symbol: str
+    action: str  # BUY, SELL
+    quantity: int
+    price: float
+    commission: float = 0.0
+    value: float = field(init=False)
+    pnl: Optional[float] = None  # Realized P&L for closing trades
+
+    def __post_init__(self):
+        """Calculate trade value."""
+        self.value = self.quantity * self.price
+
+    @property
+    def net_value(self) -> float:
+        """Trade value after commission."""
+        return self.value - self.commission
+
+
+class Portfolio:
+    """
+    Portfolio manager for backtesting.
+
+    Tracks cash, positions, trades, and performance metrics.
+    Implements realistic order execution with commissions and slippage.
+    """
+
+    def __init__(self, initial_capital: float):
+        """
+        Initialize portfolio.
+
+        Args:
+            initial_capital: Starting cash amount
+        """
+        self.initial_capital = initial_capital
+        self.cash = initial_capital
+        self.positions: Dict[str, Position] = {}
+        self.trade_history: List[Trade] = []
+
+        # Performance tracking
+        self._daily_values = []
+        self._high_water_mark = initial_capital
+
+        logger.info(f"Initialized portfolio with ${initial_capital:,.2f}")
+
+    @property
+    def market_value(self) -> float:
+        """Total market value of all positions."""
+        return sum(pos.market_value for pos in self.positions.values())
+
+    @property
+    def total_value(self, market_data: Optional[Dict[str, Any]] = None) -> float:
+        """Total portfolio value (cash + positions)."""
+        if market_data and "prices" in market_data:
+            # Update position prices from market data
+            for symbol, price in market_data["prices"].items():
+                if symbol in self.positions:
+                    self.positions[symbol].update_price(price)
+
+        return self.cash + self.market_value
+
+    @property
+    def unrealized_pnl(self) -> float:
+        """Total unrealized profit/loss."""
+        return sum(pos.unrealized_pnl for pos in self.positions.values())
+
+    @property
+    def realized_pnl(self) -> float:
+        """Total realized profit/loss from closed trades."""
+        return sum(
+            trade.pnl or 0 for trade in self.trade_history if trade.pnl is not None
+        )
+
+    @property
+    def total_pnl(self) -> float:
+        """Total P&L (realized + unrealized)."""
+        return self.realized_pnl + self.unrealized_pnl
+
+    @property
+    def total_return_pct(self) -> float:
+        """Total return as percentage of initial capital."""
+        return (self.total_pnl / self.initial_capital) * 100
+
+    @property
+    def buying_power(self) -> float:
+        """Available cash for new positions."""
+        return self.cash
+
+    def buy(
+        self,
+        symbol: str,
+        quantity: int,
+        price: float,
+        timestamp: datetime,
+        commission: float = 0.0,
+    ) -> bool:
+        """
+        Execute buy order.
+
+        Args:
+            symbol: Market symbol
+            quantity: Number of contracts
+            price: Execution price
+            timestamp: Trade timestamp
+            commission: Commission fee
+
+        Returns:
+            True if trade executed successfully
+        """
+        total_cost = quantity * price + commission
+
+        # Check if sufficient cash
+        if total_cost > self.cash:
+            logger.warning(
+                f"Insufficient cash for {symbol}: need ${total_cost:,.2f}, have ${self.cash:,.2f}"
+            )
+            return False
+
+        # Update cash
+        self.cash -= total_cost
+
+        # Update or create position
+        if symbol in self.positions:
+            pos = self.positions[symbol]
+            # Calculate new average cost
+            total_quantity = pos.quantity + quantity
+            total_cost_basis = pos.cost_basis + (quantity * price)
+            new_avg_cost = total_cost_basis / total_quantity
+
+            pos.quantity = total_quantity
+            pos.avg_cost = new_avg_cost
+            pos.current_price = price
+            pos.timestamp = timestamp
+        else:
+            self.positions[symbol] = Position(
+                symbol=symbol,
+                quantity=quantity,
+                avg_cost=price,
+                current_price=price,
+                timestamp=timestamp,
+            )
+
+        # Record trade
+        trade = Trade(
+            timestamp=timestamp,
+            symbol=symbol,
+            action="BUY",
+            quantity=quantity,
+            price=price,
+            commission=commission,
+        )
+        self.trade_history.append(trade)
+
+        logger.debug(
+            f"BUY: {quantity} {symbol} @ ${price:.2f} (commission: ${commission:.2f})"
+        )
+        return True
+
+    def sell(
+        self,
+        symbol: str,
+        quantity: int,
+        price: float,
+        timestamp: datetime,
+        commission: float = 0.0,
+    ) -> bool:
+        """
+        Execute sell order.
+
+        Args:
+            symbol: Market symbol
+            quantity: Number of contracts to sell
+            price: Execution price
+            timestamp: Trade timestamp
+            commission: Commission fee
+
+        Returns:
+            True if trade executed successfully
+        """
+        # Check if position exists and has sufficient quantity
+        if symbol not in self.positions:
+            logger.warning(f"Cannot sell {symbol}: no position")
+            return False
+
+        pos = self.positions[symbol]
+        if pos.quantity < quantity:
+            logger.warning(f"Cannot sell {quantity} {symbol}: only have {pos.quantity}")
+            return False
+
+        # Calculate proceeds and P&L
+        gross_proceeds = quantity * price
+        net_proceeds = gross_proceeds - commission
+        cost_basis = quantity * pos.avg_cost
+        realized_pnl = net_proceeds - cost_basis
+
+        # Update cash
+        self.cash += net_proceeds
+
+        # Update position
+        pos.quantity -= quantity
+
+        # Remove position if fully closed
+        if pos.quantity == 0:
+            del self.positions[symbol]
+        else:
+            pos.current_price = price
+            pos.timestamp = timestamp
+
+        # Record trade with realized P&L
+        trade = Trade(
+            timestamp=timestamp,
+            symbol=symbol,
+            action="SELL",
+            quantity=quantity,
+            price=price,
+            commission=commission,
+            pnl=realized_pnl,
+        )
+        self.trade_history.append(trade)
+
+        logger.debug(
+            f"SELL: {quantity} {symbol} @ ${price:.2f} (P&L: ${realized_pnl:+.2f})"
+        )
+        return True
+
+    def close_position(
+        self, symbol: str, price: float, timestamp: datetime, commission: float = 0.0
+    ) -> bool:
+        """
+        Close entire position in symbol.
+
+        Args:
+            symbol: Market symbol
+            price: Execution price
+            timestamp: Trade timestamp
+            commission: Commission fee
+
+        Returns:
+            True if position closed successfully
+        """
+        if symbol not in self.positions:
+            logger.warning(f"No position to close in {symbol}")
+            return False
+
+        quantity = self.positions[symbol].quantity
+        return self.sell(symbol, quantity, price, timestamp, commission)
+
+    def close_all_positions(
+        self,
+        market_data: Dict[str, Any],
+        timestamp: datetime,
+        commission_rate: float = 0.02,
+    ):
+        """
+        Close all open positions at market prices.
+
+        Args:
+            market_data: Current market prices
+            timestamp: Trade timestamp
+            commission_rate: Commission rate (default 2%)
+        """
+        positions_to_close = list(self.positions.keys())
+
+        for symbol in positions_to_close:
+            if symbol in market_data.get("prices", {}):
+                price = market_data["prices"][symbol]
+                quantity = self.positions[symbol].quantity
+                commission = quantity * price * commission_rate
+
+                self.close_position(symbol, price, timestamp, commission)
+
+        logger.info(f"Closed {len(positions_to_close)} positions")
+
+    def get_position(self, symbol: str) -> Optional[Position]:
+        """Get position for symbol."""
+        return self.positions.get(symbol)
+
+    def get_position_size(self, symbol: str) -> int:
+        """Get position size for symbol."""
+        pos = self.positions.get(symbol)
+        return pos.quantity if pos else 0
+
+    def is_long(self, symbol: str) -> bool:
+        """Check if long position exists."""
+        pos = self.positions.get(symbol)
+        return pos is not None and pos.quantity > 0
+
+    def positions_df(self) -> pd.DataFrame:
+        """Get positions as DataFrame."""
+        if not self.positions:
+            return pd.DataFrame()
+
+        positions_data = []
+        for pos in self.positions.values():
+            positions_data.append(
+                {
+                    "symbol": pos.symbol,
+                    "quantity": pos.quantity,
+                    "avg_cost": pos.avg_cost,
+                    "current_price": pos.current_price,
+                    "market_value": pos.market_value,
+                    "cost_basis": pos.cost_basis,
+                    "unrealized_pnl": pos.unrealized_pnl,
+                    "unrealized_pnl_pct": pos.unrealized_pnl_pct,
+                    "timestamp": pos.timestamp,
+                }
+            )
+
+        return pd.DataFrame(positions_data)
+
+    def trades_df(self) -> pd.DataFrame:
+        """Get trade history as DataFrame."""
+        if not self.trade_history:
+            return pd.DataFrame()
+
+        trades_data = []
+        for trade in self.trade_history:
+            trades_data.append(
+                {
+                    "timestamp": trade.timestamp,
+                    "symbol": trade.symbol,
+                    "action": trade.action,
+                    "quantity": trade.quantity,
+                    "price": trade.price,
+                    "value": trade.value,
+                    "commission": trade.commission,
+                    "net_value": trade.net_value,
+                    "realized_pnl": trade.pnl,
+                }
+            )
+
+        return pd.DataFrame(trades_data)
+
+    def get_performance_summary(self) -> Dict[str, Any]:
+        """Get comprehensive performance summary."""
+        return {
+            "initial_capital": self.initial_capital,
+            "current_cash": self.cash,
+            "market_value": self.market_value,
+            "total_value": self.total_value(),
+            "total_return": self.total_value() - self.initial_capital,
+            "total_return_pct": self.total_return_pct,
+            "realized_pnl": self.realized_pnl,
+            "unrealized_pnl": self.unrealized_pnl,
+            "total_pnl": self.total_pnl,
+            "num_positions": len(self.positions),
+            "num_trades": len(self.trade_history),
+            "positions": (
+                self.positions_df().to_dict("records") if self.positions else []
+            ),
+        }
+
+    def calculate_drawdown(self, portfolio_values: pd.Series) -> pd.Series:
+        """
+        Calculate drawdown series.
+
+        Args:
+            portfolio_values: Series of portfolio values over time
+
+        Returns:
+            Series of drawdown values (negative percentages)
+        """
+        rolling_max = portfolio_values.expanding().max()
+        drawdown = (portfolio_values - rolling_max) / rolling_max
+        return drawdown
+
+    def calculate_max_drawdown(self, portfolio_values: pd.Series) -> float:
+        """Calculate maximum drawdown percentage."""
+        drawdown = self.calculate_drawdown(portfolio_values)
+        return drawdown.min() * 100  # Convert to percentage
+
+    def get_trade_statistics(self) -> Dict[str, Any]:
+        """Get detailed trade statistics."""
+        if not self.trade_history:
+            return {}
+
+        trades_df = self.trades_df()
+
+        # Separate buy and sell trades
+        buys = trades_df[trades_df["action"] == "BUY"]
+        sells = trades_df[trades_df["action"] == "SELL"]
+
+        # Realized P&L from sell trades
+        realized_trades = sells[sells["realized_pnl"].notna()]
+
+        if len(realized_trades) == 0:
+            win_rate = 0
+            avg_win = 0
+            avg_loss = 0
+            largest_win = 0
+            largest_loss = 0
+        else:
+            winning_trades = realized_trades[realized_trades["realized_pnl"] > 0]
+            losing_trades = realized_trades[realized_trades["realized_pnl"] < 0]
+
+            win_rate = len(winning_trades) / len(realized_trades) * 100
+            avg_win = (
+                winning_trades["realized_pnl"].mean() if len(winning_trades) > 0 else 0
+            )
+            avg_loss = (
+                losing_trades["realized_pnl"].mean() if len(losing_trades) > 0 else 0
+            )
+            largest_win = (
+                winning_trades["realized_pnl"].max() if len(winning_trades) > 0 else 0
+            )
+            largest_loss = (
+                losing_trades["realized_pnl"].min() if len(losing_trades) > 0 else 0
+            )
+
+        return {
+            "total_trades": len(self.trade_history),
+            "buy_trades": len(buys),
+            "sell_trades": len(sells),
+            "realized_trades": len(realized_trades),
+            "win_rate": win_rate,
+            "winning_trades": (
+                len(realized_trades[realized_trades["realized_pnl"] > 0])
+                if len(realized_trades) > 0
+                else 0
+            ),
+            "losing_trades": (
+                len(realized_trades[realized_trades["realized_pnl"] < 0])
+                if len(realized_trades) > 0
+                else 0
+            ),
+            "avg_win": avg_win,
+            "avg_loss": avg_loss,
+            "largest_win": largest_win,
+            "largest_loss": largest_loss,
+            "total_commissions": trades_df["commission"].sum(),
+        }
diff --git a/neural_sdk/backtesting/providers/__init__.py b/neural_sdk/backtesting/providers/__init__.py
new file mode 100644
index 00000000..d3385ecb
--- /dev/null
+++ b/neural_sdk/backtesting/providers/__init__.py
@@ -0,0 +1,43 @@
+"""
+Data Providers for Backtesting Module
+
+Support for loading historical data from various sources:
+- CSV files
+- Parquet files
+- S3 buckets
+- PostgreSQL databases
+- Remote APIs
+
+Example:
+    ```python
+    from neural_sdk.backtesting.providers import CSVProvider, S3Provider
+
+    # Load from CSV
+    csv_provider = CSVProvider()
+    data = csv_provider.fetch("data/trades.csv")
+
+    # Load from S3
+    s3_provider = S3Provider(bucket="my-data")
+    data = s3_provider.fetch("trades/2024/", start="2024-01-01", end="2024-12-31")
+    ```
+"""
+
+from .base import DataProvider
+from .csv_provider import CSVProvider
+from .parquet_provider import ParquetProvider
+
+try:
+    from .s3_provider import S3Provider
+
+    __all__ = ["DataProvider", "CSVProvider", "ParquetProvider", "S3Provider"]
+except ImportError:
+    # S3 provider requires boto3
+    __all__ = ["DataProvider", "CSVProvider", "ParquetProvider"]
+
+try:
+    from .database_provider import DatabaseProvider
+
+    __all__.append("DatabaseProvider")
+except ImportError:
+    # Database provider requires sqlalchemy
+    pass
diff --git a/neural_sdk/backtesting/providers/base.py b/neural_sdk/backtesting/providers/base.py
new file mode 100644
index 00000000..6bf8fcf8
--- /dev/null
+++ b/neural_sdk/backtesting/providers/base.py
@@ -0,0 +1,273 @@
+"""
+Base Data Provider Interface
+
+Abstract base class for all data providers in the backtesting module.
+Ensures consistent interface across different data sources.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+class DataProvider(ABC):
+    """
+    Abstract base class for historical data providers.
+
+    All data providers must implement the fetch() method and should
+    implement validate() for data quality assurance.
+    """
+
+    def __init__(self, **kwargs):
+        """Initialize provider with configuration."""
+        self.config = kwargs
+
+    @abstractmethod
+    def fetch(
+        self,
+        source: str,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Fetch historical data from the provider.
+
+        Args:
+            source: Source identifier (file path, table name, etc.)
+            symbols: List of symbols to fetch (None for all)
+            start: Start date (YYYY-MM-DD format)
+            end: End date (YYYY-MM-DD format)
+            **kwargs: Provider-specific parameters
+
+        Returns:
+            DataFrame with standardized columns:
+            - timestamp: datetime
+            - symbol: str
+            - price: float
+            - volume: int (optional)
+            - additional market data columns
+
+        Raises:
+            ValueError: If parameters are invalid
+            ConnectionError: If unable to connect to data source
+            DataError: If data format is invalid
+        """
+        pass
+
+    def validate(self, data: pd.DataFrame) -> bool:
+        """
+        Validate data integrity and format.
+
+        Args:
+            data: DataFrame to validate
+
+        Returns:
+            True if data is valid, raises exception otherwise
+
+        Raises:
+            ValueError: If data format is invalid
+        """
+        required_columns = ["timestamp", "symbol", "price"]
+        missing_columns = [col for col in required_columns if col not in data.columns]
+
+        if missing_columns:
+            raise ValueError(f"Data missing required columns: {missing_columns}")
+
+        # Check for null values in critical columns
+        for col in required_columns:
+            if data[col].isnull().any():
+                null_count = data[col].isnull().sum()
+                raise ValueError(f"Column '{col}' has {null_count} null values")
+
+        # Validate timestamp format
+        if not pd.api.types.is_datetime64_any_dtype(data["timestamp"]):
+            try:
+                data["timestamp"] = pd.to_datetime(data["timestamp"])
+            except Exception as e:
+                raise ValueError(f"Cannot parse timestamp column: {e}")
+
+        # Validate price data
+        if not pd.api.types.is_numeric_dtype(data["price"]):
+            raise ValueError("Price column must be numeric")
+
+        if (data["price"] <= 0).any():
+            raise ValueError("Price column contains non-positive values")
+
+        # Check for reasonable data ranges (prediction market prices are 0-1)
+        if (data["price"] > 1.0).any():
+            logger.warning(
+                "Price values > 1.0 detected. Are these prediction market prices?"
+            )
+
+        logger.info(f"Data validation passed: {len(data)} records")
+        return True
+
+    def clean_data(self, data: pd.DataFrame) -> pd.DataFrame:
+        """
+        Clean and standardize data format.
+
+        Args:
+            data: Raw data DataFrame
+
+        Returns:
+            Cleaned DataFrame
+        """
+        # Make a copy to avoid modifying original
+        cleaned = data.copy()
+
+        # Ensure timestamp is datetime
+        if not pd.api.types.is_datetime64_any_dtype(cleaned["timestamp"]):
+            cleaned["timestamp"] = pd.to_datetime(cleaned["timestamp"])
+
+        # Sort by timestamp
+        cleaned = cleaned.sort_values("timestamp")
+
+        # Remove duplicates
+        initial_len = len(cleaned)
+        cleaned = cleaned.drop_duplicates(subset=["timestamp", "symbol"])
+        if len(cleaned) < initial_len:
+            logger.info(f"Removed {initial_len - len(cleaned)} duplicate records")
+
+        # Fill forward any missing prices (conservative approach)
+        if "price" in cleaned.columns:
+            cleaned["price"] = cleaned.groupby("symbol")["price"].fillna(method="ffill")
+
+        # Add volume column if missing
+        if "volume" not in cleaned.columns:
+            cleaned["volume"] = 0
+
+        return cleaned
+
+    def filter_data(
+        self,
+        data: pd.DataFrame,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+    ) -> pd.DataFrame:
+        """
+        Filter data by symbols and date range.
+
+        Args:
+            data: DataFrame to filter
+            symbols: List of symbols to include
+            start: Start date string
+            end: End date string
+
+        Returns:
+            Filtered DataFrame
+        """
+        filtered = data.copy()
+
+        # Filter by symbols
+        if symbols:
+            filtered = filtered[filtered["symbol"].isin(symbols)]
+
+        # Filter by date range
+        if start:
+            start_date = pd.to_datetime(start)
+            filtered = filtered[filtered["timestamp"] >= start_date]
+
+        if end:
+            end_date = pd.to_datetime(end)
+            filtered = filtered[filtered["timestamp"] <= end_date]
+
+        logger.info(f"Filtered data: {len(filtered)} records")
+        return filtered
+
+    def aggregate_data(
+        self, data: pd.DataFrame, frequency: str = "1min"
+    ) -> pd.DataFrame:
+        """
+        Aggregate data to specified frequency.
+
+        Args:
+            data: Data to aggregate
+            frequency: Pandas frequency string (1min, 5min, 1h, 1d)
+
+        Returns:
+            Aggregated DataFrame
+        """
+        if frequency == "raw":
+            return data
+
+        # Group by symbol and timestamp
+        grouped = (
+            data.groupby("symbol")
+            .resample(frequency, on="timestamp")
+            .agg(
+                {
+                    "price": "last",  # Use last price in period
+                    "volume": "sum",  # Sum volume
+                }
+            )
+            .reset_index()
+        )
+
+        # Remove any null prices (no data in period)
+        grouped = grouped.dropna(subset=["price"])
+
+        logger.info(f"Aggregated to {frequency}: {len(grouped)} records")
+        return grouped
+
+    def get_available_symbols(self, source: str) -> List[str]:
+        """
+        Get list of available symbols from data source.
+
+        Args:
+            source: Data source identifier
+
+        Returns:
+            List of symbol strings
+        """
+        # Default implementation - override in subclasses
+        try:
+            sample_data = self.fetch(source, start="2024-01-01", end="2024-01-02")
+            return sorted(sample_data["symbol"].unique().tolist())
+        except Exception as e:
+            logger.error(f"Cannot get symbols from {source}: {e}")
+            return []
+
+    def get_date_range(self, source: str, symbol: Optional[str] = None) -> tuple:
+        """
+        Get available date range for data source.
+
+        Args:
+            source: Data source identifier
+            symbol: Specific symbol (None for all)
+
+        Returns:
+            Tuple of (start_date, end_date) as datetime objects
+        """
+        try:
+            # Load small sample to get date range
+            sample_data = self.fetch(source, symbols=[symbol] if symbol else None)
+            if len(sample_data) == 0:
+                return None, None
+
+            start_date = sample_data["timestamp"].min()
+            end_date = sample_data["timestamp"].max()
+            return start_date, end_date
+
+        except Exception as e:
+            logger.error(f"Cannot get date range from {source}: {e}")
+            return None, None
+
+
+class DataError(Exception):
+    """Exception raised for data-related errors."""
+
+    pass
+
+
+class ConnectionError(Exception):
+    """Exception raised for connection-related errors."""
+
+    pass
diff --git a/neural_sdk/backtesting/providers/csv_provider.py b/neural_sdk/backtesting/providers/csv_provider.py
new file mode 100644
index 00000000..3323c4ed
--- /dev/null
+++ b/neural_sdk/backtesting/providers/csv_provider.py
@@ -0,0 +1,302 @@
+"""
+CSV Data Provider for Backtesting
+
+Loads historical trading data from CSV files.
+Supports standard CSV format with configurable column mapping.
+"""
+
+import glob
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from .base import DataError, DataProvider
+
+logger = logging.getLogger(__name__)
+
+
+class CSVProvider(DataProvider):
+    """
+    CSV file data provider for backtesting.
+
+    Expects CSV files with columns:
+    - timestamp (or datetime, date)
+    - symbol (or ticker, market)
+    - price (or close, last)
+    - volume (optional)
+
+    Example:
+        ```python
+        provider = CSVProvider(
+            column_mapping={
+                'datetime': 'timestamp',
+                'ticker': 'symbol',
+                'close': 'price'
+            }
+        )
+        data = provider.fetch('trades.csv')
+        ```
+    """
+
+    def __init__(self, column_mapping: Optional[Dict[str, str]] = None, **kwargs):
+        """
+        Initialize CSV provider.
+
+        Args:
+            column_mapping: Map CSV columns to standard names
+                          e.g., {'datetime': 'timestamp', 'close': 'price'}
+            **kwargs: Additional configuration
+        """
+        super().__init__(**kwargs)
+
+        # Default column mapping
+        self.column_mapping = {
+            "datetime": "timestamp",
+            "date": "timestamp",
+            "time": "timestamp",
+            "ticker": "symbol",
+            "market": "symbol",
+            "instrument": "symbol",
+            "close": "price",
+            "last": "price",
+            "trade_price": "price",
+            "vol": "volume",
+            "qty": "volume",
+            "size": "volume",
+        }
+
+        # Override with user mapping
+        if column_mapping:
+            self.column_mapping.update(column_mapping)
+
+        # CSV reading options
+        self.csv_options = {
+            "parse_dates": True,
+            "infer_datetime_format": True,
+            **kwargs.get("csv_options", {}),
+        }
+
+    def fetch(
+        self,
+        source: str,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Load data from CSV file(s).
+
+        Args:
+            source: CSV file path or glob pattern
+            symbols: Filter by symbols (applied after loading)
+            start: Start date filter
+            end: End date filter
+            **kwargs: Additional CSV reading options
+
+        Returns:
+            DataFrame with standardized columns
+        """
+        try:
+            # Handle glob patterns for multiple files
+            if "*" in source or "?" in source:
+                files = glob.glob(source)
+                if not files:
+                    raise FileNotFoundError(
+                        f"No files found matching pattern: {source}"
+                    )
+                logger.info(f"Loading {len(files)} CSV files")
+
+                # Load and combine all files
+                dataframes = []
+                for file_path in files:
+                    df = self._load_single_file(file_path, **kwargs)
+                    dataframes.append(df)
+
+                data = pd.concat(dataframes, ignore_index=True)
+
+            else:
+                # Single file
+                data = self._load_single_file(source, **kwargs)
+
+            # Standardize columns
+            data = self._standardize_columns(data)
+
+            # Clean and validate
+            data = self.clean_data(data)
+            self.validate(data)
+
+            # Apply filters
+            data = self.filter_data(data, symbols, start, end)
+
+            logger.info(f"Loaded {len(data)} records from CSV: {source}")
+            return data
+
+        except Exception as e:
+            logger.error(f"Error loading CSV {source}: {e}")
+            raise DataError(f"Failed to load CSV data: {e}")
+
+    def _load_single_file(self, file_path: str, **kwargs) -> pd.DataFrame:
+        """Load single CSV file."""
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"CSV file not found: {file_path}")
+
+        # Merge CSV options
+        options = {**self.csv_options, **kwargs}
+
+        # Try to detect delimiter
+        if "sep" not in options:
+            with open(file_path, "r") as f:
+                first_line = f.readline()
+                if "\t" in first_line:
+                    options["sep"] = "\t"
+                elif ";" in first_line:
+                    options["sep"] = ";"
+                else:
+                    options["sep"] = ","
+
+        data = pd.read_csv(file_path, **options)
+
+        # Add filename as symbol if no symbol column
+        if (
+            "symbol" not in data.columns
+            and len(self._find_symbol_column(data.columns)) == 0
+        ):
+            # Use filename as symbol
+            symbol = path.stem
+            data["symbol"] = symbol
+            logger.info(f"Using filename as symbol: {symbol}")
+
+        return data
+
+    def _standardize_columns(self, data: pd.DataFrame) -> pd.DataFrame:
+        """Map CSV columns to standard names."""
+        # Create column mapping
+        renamed_columns = {}
+
+        for original_col in data.columns:
+            # Check exact matches first
+            if original_col.lower() in self.column_mapping:
+                renamed_columns[original_col] = self.column_mapping[
+                    original_col.lower()
+                ]
+            # Check partial matches
+            else:
+                for pattern, standard in self.column_mapping.items():
+                    if pattern.lower() in original_col.lower():
+                        renamed_columns[original_col] = standard
+                        break
+
+        # Apply renaming
+        if renamed_columns:
+            data = data.rename(columns=renamed_columns)
+            logger.debug(f"Renamed columns: {renamed_columns}")
+
+        return data
+
+    def _find_symbol_column(self, columns: List[str]) -> List[str]:
+        """Find potential symbol columns."""
+        symbol_patterns = ["symbol", "ticker", "market", "instrument", "contract"]
+        matches = []
+
+        for col in columns:
+            for pattern in symbol_patterns:
+                if pattern.lower() in col.lower():
+                    matches.append(col)
+                    break
+
+        return matches
+
+    def get_available_symbols(self, source: str) -> List[str]:
+        """Get unique symbols from CSV file."""
+        try:
+            # Load just a sample to get symbols quickly
+            sample_options = {**self.csv_options, "nrows": 10000}
+            data = self._load_single_file(source, **sample_options)
+            data = self._standardize_columns(data)
+
+            if "symbol" in data.columns:
+                return sorted(data["symbol"].unique().tolist())
+            else:
+                # Use filename as symbol
+                return [Path(source).stem]
+
+        except Exception as e:
+            logger.error(f"Error getting symbols from {source}: {e}")
+            return []
+
+    def export_template(self, file_path: str):
+        """
+        Export a CSV template file with proper column headers.
+
+        Args:
+            file_path: Path where to save template
+        """
+        template_data = pd.DataFrame(
+            {
+                "timestamp": ["2024-01-01 09:30:00", "2024-01-01 09:31:00"],
+                "symbol": ["NFL-KC-BUF-WINNER", "NFL-KC-BUF-TOTAL"],
+                "price": [0.65, 0.52],
+                "volume": [1000, 500],
+            }
+        )
+
+        template_data.to_csv(file_path, index=False)
+        logger.info(f"CSV template saved to: {file_path}")
+
+    def validate_csv_format(self, file_path: str) -> Dict[str, Any]:
+        """
+        Validate CSV file format without loading all data.
+
+        Args:
+            file_path: Path to CSV file
+
+        Returns:
+            Dict with validation results
+        """
+        results = {
+            "valid": False,
+            "errors": [],
+            "warnings": [],
+            "columns": [],
+            "row_count": 0,
+            "date_range": None,
+        }
+
+        try:
+            # Read just header and a few rows
+            sample = pd.read_csv(file_path, nrows=100)
+            results["columns"] = sample.columns.tolist()
+            results["row_count"] = len(sample)
+
+            # Check for required columns after mapping
+            standardized = self._standardize_columns(sample)
+
+            required_columns = ["timestamp", "symbol", "price"]
+            missing = [
+                col for col in required_columns if col not in standardized.columns
+            ]
+
+            if missing:
+                results["errors"].append(f"Missing required columns: {missing}")
+            else:
+                results["valid"] = True
+
+                # Check date range
+                if "timestamp" in standardized.columns:
+                    try:
+                        timestamps = pd.to_datetime(standardized["timestamp"])
+                        results["date_range"] = (
+                            timestamps.min().strftime("%Y-%m-%d"),
+                            timestamps.max().strftime("%Y-%m-%d"),
+                        )
+                    except:
+                        results["warnings"].append("Cannot parse timestamp column")
+
+        except Exception as e:
+            results["errors"].append(f"Cannot read CSV file: {e}")
+
+        return results
diff --git a/neural_sdk/backtesting/providers/database_provider.py b/neural_sdk/backtesting/providers/database_provider.py
new file mode 100644
index 00000000..cfaa77ca
--- /dev/null
+++ b/neural_sdk/backtesting/providers/database_provider.py
@@ -0,0 +1,352 @@
+"""
+Database Data Provider for Backtesting
+
+Loads historical trading data from SQL databases.
+Supports PostgreSQL, MySQL, SQLite, and other SQLAlchemy-compatible databases.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from .base import DataError, DataProvider
+
+logger = logging.getLogger(__name__)
+
+try:
+    import sqlalchemy
+    from sqlalchemy import create_engine, text
+
+    SQLALCHEMY_AVAILABLE = True
+except ImportError:
+    SQLALCHEMY_AVAILABLE = False
+
+
+class DatabaseProvider(DataProvider):
+    """
+    SQL database provider for backtesting.
+
+    Supports loading historical data from:
+    - PostgreSQL
+    - MySQL
+    - SQLite
+    - Any SQLAlchemy-compatible database
+
+    Example:
+        ```python
+        provider = DatabaseProvider(
+            connection_string="postgresql://user:pass@host:5432/dbname"
+        )
+
+        # Load from table with filtering
+        data = provider.fetch(
+            source="trades",
+            symbols=["NFL-KC-BUF-WINNER"],
+            start="2024-01-01",
+            end="2024-03-31"
+        )
+
+        # Load with custom SQL
+        data = provider.fetch(
+            source="SELECT * FROM trades WHERE volume > 100",
+            start="2024-01-01"
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        connection_string: str,
+        pool_size: int = 5,
+        max_overflow: int = 10,
+        **kwargs,
+    ):
+        """
+        Initialize database provider.
+
+        Args:
+            connection_string: SQLAlchemy database URL
+            pool_size: Connection pool size
+            max_overflow: Max pool overflow
+            **kwargs: Additional SQLAlchemy engine options
+        """
+        super().__init__(**kwargs)
+
+        if not SQLALCHEMY_AVAILABLE:
+            raise ImportError(
+                "Database provider requires SQLAlchemy: pip install sqlalchemy"
+            )
+
+        self.connection_string = connection_string
+
+        # Create database engine
+        try:
+            engine_kwargs = {
+                "pool_size": pool_size,
+                "max_overflow": max_overflow,
+                "pool_timeout": 30,
+                "pool_recycle": 3600,
+                **kwargs,
+            }
+
+            self.engine = create_engine(connection_string, **engine_kwargs)
+
+            # Test connection
+            with self.engine.connect() as conn:
+                conn.execute(text("SELECT 1"))
+
+            logger.info("Database provider initialized successfully")
+
+        except Exception as e:
+            logger.error(f"Database connection failed: {e}")
+            raise DataError(f"Failed to connect to database: {e}")
+
+    def fetch(
+        self,
+        source: str,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        limit: Optional[int] = None,
+        **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Fetch data from database.
+
+        Args:
+            source: Table name or SQL query
+            symbols: Filter by symbols
+            start: Start date filter (YYYY-MM-DD)
+            end: End date filter (YYYY-MM-DD)
+            limit: Maximum number of records
+            **kwargs: Additional query parameters
+
+        Returns:
+            DataFrame with standardized columns
+        """
+        try:
+            # Build SQL query
+            if source.upper().strip().startswith("SELECT"):
+                # Custom SQL query
+                query = source
+                params = kwargs
+            else:
+                # Table name - build query
+                query, params = self._build_query(
+                    table=source,
+                    symbols=symbols,
+                    start=start,
+                    end=end,
+                    limit=limit,
+                    **kwargs,
+                )
+
+            logger.info(f"Executing database query: {query}")
+            logger.debug(f"Query parameters: {params}")
+
+            # Execute query
+            data = pd.read_sql(sql=text(query), con=self.engine, params=params)
+
+            # Ensure timestamp column is datetime
+            if "timestamp" in data.columns:
+                data["timestamp"] = pd.to_datetime(data["timestamp"])
+
+            # Clean and validate
+            data = self.clean_data(data)
+            self.validate(data)
+
+            logger.info(f"Loaded {len(data)} records from database")
+            return data
+
+        except Exception as e:
+            logger.error(f"Database query failed: {e}")
+            raise DataError(f"Failed to fetch from database: {e}")
+
+    def _build_query(
+        self,
+        table: str,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        limit: Optional[int] = None,
+        order_by: str = "timestamp",
+        **kwargs,
+    ) -> tuple:
+        """Build SQL query and parameters."""
+
+        # Base query
+        query = f"SELECT * FROM {table}"
+        conditions = []
+        params = {}
+
+        # Add filters
+        if start:
+            conditions.append("timestamp >= :start_date")
+            params["start_date"] = start
+
+        if end:
+            conditions.append("timestamp <= :end_date")
+            params["end_date"] = end
+
+        if symbols:
+            # Create IN clause with parameterized values
+            symbol_params = []
+            for i, symbol in enumerate(symbols):
+                param_name = f"symbol_{i}"
+                symbol_params.append(f":{param_name}")
+                params[param_name] = symbol
+
+            conditions.append(f"symbol IN ({', '.join(symbol_params)})")
+
+        # Add custom conditions from kwargs
+        for key, value in kwargs.items():
+            if key not in ["order_by"]:  # Skip non-filter kwargs
+                conditions.append(f"{key} = :{key}")
+                params[key] = value
+
+        # Add WHERE clause if conditions exist
+        if conditions:
+            query += " WHERE " + " AND ".join(conditions)
+
+        # Add ORDER BY
+        if order_by:
+            query += f" ORDER BY {order_by}"
+
+        # Add LIMIT
+        if limit:
+            query += f" LIMIT {limit}"
+
+        return query, params
+
+    def get_available_symbols(self, source: str) -> List[str]:
+        """Get unique symbols from database table."""
+        try:
+            if source.upper().strip().startswith("SELECT"):
+                # Extract from custom query - just run it and get symbols
+                sample_data = self.fetch(source)
+                if len(sample_data) > 10000:
+                    sample_data = sample_data.sample(10000)
+                return sorted(sample_data["symbol"].unique().tolist())
+            else:
+                # Simple table query
+                query = f"SELECT DISTINCT symbol FROM {source} ORDER BY symbol"
+
+                with self.engine.connect() as conn:
+                    result = conn.execute(text(query))
+                    symbols = [row[0] for row in result]
+
+                return symbols
+
+        except Exception as e:
+            logger.error(f"Error getting symbols from database: {e}")
+            return []
+
+    def get_table_info(self, table_name: str) -> Dict[str, Any]:
+        """Get information about database table."""
+        try:
+            # Get table schema
+            with self.engine.connect() as conn:
+                # Get column info
+                if "postgresql" in self.connection_string.lower():
+                    schema_query = """
+                        SELECT column_name, data_type, is_nullable
+                        FROM information_schema.columns 
+                        WHERE table_name = :table_name
+                        ORDER BY ordinal_position
+                    """
+                elif "mysql" in self.connection_string.lower():
+                    schema_query = """
+                        SELECT column_name, data_type, is_nullable
+                        FROM information_schema.columns 
+                        WHERE table_name = :table_name
+                        ORDER BY ordinal_position
+                    """
+                else:
+                    # SQLite or generic
+                    schema_query = f"PRAGMA table_info({table_name})"
+
+                schema_result = conn.execute(
+                    text(schema_query), {"table_name": table_name}
+                )
+                columns = list(schema_result)
+
+                # Get row count
+                count_query = f"SELECT COUNT(*) FROM {table_name}"
+                count_result = conn.execute(text(count_query))
+                row_count = count_result.scalar()
+
+                # Get date range if timestamp column exists
+                date_range = None
+                try:
+                    date_query = f"""
+                        SELECT MIN(timestamp) as min_date, MAX(timestamp) as max_date 
+                        FROM {table_name}
+                        WHERE timestamp IS NOT NULL
+                    """
+                    date_result = conn.execute(text(date_query))
+                    date_row = date_result.first()
+                    if date_row:
+                        date_range = (date_row[0], date_row[1])
+                except:
+                    pass  # timestamp column might not exist
+
+                return {
+                    "table_name": table_name,
+                    "columns": columns,
+                    "row_count": row_count,
+                    "date_range": date_range,
+                }
+
+        except Exception as e:
+            logger.error(f"Error getting table info: {e}")
+            return {}
+
+    def execute_query(self, query: str, params: Dict[str, Any] = None) -> pd.DataFrame:
+        """Execute custom SQL query."""
+        try:
+            data = pd.read_sql(sql=text(query), con=self.engine, params=params or {})
+
+            logger.info(f"Query returned {len(data)} records")
+            return data
+
+        except Exception as e:
+            logger.error(f"Query execution failed: {e}")
+            raise DataError(f"Failed to execute query: {e}")
+
+    def list_tables(self) -> List[str]:
+        """List all tables in the database."""
+        try:
+            with self.engine.connect() as conn:
+                if "postgresql" in self.connection_string.lower():
+                    query = """
+                        SELECT table_name 
+                        FROM information_schema.tables 
+                        WHERE table_schema = 'public'
+                        ORDER BY table_name
+                    """
+                elif "mysql" in self.connection_string.lower():
+                    query = "SHOW TABLES"
+                else:
+                    # SQLite
+                    query = """
+                        SELECT name FROM sqlite_master 
+                        WHERE type='table'
+                        ORDER BY name
+                    """
+
+                result = conn.execute(text(query))
+                tables = [row[0] for row in result]
+
+                return tables
+
+        except Exception as e:
+            logger.error(f"Error listing tables: {e}")
+            return []
+
+    def close(self):
+        """Close database connection."""
+        if hasattr(self, "engine"):
+            self.engine.dispose()
+            logger.info("Database connection closed")
diff --git a/neural_sdk/backtesting/providers/parquet_provider.py b/neural_sdk/backtesting/providers/parquet_provider.py
new file mode 100644
index 00000000..4923e3e6
--- /dev/null
+++ b/neural_sdk/backtesting/providers/parquet_provider.py
@@ -0,0 +1,378 @@
+"""
+Parquet Data Provider for Backtesting
+
+High-performance data loading from Parquet files.
+Optimal for large historical datasets with columnar storage.
+"""
+
+import glob
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from .base import DataError, DataProvider
+
+logger = logging.getLogger(__name__)
+
+try:
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    PYARROW_AVAILABLE = True
+except ImportError:
+    PYARROW_AVAILABLE = False
+    logger.warning("PyArrow not available. Falling back to pandas parquet engine.")
+
+
+class ParquetProvider(DataProvider):
+    """
+    Parquet file data provider for backtesting.
+
+    Optimized for large datasets with:
+    - Column-based filtering
+    - Predicate pushdown
+    - Memory-efficient loading
+    - Multi-file support
+
+    Example:
+        ```python
+        provider = ParquetProvider()
+
+        # Load single file
+        data = provider.fetch('trades_2024.parquet')
+
+        # Load multiple files with date partitioning
+        data = provider.fetch('data/year=2024/month=*/trades.parquet')
+
+        # Load with filtering
+        data = provider.fetch(
+            'trades.parquet',
+            symbols=['NFL-KC-BUF-WINNER'],
+            columns=['timestamp', 'symbol', 'price']
+        )
+        ```
+    """
+
+    def __init__(self, use_pyarrow: bool = True, **kwargs):
+        """
+        Initialize Parquet provider.
+
+        Args:
+            use_pyarrow: Use PyArrow engine if available (recommended)
+            **kwargs: Additional configuration
+        """
+        super().__init__(**kwargs)
+
+        self.use_pyarrow = use_pyarrow and PYARROW_AVAILABLE
+        if use_pyarrow and not PYARROW_AVAILABLE:
+            logger.warning("PyArrow requested but not available")
+
+        # Parquet reading options
+        self.parquet_options = {
+            "engine": "pyarrow" if self.use_pyarrow else "auto",
+            **kwargs.get("parquet_options", {}),
+        }
+
+    def fetch(
+        self,
+        source: str,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        columns: Optional[List[str]] = None,
+        **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Load data from Parquet file(s).
+
+        Args:
+            source: Parquet file path or glob pattern
+            symbols: Filter by symbols (pushed down to file level if supported)
+            start: Start date filter
+            end: End date filter
+            columns: Specific columns to load (memory optimization)
+            **kwargs: Additional parquet reading options
+
+        Returns:
+            DataFrame with requested data
+        """
+        try:
+            # Handle glob patterns for multiple files
+            if "*" in source or "?" in source:
+                files = glob.glob(source)
+                if not files:
+                    raise FileNotFoundError(
+                        f"No files found matching pattern: {source}"
+                    )
+                logger.info(f"Loading {len(files)} Parquet files")
+
+                if self.use_pyarrow and len(files) > 1:
+                    # Use PyArrow dataset for efficient multi-file loading
+                    data = self._load_dataset(
+                        files, symbols, start, end, columns, **kwargs
+                    )
+                else:
+                    # Load individual files
+                    dataframes = []
+                    for file_path in files:
+                        df = self._load_single_file(file_path, columns, **kwargs)
+                        dataframes.append(df)
+                    data = pd.concat(dataframes, ignore_index=True)
+
+            else:
+                # Single file
+                data = self._load_single_file(source, columns, **kwargs)
+
+            # Validate data
+            self.validate(data)
+
+            # Apply filters (if not already applied at file level)
+            data = self.filter_data(data, symbols, start, end)
+
+            logger.info(f"Loaded {len(data)} records from Parquet: {source}")
+            return data
+
+        except Exception as e:
+            logger.error(f"Error loading Parquet {source}: {e}")
+            raise DataError(f"Failed to load Parquet data: {e}")
+
+    def _load_single_file(
+        self, file_path: str, columns: Optional[List[str]] = None, **kwargs
+    ) -> pd.DataFrame:
+        """Load single Parquet file."""
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Parquet file not found: {file_path}")
+
+        # Merge options
+        options = {**self.parquet_options, **kwargs}
+
+        # Read parquet file
+        if columns:
+            options["columns"] = columns
+            logger.debug(f"Loading columns: {columns}")
+
+        data = pd.read_parquet(file_path, **options)
+
+        return data
+
+    def _load_dataset(
+        self,
+        files: List[str],
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        columns: Optional[List[str]] = None,
+        **kwargs,
+    ) -> pd.DataFrame:
+        """Load multiple files efficiently using PyArrow dataset."""
+        if not self.use_pyarrow:
+            raise NotImplementedError("Dataset loading requires PyArrow")
+
+        # Create dataset
+        dataset = pq.ParquetDataset(files)
+
+        # Build filters for predicate pushdown
+        filters = []
+
+        if symbols:
+            filters.append(("symbol", "in", symbols))
+
+        if start:
+            filters.append(("timestamp", ">=", pd.to_datetime(start)))
+
+        if end:
+            filters.append(("timestamp", "<=", pd.to_datetime(end)))
+
+        # Read with filters
+        table = dataset.read(columns=columns, filters=filters or None)
+        data = table.to_pandas()
+
+        if len(filters) > 0:
+            logger.info(f"Applied {len(filters)} filters at file level")
+
+        return data
+
+    def get_file_metadata(self, file_path: str) -> Dict[str, Any]:
+        """
+        Get metadata from Parquet file without loading data.
+
+        Args:
+            file_path: Path to Parquet file
+
+        Returns:
+            Dict with file metadata
+        """
+        if not PYARROW_AVAILABLE:
+            logger.warning("PyArrow not available for metadata extraction")
+            return {}
+
+        try:
+            parquet_file = pq.ParquetFile(file_path)
+            schema = parquet_file.schema_arrow
+
+            metadata = {
+                "num_rows": parquet_file.metadata.num_rows,
+                "num_columns": len(schema),
+                "columns": [field.name for field in schema],
+                "file_size": Path(file_path).stat().st_size,
+                "compression": None,
+            }
+
+            # Get column statistics if available
+            if parquet_file.metadata.row_group(0):
+                rg_meta = parquet_file.metadata.row_group(0)
+                for i in range(rg_meta.num_columns):
+                    col_meta = rg_meta.column(i)
+                    if col_meta.compression:
+                        metadata["compression"] = col_meta.compression
+                        break
+
+            return metadata
+
+        except Exception as e:
+            logger.error(f"Error reading Parquet metadata: {e}")
+            return {}
+
+    def get_available_symbols(self, source: str) -> List[str]:
+        """Get unique symbols from Parquet file efficiently."""
+        try:
+            if self.use_pyarrow:
+                # Read just the symbol column
+                data = pd.read_parquet(source, columns=["symbol"])
+            else:
+                # Read small sample
+                data = pd.read_parquet(source, engine="auto")
+                if len(data) > 10000:
+                    data = data.sample(10000)
+
+            return sorted(data["symbol"].unique().tolist())
+
+        except Exception as e:
+            logger.error(f"Error getting symbols from {source}: {e}")
+            return []
+
+    def optimize_file(
+        self,
+        input_path: str,
+        output_path: str,
+        partition_cols: Optional[List[str]] = None,
+        compression: str = "snappy",
+    ):
+        """
+        Optimize Parquet file for backtesting performance.
+
+        Args:
+            input_path: Source file path
+            output_path: Optimized file path
+            partition_cols: Columns to partition by (e.g., ['symbol', 'date'])
+            compression: Compression algorithm
+        """
+        if not self.use_pyarrow:
+            logger.error("File optimization requires PyArrow")
+            return
+
+        try:
+            # Read source file
+            table = pq.read_table(input_path)
+
+            # Sort by timestamp for better filtering performance
+            if "timestamp" in table.column_names:
+                indices = pa.compute.sort_indices(
+                    table, sort_keys=[("timestamp", "ascending")]
+                )
+                table = pa.compute.take(table, indices)
+
+            # Write optimized file
+            if partition_cols:
+                pq.write_to_dataset(
+                    table,
+                    root_path=output_path,
+                    partition_cols=partition_cols,
+                    compression=compression,
+                )
+                logger.info(f"Created partitioned dataset at: {output_path}")
+            else:
+                pq.write_table(table, output_path, compression=compression)
+                logger.info(f"Optimized file saved to: {output_path}")
+
+        except Exception as e:
+            logger.error(f"Error optimizing Parquet file: {e}")
+
+    def create_sample_data(self, output_path: str, num_records: int = 10000):
+        """
+        Create sample Parquet file for testing.
+
+        Args:
+            output_path: Where to save sample file
+            num_records: Number of sample records
+        """
+        from datetime import datetime, timedelta
+
+        import numpy as np
+
+        # Generate sample data
+        start_time = datetime(2024, 1, 1)
+        timestamps = [start_time + timedelta(minutes=i) for i in range(num_records)]
+
+        symbols = ["NFL-KC-BUF-WINNER", "NFL-KC-BUF-TOTAL", "NBA-LAL-GSW-WINNER"]
+
+        data = pd.DataFrame(
+            {
+                "timestamp": np.random.choice(timestamps, num_records),
+                "symbol": np.random.choice(symbols, num_records),
+                "price": np.random.uniform(0.3, 0.7, num_records),
+                "volume": np.random.randint(1, 1000, num_records),
+            }
+        )
+
+        # Sort by timestamp
+        data = data.sort_values("timestamp")
+
+        # Save to parquet
+        data.to_parquet(output_path, compression="snappy")
+
+        logger.info(f"Sample Parquet file created: {output_path}")
+        logger.info(f"Records: {num_records}, Symbols: {len(symbols)}")
+
+    def convert_csv_to_parquet(
+        self, csv_path: str, parquet_path: str, optimize: bool = True
+    ):
+        """
+        Convert CSV file to optimized Parquet format.
+
+        Args:
+            csv_path: Source CSV file
+            parquet_path: Output Parquet file
+            optimize: Apply optimization during conversion
+        """
+        try:
+            # Load CSV
+            from .csv_provider import CSVProvider
+
+            csv_provider = CSVProvider()
+            data = csv_provider.fetch(csv_path)
+
+            if optimize:
+                # Sort by timestamp for better query performance
+                data = data.sort_values("timestamp")
+
+            # Save as Parquet
+            compression = "snappy" if optimize else None
+            data.to_parquet(parquet_path, compression=compression, index=False)
+
+            # Compare file sizes
+            csv_size = Path(csv_path).stat().st_size
+            parquet_size = Path(parquet_path).stat().st_size
+            compression_ratio = (csv_size - parquet_size) / csv_size * 100
+
+            logger.info(f"Converted CSV to Parquet: {csv_path} -> {parquet_path}")
+            logger.info(
+                f"Size reduction: {compression_ratio:.1f}% ({csv_size:,} -> {parquet_size:,} bytes)"
+            )
+
+        except Exception as e:
+            logger.error(f"Error converting CSV to Parquet: {e}")
+            raise
diff --git a/neural_sdk/backtesting/providers/s3_provider.py b/neural_sdk/backtesting/providers/s3_provider.py
new file mode 100644
index 00000000..2774b6e5
--- /dev/null
+++ b/neural_sdk/backtesting/providers/s3_provider.py
@@ -0,0 +1,311 @@
+"""
+S3 Data Provider for Backtesting
+
+Loads historical trading data from Amazon S3 buckets.
+Supports large-scale data storage and efficient querying.
+"""
+
+import io
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from .base import DataError, DataProvider
+
+logger = logging.getLogger(__name__)
+
+try:
+    import boto3
+    from botocore.exceptions import ClientError, NoCredentialsError
+
+    BOTO3_AVAILABLE = True
+except ImportError:
+    BOTO3_AVAILABLE = False
+
+
+class S3Provider(DataProvider):
+    """
+    S3 data provider for backtesting.
+
+    Loads historical data from S3 buckets with support for:
+    - Parquet and CSV files
+    - Partitioned datasets
+    - Prefix-based filtering
+    - AWS credential handling
+
+    Example:
+        ```python
+        provider = S3Provider(
+            bucket="my-trading-data",
+            aws_profile="default"
+        )
+
+        data = provider.fetch(
+            source="trades/2024/",
+            symbols=["NFL-KC-BUF-WINNER"],
+            start="2024-01-01",
+            end="2024-03-31"
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        bucket: str,
+        aws_profile: Optional[str] = None,
+        region: str = "us-east-1",
+        **kwargs,
+    ):
+        """
+        Initialize S3 provider.
+
+        Args:
+            bucket: S3 bucket name
+            aws_profile: AWS profile to use (None for default)
+            region: AWS region
+            **kwargs: Additional configuration
+        """
+        super().__init__(**kwargs)
+
+        if not BOTO3_AVAILABLE:
+            raise ImportError("S3 provider requires boto3: pip install boto3")
+
+        self.bucket = bucket
+        self.aws_profile = aws_profile
+        self.region = region
+
+        # Initialize S3 client
+        try:
+            session = boto3.Session(profile_name=aws_profile)
+            self.s3_client = session.client("s3", region_name=region)
+            self.s3_resource = session.resource("s3", region_name=region)
+
+            # Test connection
+            self.s3_client.head_bucket(Bucket=bucket)
+            logger.info(f"S3 provider initialized for bucket: {bucket}")
+
+        except NoCredentialsError:
+            raise DataError(
+                "AWS credentials not found. Configure AWS CLI or set environment variables."
+            )
+        except ClientError as e:
+            error_code = e.response["Error"]["Code"]
+            if error_code == "404":
+                raise DataError(f"S3 bucket not found: {bucket}")
+            elif error_code == "403":
+                raise DataError(f"Access denied to S3 bucket: {bucket}")
+            else:
+                raise DataError(f"S3 connection failed: {e}")
+
+    def fetch(
+        self,
+        source: str,
+        symbols: Optional[List[str]] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        file_format: str = "auto",
+        **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Fetch data from S3.
+
+        Args:
+            source: S3 prefix/key (e.g., "trades/2024/" or "data.parquet")
+            symbols: Filter by symbols (applied after loading)
+            start: Start date filter
+            end: End date filter
+            file_format: File format ("auto", "parquet", "csv")
+            **kwargs: Additional parameters
+
+        Returns:
+            DataFrame with standardized columns
+        """
+        try:
+            # List objects with the given prefix
+            objects = self._list_objects(source)
+
+            if not objects:
+                raise DataError(f"No objects found in S3 with prefix: {source}")
+
+            # Filter objects by file type if specified
+            if file_format != "auto":
+                objects = [obj for obj in objects if obj.endswith(f".{file_format}")]
+
+            logger.info(f"Found {len(objects)} S3 objects to load")
+
+            # Load data from objects
+            dataframes = []
+            for obj_key in objects:
+                try:
+                    df = self._load_single_object(obj_key, file_format)
+                    if len(df) > 0:
+                        dataframes.append(df)
+                except Exception as e:
+                    logger.warning(f"Failed to load {obj_key}: {e}")
+
+            if not dataframes:
+                raise DataError("No valid data loaded from S3 objects")
+
+            # Combine all dataframes
+            data = pd.concat(dataframes, ignore_index=True)
+
+            # Clean and validate
+            data = self.clean_data(data)
+            self.validate(data)
+
+            # Apply filters
+            data = self.filter_data(data, symbols, start, end)
+
+            logger.info(f"Loaded {len(data)} records from S3: {source}")
+            return data
+
+        except Exception as e:
+            logger.error(f"S3 fetch failed: {e}")
+            raise DataError(f"Failed to fetch from S3: {e}")
+
+    def _list_objects(self, prefix: str) -> List[str]:
+        """List objects in S3 bucket with given prefix."""
+        objects = []
+
+        try:
+            paginator = self.s3_client.get_paginator("list_objects_v2")
+            pages = paginator.paginate(Bucket=self.bucket, Prefix=prefix)
+
+            for page in pages:
+                if "Contents" in page:
+                    for obj in page["Contents"]:
+                        key = obj["Key"]
+                        # Skip directories
+                        if not key.endswith("/"):
+                            objects.append(key)
+
+        except ClientError as e:
+            raise DataError(f"Failed to list S3 objects: {e}")
+
+        return objects
+
+    def _load_single_object(self, key: str, file_format: str = "auto") -> pd.DataFrame:
+        """Load single object from S3."""
+        try:
+            # Get object
+            response = self.s3_client.get_object(Bucket=self.bucket, Key=key)
+            content = response["Body"].read()
+
+            # Determine file format
+            if file_format == "auto":
+                if key.endswith(".parquet"):
+                    file_format = "parquet"
+                elif key.endswith(".csv"):
+                    file_format = "csv"
+                else:
+                    # Try to guess from content
+                    file_format = "csv"  # Default fallback
+
+            # Load data based on format
+            if file_format == "parquet":
+                df = pd.read_parquet(io.BytesIO(content))
+            elif file_format == "csv":
+                df = pd.read_csv(io.BytesIO(content))
+            else:
+                raise ValueError(f"Unsupported file format: {file_format}")
+
+            logger.debug(f"Loaded {len(df)} records from {key}")
+            return df
+
+        except ClientError as e:
+            raise DataError(f"Failed to load S3 object {key}: {e}")
+
+    def upload_data(
+        self, data: pd.DataFrame, key: str, file_format: str = "parquet", **kwargs
+    ):
+        """
+        Upload data to S3.
+
+        Args:
+            data: DataFrame to upload
+            key: S3 key/path
+            file_format: File format ("parquet", "csv")
+            **kwargs: Format-specific options
+        """
+        try:
+            # Convert to bytes
+            if file_format == "parquet":
+                buffer = io.BytesIO()
+                data.to_parquet(buffer, **kwargs)
+                buffer.seek(0)
+            elif file_format == "csv":
+                buffer = io.StringIO()
+                data.to_csv(buffer, index=False, **kwargs)
+                buffer = io.BytesIO(buffer.getvalue().encode())
+            else:
+                raise ValueError(f"Unsupported upload format: {file_format}")
+
+            # Upload to S3
+            self.s3_client.put_object(
+                Bucket=self.bucket, Key=key, Body=buffer.getvalue()
+            )
+
+            logger.info(f"Uploaded {len(data)} records to s3://{self.bucket}/{key}")
+
+        except Exception as e:
+            logger.error(f"S3 upload failed: {e}")
+            raise DataError(f"Failed to upload to S3: {e}")
+
+    def get_available_symbols(self, source: str) -> List[str]:
+        """Get unique symbols from S3 data."""
+        try:
+            # Load a sample of data to get symbols
+            sample_data = self.fetch(source)
+            if len(sample_data) > 10000:
+                sample_data = sample_data.sample(10000)
+
+            return sorted(sample_data["symbol"].unique().tolist())
+
+        except Exception as e:
+            logger.error(f"Error getting symbols from S3: {e}")
+            return []
+
+    def create_partitioned_dataset(
+        self,
+        data: pd.DataFrame,
+        base_prefix: str,
+        partition_cols: List[str] = None,
+        file_format: str = "parquet",
+    ):
+        """
+        Create partitioned dataset in S3.
+
+        Args:
+            data: Data to partition and upload
+            base_prefix: Base S3 prefix for partitioned data
+            partition_cols: Columns to partition by
+            file_format: File format for partitioned files
+        """
+        if not partition_cols:
+            partition_cols = ["symbol"]
+
+        try:
+            # Group by partition columns
+            for group_values, group_data in data.groupby(partition_cols):
+                if not isinstance(group_values, tuple):
+                    group_values = (group_values,)
+
+                # Build partition path
+                partition_path = base_prefix.rstrip("/")
+                for col, value in zip(partition_cols, group_values):
+                    partition_path += f"/{col}={value}"
+
+                # Create filename
+                filename = f"data.{file_format}"
+                full_key = f"{partition_path}/{filename}"
+
+                # Upload partition
+                self.upload_data(group_data, full_key, file_format)
+
+            logger.info(f"Created partitioned dataset: {base_prefix}")
+
+        except Exception as e:
+            logger.error(f"Partitioned dataset creation failed: {e}")
+            raise DataError(f"Failed to create partitioned dataset: {e}")
diff --git a/neural_sdk/cli.py b/neural_sdk/cli.py
new file mode 100644
index 00000000..871a0922
--- /dev/null
+++ b/neural_sdk/cli.py
@@ -0,0 +1,368 @@
+"""
+Command-line interface for the Neural Trading SDK.
+
+This module provides a CLI for managing the SDK, running trading systems,
+and performing administrative tasks.
+"""
+
+import asyncio
+import json
+import logging
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from .core.client import NeuralSDK
+from .core.config import SDKConfig
+from .core.exceptions import ConfigurationError, SDKError
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create CLI app
+app = typer.Typer(
+    name="neural-sdk",
+    help="Neural Trading SDK - Algorithmic sports trading platform",
+    add_completion=False,
+)
+
+console = Console()
+
+
+@app.callback()
+def callback():
+    """Neural Trading SDK CLI"""
+    pass
+
+
+@app.command()
+def init(
+    config_file: Optional[str] = typer.Option(
+        None, "--config", "-c", help="Path to configuration file"
+    ),
+    environment: str = typer.Option(
+        "development",
+        "--env",
+        "-e",
+        help="Environment (development/staging/production)",
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Overwrite existing configuration"
+    ),
+):
+    """
+    Initialize SDK configuration.
+
+    Creates a default configuration file that can be customized for your needs.
+    """
+    try:
+        if config_file:
+            config_path = Path(config_file)
+        else:
+            config_path = Path("neural_config.yaml")
+
+        if config_path.exists() and not force:
+            console.print(
+                f"[red]Configuration file already exists: {config_path}[/red]"
+            )
+            console.print("[yellow]Use --force to overwrite[/yellow]")
+            return
+
+        # Create default configuration
+        config = SDKConfig(
+            environment=environment, enable_debug_mode=environment == "development"
+        )
+
+        # Save configuration
+        config.save_to_file(str(config_path))
+
+        console.print(f"[green]✅ Configuration created: {config_path}[/green]")
+        console.print("\n[bold]Next steps:[/bold]")
+        console.print("1. Edit the configuration file with your API keys")
+        console.print("2. Run 'neural-sdk start' to begin trading")
+
+    except Exception as e:
+        console.print(f"[red]❌ Failed to initialize configuration: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def start(
+    config_file: Optional[str] = typer.Option(
+        None, "--config", "-c", help="Path to configuration file"
+    ),
+    env_prefix: str = typer.Option(
+        "KALSHI_", "--env-prefix", "-p", help="Environment variable prefix"
+    ),
+):
+    """
+    Start the trading system.
+
+    Initializes all components and begins automated trading based on your configuration.
+    """
+    try:
+        # Load configuration
+        if config_file:
+            config = SDKConfig.from_file(config_file)
+        else:
+            config = SDKConfig.from_env(env_prefix)
+
+        console.print(
+            f"[blue]🚀 Starting Neural Trading SDK ({config.environment})[/blue]"
+        )
+
+        # Create SDK instance
+        sdk = NeuralSDK(config)
+
+        # Display configuration summary
+        console.print(
+            Panel.fit(
+                config.get_summary(),
+                title="📊 Configuration Summary",
+                border_style="blue",
+            )
+        )
+
+        # Start trading system
+        asyncio.run(_run_trading_system(sdk))
+
+    except ConfigurationError as e:
+        console.print(f"[red]❌ Configuration error: {e}[/red]")
+        console.print(
+            "[yellow]Run 'neural-sdk init' to create a configuration file[/yellow]"
+        )
+        raise typer.Exit(1)
+    except KeyboardInterrupt:
+        console.print("[yellow]⚠️  Trading system interrupted by user[/yellow]")
+    except Exception as e:
+        console.print(f"[red]❌ Failed to start trading system: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def status(
+    config_file: Optional[str] = typer.Option(
+        None, "--config", "-c", help="Path to configuration file"
+    ),
+    env_prefix: str = typer.Option(
+        "KALSHI_", "--env-prefix", "-p", help="Environment variable prefix"
+    ),
+    watch: bool = typer.Option(
+        False, "--watch", "-w", help="Continuously monitor status"
+    ),
+):
+    """
+    Show system status and health information.
+    """
+    try:
+        # Load configuration
+        if config_file:
+            config = SDKConfig.from_file(config_file)
+        else:
+            config = SDKConfig.from_env(env_prefix)
+
+        sdk = NeuralSDK(config)
+
+        if watch:
+            console.print("[green]📊 Monitoring system status (Ctrl+C to stop)[/green]")
+            asyncio.run(_monitor_status(sdk))
+        else:
+            asyncio.run(_show_status(sdk))
+
+    except Exception as e:
+        console.print(f"[red]❌ Failed to get status: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def validate(
+    config_file: Optional[str] = typer.Option(
+        None, "--config", "-c", help="Path to configuration file"
+    ),
+    env_prefix: str = typer.Option(
+        "KALSHI_", "--env-prefix", "-p", help="Environment variable prefix"
+    ),
+):
+    """
+    Validate configuration and check system health.
+    """
+    try:
+        # Load configuration
+        if config_file:
+            config = SDKConfig.from_file(config_file)
+        else:
+            config = SDKConfig.from_env(env_prefix)
+
+        console.print("[blue]🔍 Validating configuration...[/blue]")
+
+        # Create SDK instance (this will validate config)
+        sdk = NeuralSDK(config)
+
+        # Perform health check
+        health = asyncio.run(sdk.health_check())
+
+        # Display results
+        if health["overall"] == "healthy":
+            console.print(
+                "[green]✅ Configuration is valid and system is healthy[/green]"
+            )
+        else:
+            console.print(f"[red]❌ System health: {health['overall']}[/red]")
+
+        # Show component status
+        table = Table(title="Component Status")
+        table.add_column("Component", style="cyan")
+        table.add_column("Status", style="green")
+
+        for component, status in health["components"].items():
+            status_color = {
+                "healthy": "green",
+                "degraded": "yellow",
+                "unhealthy": "red",
+            }.get(status, "white")
+            table.add_row(component, f"[{status_color}]{status}[/{status_color}]")
+
+        console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]❌ Validation failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def config(
+    action: str = typer.Argument(..., help="Action: show, edit, or validate"),
+    config_file: Optional[str] = typer.Option(
+        None, "--config", "-c", help="Path to configuration file"
+    ),
+    env_prefix: str = typer.Option(
+        "KALSHI_", "--env-prefix", "-p", help="Environment variable prefix"
+    ),
+):
+    """
+    Manage SDK configuration.
+
+    Actions:
+    - show: Display current configuration
+    - edit: Open configuration file in editor
+    - validate: Check configuration validity
+    """
+    try:
+        if action == "show":
+            if config_file:
+                config = SDKConfig.from_file(config_file)
+            else:
+                config = SDKConfig.from_env(env_prefix)
+
+            console.print(
+                Panel.fit(
+                    config.get_summary(),
+                    title="📋 Current Configuration",
+                    border_style="blue",
+                )
+            )
+
+        elif action == "edit":
+            if not config_file:
+                config_file = "neural_config.yaml"
+
+            config_path = Path(config_file)
+            if not config_path.exists():
+                console.print(f"[red]Configuration file not found: {config_path}[/red]")
+                console.print("[yellow]Run 'neural-sdk init' to create one[/yellow]")
+                return
+
+            # Try to open in editor
+            import os
+            import subprocess
+
+            editor = os.getenv("EDITOR", "nano")
+            try:
+                subprocess.run([editor, str(config_path)])
+                console.print(f"[green]✅ Configuration edited: {config_path}[/green]")
+            except Exception as e:
+                console.print(f"[red]❌ Failed to open editor: {e}[/red]")
+                console.print(f"Edit the file manually: {config_path}")
+
+        elif action == "validate":
+            # Reuse the validate command logic
+            validate(config_file, env_prefix)
+
+        else:
+            console.print(f"[red]❌ Unknown action: {action}[/red]")
+            console.print("Available actions: show, edit, validate")
+            raise typer.Exit(1)
+
+    except Exception as e:
+        console.print(f"[red]❌ Config command failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+async def _run_trading_system(sdk: NeuralSDK):
+    """Run the trading system with proper error handling."""
+    try:
+        await sdk.start_trading_system()
+    except KeyboardInterrupt:
+        console.print("[yellow]⚠️  Received shutdown signal[/yellow]")
+    finally:
+        await sdk.stop_trading_system()
+        console.print("[green]✅ Trading system shut down gracefully[/green]")
+
+
+async def _show_status(sdk: NeuralSDK):
+    """Show current system status."""
+    try:
+        # Get system status
+        status = sdk.get_system_status()
+        health = await sdk.health_check()
+
+        # Display status
+        console.print(
+            Panel.fit(
+                f"""
+Environment: {status['environment']}
+Running: {'✅ Yes' if status['is_running'] else '❌ No'}
+Data Sources: {status['data_sources_connected']}
+Active Agents: {status['agents_active']}
+Loaded Strategies: {status['strategies_loaded']}
+System Health: {health['overall']}
+Last Update: {status['last_update']}
+            """.strip(),
+                title="📊 System Status",
+                border_style="blue",
+            )
+        )
+
+    except Exception as e:
+        console.print(f"[red]❌ Failed to get status: {e}[/red]")
+
+
+async def _monitor_status(sdk: NeuralSDK):
+    """Continuously monitor system status."""
+    import time
+
+    try:
+        while True:
+            console.clear()
+            await _show_status(sdk)
+            console.print(
+                "\n[yellow]Refreshing in 5 seconds... (Ctrl+C to stop)[/yellow]"
+            )
+            await asyncio.sleep(5)
+    except KeyboardInterrupt:
+        console.print("[green]✅ Monitoring stopped[/green]")
+
+
+def main():
+    """Main entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/neural_sdk/core/__init__.py b/neural_sdk/core/__init__.py
new file mode 100644
index 00000000..cb683ed7
--- /dev/null
+++ b/neural_sdk/core/__init__.py
@@ -0,0 +1,23 @@
+"""
+Core SDK functionality and base classes.
+"""
+
+from .client import NeuralSDK
+from .config import SDKConfig
+from .exceptions import (
+    ConfigurationError,
+    ConnectionError,
+    SDKError,
+    TradingError,
+    ValidationError,
+)
+
+__all__ = [
+    "NeuralSDK",
+    "SDKConfig",
+    "SDKError",
+    "ConfigurationError",
+    "ConnectionError",
+    "TradingError",
+    "ValidationError",
+]
diff --git a/neural_sdk/core/client.py b/neural_sdk/core/client.py
new file mode 100644
index 00000000..beac135d
--- /dev/null
+++ b/neural_sdk/core/client.py
@@ -0,0 +1,618 @@
+"""
+Main Neural SDK client.
+
+This module provides the primary interface for interacting with the Neural SDK.
+It orchestrates all components and provides a simple, unified API for trading operations.
+"""
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from .config import SDKConfig
+from .exceptions import (
+    ConfigurationError,
+    ConnectionError,
+    SDKError,
+    TradingError,
+    ValidationError,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TradingSignal:
+    """Represents a trading signal generated by a strategy."""
+
+    action: str  # "BUY", "SELL", "HOLD"
+    market_ticker: str
+    side: str  # "YES" or "NO"
+    confidence: float  # 0.0 to 1.0
+    quantity: Optional[int] = None
+    price_limit: Optional[float] = None
+    reason: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+    def __post_init__(self):
+        """Validate signal data."""
+        if self.action not in ["BUY", "SELL", "HOLD"]:
+            raise ValidationError(f"Invalid action: {self.action}")
+        if self.side not in ["YES", "NO"]:
+            raise ValidationError(f"Invalid side: {self.side}")
+        if not 0.0 <= self.confidence <= 1.0:
+            raise ValidationError(
+                f"Confidence must be between 0.0 and 1.0, got {self.confidence}"
+            )
+
+
+@dataclass
+class MarketData:
+    """Represents market data for a specific market."""
+
+    ticker: str
+    yes_price: float
+    no_price: float
+    yes_bid: Optional[float] = None
+    yes_ask: Optional[float] = None
+    no_bid: Optional[float] = None
+    no_ask: Optional[float] = None
+    volume: int = 0
+    open_interest: int = 0
+    last_update: Optional[datetime] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+    @property
+    def spread(self) -> Optional[float]:
+        """Calculate the bid-ask spread."""
+        if self.yes_ask and self.yes_bid:
+            return self.yes_ask - self.yes_bid
+        return None
+
+    @property
+    def implied_probability(self) -> float:
+        """Calculate implied probability from prices."""
+        return self.yes_price / (self.yes_price + self.no_price)
+
+
+@dataclass
+class TradeResult:
+    """Result of a trade execution."""
+
+    order_id: str
+    market_ticker: str
+    side: str
+    quantity: int
+    price: float
+    status: str  # "FILLED", "PARTIAL", "REJECTED", "CANCELLED"
+    timestamp: datetime
+    fees: Optional[float] = None
+    error_message: Optional[str] = None
+
+    @property
+    def total_cost(self) -> float:
+        """Calculate total cost including fees."""
+        cost = self.quantity * self.price
+        if self.fees:
+            cost += self.fees
+        return cost
+
+
+class NeuralSDK:
+    """
+    Main Neural SDK client.
+
+    This is the primary interface for the Neural SDK. It provides
+    a unified API for:
+    - Market data streaming
+    - Trading strategy deployment
+    - Risk management
+    - Portfolio monitoring
+    - Agent orchestration
+
+    Example:
+        ```python
+        from neural_sdk import NeuralSDK
+
+        # Initialize SDK
+        sdk = NeuralSDK.from_env()
+
+        # Create and deploy a strategy
+        @sdk.strategy
+        async def my_strategy(market_data):
+            if market_data.yes_price < 0.3:
+                return sdk.create_signal("BUY", market_data.ticker)
+
+        # Start trading
+        await sdk.start_trading_system()
+        ```
+    """
+
+    def __init__(self, config: SDKConfig):
+        """
+        Initialize the Neural SDK.
+
+        Args:
+            config: SDK configuration object
+
+        Raises:
+            ConfigurationError: If configuration is invalid
+        """
+        self.config = config
+        self._validate_config()
+
+        # Core components (to be initialized)
+        self._agents = {}
+        self._strategies = {}
+        self._data_sources = {}
+        self._is_running = False
+
+        # Event handlers
+        self._market_data_handlers: List[Callable] = []
+        self._signal_handlers: List[Callable] = []
+        self._trade_handlers: List[Callable] = []
+
+        logger.info(f"Neural SDK initialized for {config.environment} environment")
+
+    def _validate_config(self):
+        """Validate SDK configuration."""
+        if not self.config.api_key_id and self.config.environment != "development":
+            raise ConfigurationError(
+                "API key required for non-development environments"
+            )
+
+        if self.config.trading.enable_live_trading and not self.config.api_secret:
+            raise ConfigurationError("API secret required for live trading")
+
+    @classmethod
+    def from_env(cls, prefix: str = "NEURAL_") -> "NeuralSDK":
+        """
+        Create SDK instance from environment variables.
+
+        Args:
+            prefix: Environment variable prefix
+
+        Returns:
+            Configured SDK instance
+        """
+        config = SDKConfig.from_env(prefix)
+        return cls(config)
+
+    @classmethod
+    def from_config_file(cls, file_path: str) -> "NeuralSDK":
+        """
+        Create SDK instance from configuration file.
+
+        Args:
+            file_path: Path to YAML configuration file
+
+        Returns:
+            Configured SDK instance
+        """
+        config = SDKConfig.from_file(file_path)
+        return cls(config)
+
+    def create_signal(
+        self,
+        action: str,
+        market_ticker: str,
+        side: str = "YES",
+        confidence: float = 0.5,
+        quantity: Optional[int] = None,
+        price_limit: Optional[float] = None,
+        reason: Optional[str] = None,
+        **metadata,
+    ) -> TradingSignal:
+        """
+        Create a trading signal.
+
+        Args:
+            action: Trading action ("BUY", "SELL", "HOLD")
+            market_ticker: Market ticker symbol
+            side: Market side ("YES" or "NO")
+            confidence: Signal confidence (0.0 to 1.0)
+            quantity: Order quantity
+            price_limit: Price limit for the order
+            reason: Reason for the signal
+            **metadata: Additional metadata
+
+        Returns:
+            TradingSignal object
+        """
+        if quantity is None:
+            quantity = self.config.trading.default_quantity
+
+        return TradingSignal(
+            action=action,
+            market_ticker=market_ticker,
+            side=side,
+            confidence=confidence,
+            quantity=quantity,
+            price_limit=price_limit,
+            reason=reason,
+            metadata=metadata or {},
+        )
+
+    def strategy(self, func: Callable) -> Callable:
+        """
+        Decorator to register a trading strategy.
+
+        Args:
+            func: Strategy function that takes market data and returns signals
+
+        Returns:
+            Decorated strategy function
+
+        Example:
+            ```python
+            @sdk.strategy
+            async def arbitrage_strategy(market_data):
+                if market_data.yes_price + market_data.no_price < 0.98:
+                    return sdk.create_signal("BUY", market_data.ticker)
+            ```
+        """
+        strategy_name = func.__name__
+        self._strategies[strategy_name] = func
+
+        logger.info(f"Registered strategy: {strategy_name}")
+        return func
+
+    def on_market_data(self, func: Callable) -> Callable:
+        """
+        Decorator to register market data handler.
+
+        Args:
+            func: Handler function that processes market data
+
+        Returns:
+            Decorated handler function
+        """
+        self._market_data_handlers.append(func)
+        return func
+
+    def on_signal(self, func: Callable) -> Callable:
+        """
+        Decorator to register signal handler.
+
+        Args:
+            func: Handler function that processes trading signals
+
+        Returns:
+            Decorated handler function
+        """
+        self._signal_handlers.append(func)
+        return func
+
+    def on_trade(self, func: Callable) -> Callable:
+        """
+        Decorator to register trade handler.
+
+        Args:
+            func: Handler function that processes trade results
+
+        Returns:
+            Decorated handler function
+        """
+        self._trade_handlers.append(func)
+        return func
+
+    async def start_trading_system(self) -> None:
+        """
+        Start the complete trading system.
+
+        This initializes all components:
+        - Data sources and streaming
+        - Agent orchestration
+        - Strategy execution
+        - Risk management
+        - Monitoring
+
+        Raises:
+            SDKError: If system fails to start
+        """
+        if self._is_running:
+            logger.warning("Trading system already running")
+            return
+
+        try:
+            logger.info("Starting Neural Trading System...")
+
+            # Initialize core components
+            await self._initialize_data_sources()
+            await self._initialize_agents()
+            await self._initialize_monitoring()
+
+            self._is_running = True
+            logger.info("✅ Neural Trading System started successfully")
+
+            # Start main event loop
+            await self._run_trading_loop()
+
+        except Exception as e:
+            logger.error(f"Failed to start trading system: {e}")
+            await self.stop_trading_system()
+            raise SDKError(f"Failed to start trading system: {e}") from e
+
+    async def stop_trading_system(self) -> None:
+        """
+        Stop the trading system gracefully.
+
+        This shuts down all components in the correct order.
+        """
+        if not self._is_running:
+            return
+
+        logger.info("Stopping Neural Trading System...")
+
+        try:
+            # Stop components in reverse order
+            await self._shutdown_monitoring()
+            await self._shutdown_agents()
+            await self._shutdown_data_sources()
+
+            self._is_running = False
+            logger.info("✅ Neural Trading System stopped")
+
+        except Exception as e:
+            logger.error(f"Error during shutdown: {e}")
+            raise SDKError(f"Error during system shutdown: {e}") from e
+
+    async def _initialize_data_sources(self) -> None:
+        """Initialize data sources and streaming."""
+        logger.info("Initializing data sources...")
+
+        # Initialize Redis connection for pub/sub
+        # Initialize market data streams
+        # Initialize ESPN data streams
+        # Initialize other data sources based on config
+
+        logger.info("✅ Data sources initialized")
+
+    async def _initialize_agents(self) -> None:
+        """Initialize and start agents."""
+        logger.info("Initializing agents...")
+
+        # TODO: Initialize trading agents if using agent-based architecture
+        # This is optional - the SDK can work without agents using just strategies
+        # 
+        # Example agent initialization:
+        # self._agents['data_coordinator'] = DataCoordinatorAgent(self.config)
+        # self._agents['portfolio_monitor'] = PortfolioMonitorAgent(self.config)
+        # self._agents['risk_manager'] = RiskManagerAgent(self.config)
+        # 
+        # for name, agent in self._agents.items():
+        #     await agent.start()
+        #     logger.info(f"Started {name} agent")
+
+        logger.info("✅ Agents initialized (using strategy-based approach)")
+
+    async def _initialize_monitoring(self) -> None:
+        """Initialize monitoring and metrics."""
+        if self.config.enable_monitoring:
+            logger.info("Initializing monitoring...")
+
+            # Initialize metrics collection
+            # Initialize health checks
+            # Initialize logging
+
+            logger.info("✅ Monitoring initialized")
+
+    async def _shutdown_data_sources(self) -> None:
+        """Shutdown data sources."""
+        logger.info("Shutting down data sources...")
+
+        # Close all data source connections
+        # Stop streaming threads/tasks
+
+        logger.info("✅ Data sources shut down")
+
+    async def _shutdown_agents(self) -> None:
+        """Shutdown agents."""
+        logger.info("Shutting down agents...")
+
+        # Stop all agents
+        # Close agent connections
+
+        logger.info("✅ Agents shut down")
+
+    async def _shutdown_monitoring(self) -> None:
+        """Shutdown monitoring."""
+        if self.config.enable_monitoring:
+            logger.info("Shutting down monitoring...")
+
+            # Stop metrics collection
+            # Close monitoring connections
+
+            logger.info("✅ Monitoring shut down")
+
+    async def _run_trading_loop(self) -> None:
+        """Main trading system event loop."""
+        logger.info("Starting trading event loop...")
+
+        try:
+            while self._is_running:
+                # Process market data
+                await self._process_market_data()
+
+                # Execute strategies
+                await self._execute_strategies()
+
+                # Process signals
+                await self._process_signals()
+
+                # Monitor portfolio
+                await self._monitor_portfolio()
+
+                # Brief pause to prevent busy waiting
+                await asyncio.sleep(0.1)
+
+        except asyncio.CancelledError:
+            logger.info("Trading loop cancelled")
+            raise
+        except Exception as e:
+            logger.error(f"Error in trading loop: {e}")
+            raise
+
+    async def _process_market_data(self) -> None:
+        """Process incoming market data."""
+        # Get market data from sources
+        # Call market data handlers
+        # Update internal market data cache
+
+        for handler in self._market_data_handlers:
+            try:
+                # Call handler with market data
+                pass
+            except Exception as e:
+                logger.error(f"Error in market data handler: {e}")
+
+    async def _execute_strategies(self) -> None:
+        """Execute registered trading strategies."""
+        # Get current market data
+        # Execute each strategy
+        # Collect generated signals
+
+        for strategy_name, strategy_func in self._strategies.items():
+            try:
+                # Execute strategy and collect signals
+                pass
+            except Exception as e:
+                logger.error(f"Error executing strategy {strategy_name}: {e}")
+
+    async def _process_signals(self) -> None:
+        """Process trading signals."""
+        # Validate signals
+        # Apply risk management
+        # Execute trades if approved
+        # Call signal handlers
+
+        for handler in self._signal_handlers:
+            try:
+                # Call handler with signals
+                pass
+            except Exception as e:
+                logger.error(f"Error in signal handler: {e}")
+
+    async def _monitor_portfolio(self) -> None:
+        """Monitor portfolio and risk metrics."""
+        # Update portfolio positions
+        # Check risk limits
+        # Generate risk alerts if needed
+        # Update performance metrics
+
+        pass
+
+    async def get_market_data(self, ticker: str) -> Optional[MarketData]:
+        """
+        Get current market data for a specific ticker.
+
+        Args:
+            ticker: Market ticker symbol
+
+        Returns:
+            MarketData object or None if not found
+        """
+        # TODO: Implement market data fetching from data sources
+        # This should query the unified stream manager or Kalshi client
+        # Example implementation:
+        # if self.stream_manager:
+        #     return await self.stream_manager.get_market_context(ticker)
+        # return None
+        return None  # Placeholder - implement in your integration
+
+    async def execute_signal(self, signal: TradingSignal) -> TradeResult:
+        """
+        Execute a trading signal.
+
+        Args:
+            signal: Trading signal to execute
+
+        Returns:
+            TradeResult with execution details
+
+        Raises:
+            TradingError: If trade execution fails
+        """
+        # TODO: Implement trade execution
+        # This should:
+        # 1. Validate signal against risk limits
+        # 2. Check available capital
+        # 3. Execute trade via Kalshi API
+        # 4. Return TradeResult with execution details
+        #
+        # Example implementation:
+        # if self.config.trading.enable_paper_trading:
+        #     return await self._execute_paper_trade(signal)
+        # else:
+        #     return await self._execute_live_trade(signal)
+        
+        raise NotImplementedError("Trade execution not yet implemented - override in your implementation")
+
+    async def get_portfolio_status(self) -> Dict[str, Any]:
+        """
+        Get current portfolio status and metrics.
+
+        Returns:
+            Dictionary with portfolio information
+        """
+        return {
+            "total_value": 0.0,
+            "cash_balance": 0.0,
+            "positions": [],
+            "daily_pnl": 0.0,
+            "total_pnl": 0.0,
+            "risk_metrics": {},
+        }
+
+    def get_system_status(self) -> Dict[str, Any]:
+        """
+        Get overall system status.
+
+        Returns:
+            Dictionary with system status information
+        """
+        return {
+            "is_running": self._is_running,
+            "environment": self.config.environment,
+            "data_sources_connected": len(self._data_sources),
+            "agents_active": len(self._agents),
+            "strategies_loaded": len(self._strategies),
+            "last_update": datetime.utcnow().isoformat(),
+        }
+
+    async def health_check(self) -> Dict[str, Any]:
+        """
+        Perform comprehensive health check.
+
+        Returns:
+            Dictionary with health check results
+        """
+        health = {
+            "overall": "healthy",
+            "components": {},
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+
+        # Check data sources
+        health["components"]["data_sources"] = "healthy"  # Placeholder
+
+        # Check agents
+        health["components"]["agents"] = "healthy"  # Placeholder
+
+        # Check trading
+        health["components"]["trading"] = "healthy"  # Placeholder
+
+        # Determine overall health
+        component_statuses = health["components"].values()
+        if "unhealthy" in component_statuses:
+            health["overall"] = "unhealthy"
+        elif "degraded" in component_statuses:
+            health["overall"] = "degraded"
+
+        return health
+
+    def __repr__(self) -> str:
+        """String representation of the SDK."""
+        return f"NeuralSDK(environment={self.config.environment}, running={self._is_running})"
diff --git a/neural_sdk/core/config.py b/neural_sdk/core/config.py
new file mode 100644
index 00000000..99d8bc64
--- /dev/null
+++ b/neural_sdk/core/config.py
@@ -0,0 +1,425 @@
+"""
+Configuration management for the Neural SDK.
+
+This module provides configuration classes and utilities for managing
+SDK settings, environment variables, and validation.
+"""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from .exceptions import ConfigurationError, ValidationError
+
+
+@dataclass
+class RiskLimits:
+    """Risk management limits and thresholds."""
+
+    max_position_size_pct: float = 0.05  # Max 5% of portfolio per position
+    max_daily_loss_pct: float = 0.20  # Max 20% daily loss
+    max_correlation: float = 0.7  # Max correlation between positions
+    stop_loss_pct: float = 0.10  # Default 10% stop-loss
+    take_profit_pct: float = 0.30  # Default 30% take-profit
+    kelly_fraction: float = 0.25  # Use 25% of Kelly criterion
+
+    def __post_init__(self):
+        """Validate risk limits."""
+        if not 0 < self.max_position_size_pct <= 1:
+            raise ValidationError(
+                f"max_position_size_pct must be between 0 and 1, got {self.max_position_size_pct}"
+            )
+        if not 0 < self.max_daily_loss_pct <= 1:
+            raise ValidationError(
+                f"max_daily_loss_pct must be between 0 and 1, got {self.max_daily_loss_pct}"
+            )
+        if not -1 <= self.max_correlation <= 1:
+            raise ValidationError(
+                f"max_correlation must be between -1 and 1, got {self.max_correlation}"
+            )
+        if not 0 < self.kelly_fraction <= 1:
+            raise ValidationError(
+                f"kelly_fraction must be between 0 and 1, got {self.kelly_fraction}"
+            )
+
+
+@dataclass
+class TradingConfig:
+    """Trading-specific configuration."""
+
+    default_quantity: int = 100
+    max_order_size: int = 1000
+    min_order_size: int = 10
+    enable_paper_trading: bool = True
+    enable_live_trading: bool = False
+    auto_cancel_stale_orders: bool = True
+    stale_order_timeout_seconds: int = 300  # 5 minutes
+
+
+@dataclass
+class DataConfig:
+    """Data source configuration."""
+
+    redis_url: str = "redis://localhost:6379"
+    enable_stream: bool = True
+    enable_espn_stream: bool = True
+    enable_twitter_stream: bool = False
+    enable_weather_stream: bool = False
+    stream_buffer_size: int = 1000
+    data_retention_days: int = 30
+
+
+@dataclass
+class LoggingConfig:
+    """Logging configuration."""
+
+    level: str = "INFO"
+    format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    enable_file_logging: bool = False
+    log_file_path: Optional[str] = None
+    enable_structured_logging: bool = True
+    log_performance_metrics: bool = True
+
+
+@dataclass
+class SDKConfig:
+    """
+    Main configuration class for the Neural SDK.
+
+    This class centralizes all configuration options and provides
+    validation and environment variable loading.
+    """
+
+    # API Credentials
+    api_key_id: Optional[str] = None
+    api_secret: Optional[str] = None
+
+    # Core Settings
+    environment: str = "development"  # development, staging, production
+    log_level: str = "INFO"
+
+    # Component Configurations
+    risk_limits: RiskLimits = field(default_factory=RiskLimits)
+    trading: TradingConfig = field(default_factory=TradingConfig)
+    data: DataConfig = field(default_factory=DataConfig)
+    logging: LoggingConfig = field(default_factory=LoggingConfig)
+
+    # Advanced Settings
+    enable_monitoring: bool = True
+    enable_metrics: bool = True
+    enable_debug_mode: bool = False
+    config_file_path: Optional[str] = None
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        self._validate_configuration()
+
+    def _validate_configuration(self):
+        """Validate the entire configuration."""
+        valid_environments = ["development", "staging", "production"]
+        if self.environment not in valid_environments:
+            raise ConfigurationError(
+                f"Invalid environment '{self.environment}'. Must be one of: {valid_environments}"
+            )
+
+        # Validate API credentials for non-development environments
+        if self.environment != "development":
+            if not self.api_key_id or not self.api_secret:
+                raise ConfigurationError(
+                    "API credentials required for non-development environments"
+                )
+
+        # Validate trading configuration
+        if self.trading.max_order_size < self.trading.min_order_size:
+            raise ConfigurationError(
+                "max_order_size must be greater than min_order_size"
+            )
+
+    @classmethod
+    def from_env(cls, prefix: str = "KALSHI_") -> "SDKConfig":
+        """
+        Create configuration from environment variables.
+
+        Args:
+            prefix: Environment variable prefix (default: "KALSHI_")
+
+        Returns:
+            SDKConfig instance with values from environment
+
+        Example:
+            >>> config = SDKConfig.from_env()
+            >>> # Reads KALSHI_KALSHI_API_KEY_ID, etc.
+        """
+        env_data = {}
+
+        # API Credentials
+        env_data["api_key_id"] = os.getenv(f"{prefix}API_KEY_ID")
+        env_data["api_secret"] = os.getenv(f"{prefix}API_SECRET")
+
+        # Core Settings
+        env_data["environment"] = os.getenv(f"{prefix}ENVIRONMENT", "development")
+        env_data["log_level"] = os.getenv(f"{prefix}LOG_LEVEL", "INFO")
+
+        # Risk Limits
+        risk_limits = {}
+        risk_limits["max_position_size_pct"] = float(
+            os.getenv(f"{prefix}MAX_POSITION_SIZE_PCT", "0.05")
+        )
+        risk_limits["max_daily_loss_pct"] = float(
+            os.getenv(f"{prefix}MAX_DAILY_LOSS_PCT", "0.20")
+        )
+        risk_limits["max_correlation"] = float(
+            os.getenv(f"{prefix}MAX_CORRELATION", "0.7")
+        )
+        risk_limits["stop_loss_pct"] = float(
+            os.getenv(f"{prefix}STOP_LOSS_PCT", "0.10")
+        )
+        risk_limits["take_profit_pct"] = float(
+            os.getenv(f"{prefix}TAKE_PROFIT_PCT", "0.30")
+        )
+        risk_limits["kelly_fraction"] = float(
+            os.getenv(f"{prefix}KELLY_FRACTION", "0.25")
+        )
+        env_data["risk_limits"] = RiskLimits(**risk_limits)
+
+        # Data Configuration
+        data_config = {}
+        data_config["redis_url"] = os.getenv(
+            f"{prefix}REDIS_URL", "redis://localhost:6379"
+        )
+        data_config["enable_stream"] = (
+            os.getenv(f"{prefix}ENABLE_STREAM", "true").lower() == "true"
+        )
+        data_config["enable_espn_stream"] = (
+            os.getenv(f"{prefix}ENABLE_ESPN_STREAM", "true").lower() == "true"
+        )
+        data_config["enable_twitter_stream"] = (
+            os.getenv(f"{prefix}ENABLE_TWITTER_STREAM", "false").lower() == "true"
+        )
+        data_config["enable_weather_stream"] = (
+            os.getenv(f"{prefix}ENABLE_WEATHER_STREAM", "false").lower() == "true"
+        )
+        data_config["stream_buffer_size"] = int(
+            os.getenv(f"{prefix}STREAM_BUFFER_SIZE", "1000")
+        )
+        data_config["data_retention_days"] = int(
+            os.getenv(f"{prefix}DATA_RETENTION_DAYS", "30")
+        )
+        env_data["data"] = DataConfig(**data_config)
+
+        # Trading Configuration
+        trading_config = {}
+        trading_config["default_quantity"] = int(
+            os.getenv(f"{prefix}DEFAULT_QUANTITY", "100")
+        )
+        trading_config["max_order_size"] = int(
+            os.getenv(f"{prefix}MAX_ORDER_SIZE", "1000")
+        )
+        trading_config["min_order_size"] = int(
+            os.getenv(f"{prefix}MIN_ORDER_SIZE", "10")
+        )
+        trading_config["enable_paper_trading"] = (
+            os.getenv(f"{prefix}ENABLE_PAPER_TRADING", "true").lower() == "true"
+        )
+        trading_config["enable_live_trading"] = (
+            os.getenv(f"{prefix}ENABLE_LIVE_TRADING", "false").lower() == "true"
+        )
+        trading_config["auto_cancel_stale_orders"] = (
+            os.getenv(f"{prefix}AUTO_CANCEL_STALE_ORDERS", "true").lower() == "true"
+        )
+        trading_config["stale_order_timeout_seconds"] = int(
+            os.getenv(f"{prefix}STALE_ORDER_TIMEOUT", "300")
+        )
+        env_data["trading"] = TradingConfig(**trading_config)
+
+        # Logging Configuration
+        logging_config = {}
+        logging_config["level"] = os.getenv(f"{prefix}LOG_LEVEL", "INFO")
+        logging_config["enable_file_logging"] = (
+            os.getenv(f"{prefix}ENABLE_FILE_LOGGING", "false").lower() == "true"
+        )
+        logging_config["log_file_path"] = os.getenv(f"{prefix}LOG_FILE_PATH")
+        logging_config["enable_structured_logging"] = (
+            os.getenv(f"{prefix}ENABLE_STRUCTURED_LOGGING", "true").lower() == "true"
+        )
+        logging_config["log_performance_metrics"] = (
+            os.getenv(f"{prefix}LOG_PERFORMANCE_METRICS", "true").lower() == "true"
+        )
+        env_data["logging"] = LoggingConfig(**logging_config)
+
+        # Advanced Settings
+        env_data["enable_monitoring"] = (
+            os.getenv(f"{prefix}ENABLE_MONITORING", "true").lower() == "true"
+        )
+        env_data["enable_metrics"] = (
+            os.getenv(f"{prefix}ENABLE_METRICS", "true").lower() == "true"
+        )
+        env_data["enable_debug_mode"] = (
+            os.getenv(f"{prefix}ENABLE_DEBUG_MODE", "false").lower() == "true"
+        )
+        env_data["config_file_path"] = os.getenv(f"{prefix}CONFIG_FILE_PATH")
+
+        return cls(**env_data)
+
+    @classmethod
+    def from_file(cls, file_path: str) -> "SDKConfig":
+        """
+        Create configuration from a YAML file.
+
+        Args:
+            file_path: Path to YAML configuration file
+
+        Returns:
+            SDKConfig instance with values from file
+        """
+        try:
+            import yaml
+        except ImportError:
+            raise ConfigurationError(
+                "PyYAML is required for file-based configuration. Install with: pip install PyYAML"
+            )
+
+        path = Path(file_path)
+        if not path.exists():
+            raise ConfigurationError(f"Configuration file not found: {file_path}")
+
+        try:
+            with open(path, "r") as f:
+                data = yaml.safe_load(f)
+        except Exception as e:
+            raise ConfigurationError(f"Failed to parse configuration file: {e}")
+
+        return cls.from_dict(data)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SDKConfig":
+        """
+        Create configuration from a dictionary.
+
+        Args:
+            data: Configuration dictionary
+
+        Returns:
+            SDKConfig instance
+        """
+        # Handle nested configurations
+        if "risk_limits" in data:
+            data["risk_limits"] = RiskLimits(**data["risk_limits"])
+        if "trading" in data:
+            data["trading"] = TradingConfig(**data["trading"])
+        if "data" in data:
+            data["data"] = DataConfig(**data["data"])
+        if "logging" in data:
+            data["logging"] = LoggingConfig(**data["logging"])
+
+        return cls(**data)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to dictionary."""
+        return {
+            "api_key_id": self.api_key_id,
+            "api_secret": self.api_secret,
+            "environment": self.environment,
+            "log_level": self.log_level,
+            "risk_limits": {
+                "max_position_size_pct": self.risk_limits.max_position_size_pct,
+                "max_daily_loss_pct": self.risk_limits.max_daily_loss_pct,
+                "max_correlation": self.risk_limits.max_correlation,
+                "stop_loss_pct": self.risk_limits.stop_loss_pct,
+                "take_profit_pct": self.risk_limits.take_profit_pct,
+                "kelly_fraction": self.risk_limits.kelly_fraction,
+            },
+            "trading": {
+                "default_quantity": self.trading.default_quantity,
+                "max_order_size": self.trading.max_order_size,
+                "min_order_size": self.trading.min_order_size,
+                "enable_paper_trading": self.trading.enable_paper_trading,
+                "enable_live_trading": self.trading.enable_live_trading,
+                "auto_cancel_stale_orders": self.trading.auto_cancel_stale_orders,
+                "stale_order_timeout_seconds": self.trading.stale_order_timeout_seconds,
+            },
+            "data": {
+                "redis_url": self.data.redis_url,
+                "enable_stream": self.data.enable_stream,
+                "enable_espn_stream": self.data.enable_espn_stream,
+                "enable_twitter_stream": self.data.enable_twitter_stream,
+                "enable_weather_stream": self.data.enable_weather_stream,
+                "stream_buffer_size": self.data.stream_buffer_size,
+                "data_retention_days": self.data.data_retention_days,
+            },
+            "logging": {
+                "level": self.logging.level,
+                "format": self.logging.format,
+                "enable_file_logging": self.logging.enable_file_logging,
+                "log_file_path": self.logging.log_file_path,
+                "enable_structured_logging": self.logging.enable_structured_logging,
+                "log_performance_metrics": self.logging.log_performance_metrics,
+            },
+            "enable_monitoring": self.enable_monitoring,
+            "enable_metrics": self.enable_metrics,
+            "enable_debug_mode": self.enable_debug_mode,
+            "config_file_path": self.config_file_path,
+        }
+
+    def save_to_file(self, file_path: str):
+        """Save configuration to a YAML file."""
+        try:
+            import yaml
+        except ImportError:
+            raise ConfigurationError(
+                "PyYAML is required to save configuration. Install with: pip install PyYAML"
+            )
+
+        path = Path(file_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            with open(path, "w") as f:
+                yaml.dump(self.to_dict(), f, default_flow_style=False, sort_keys=False)
+        except Exception as e:
+            raise ConfigurationError(f"Failed to save configuration file: {e}")
+
+    def is_production_ready(self) -> bool:
+        """
+        Check if configuration is ready for production use.
+
+        Returns:
+            True if configuration is production-ready
+        """
+        checks = [
+            self.api_key_id is not None,
+            self.api_secret is not None,
+            self.environment == "production",
+            self.trading.enable_live_trading,
+            not self.enable_debug_mode,
+        ]
+        return all(checks)
+
+    def get_summary(self) -> str:
+        """Get a human-readable summary of the configuration."""
+        return f"""
+Neural SDK Configuration
+================================
+Environment: {self.environment}
+Log Level: {self.log_level}
+
+API Credentials: {'✅ Configured' if self.api_key_id else '❌ Missing'}
+
+Risk Limits:
+  - Max Position Size: {self.risk_limits.max_position_size_pct:.1%}
+  - Max Daily Loss: {self.risk_limits.max_daily_loss_pct:.1%}
+  - Kelly Fraction: {self.risk_limits.kelly_fraction:.1%}
+
+Trading:
+  - Paper Trading: {'✅ Enabled' if self.trading.enable_paper_trading else '❌ Disabled'}
+  - Live Trading: {'✅ Enabled' if self.trading.enable_live_trading else '❌ Disabled'}
+  - Default Quantity: {self.trading.default_quantity}
+
+Data Sources:
+  - Redis: {self.data.redis_url}
+  - Stream: {'✅ Enabled' if self.data.enable_stream else '❌ Disabled'}
+  - ESPN Stream: {'✅ Enabled' if self.data.enable_espn_stream else '❌ Disabled'}
+
+Production Ready: {'✅ Yes' if self.is_production_ready() else '❌ No'}
+        """.strip()
diff --git a/neural_sdk/core/environment_guards.py b/neural_sdk/core/environment_guards.py
new file mode 100644
index 00000000..a442c203
--- /dev/null
+++ b/neural_sdk/core/environment_guards.py
@@ -0,0 +1,589 @@
+"""
+Environment Guards
+
+Safety mechanisms and validation for environment operations.
+"""
+
+import asyncio
+import hashlib
+import json
+import os
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from .environment_manager import Environment, EnvironmentGuard
+
+
+class OperationType(Enum):
+    """Types of operations that can be guarded."""
+
+    TRADE_EXECUTION = "trade_execution"
+    DATA_DELETION = "data_deletion"
+    CONFIG_MODIFICATION = "config_modification"
+    API_CALL = "api_call"
+    DATABASE_WRITE = "database_write"
+    DATABASE_READ = "database_read"
+    MODEL_TRAINING = "model_training"
+    SYSTEM_RESTART = "system_restart"
+    EMERGENCY_STOP = "emergency_stop"
+
+
+@dataclass
+class GuardPolicy:
+    """Policy for environment guards."""
+
+    operation_type: OperationType
+    allowed_environments: List[Environment]
+    require_confirmation: bool
+    require_mfa: bool
+    cooldown_seconds: int
+    max_daily_count: int
+    audit_log: bool
+
+    def is_allowed_in(self, environment: Environment) -> bool:
+        """Check if operation is allowed in environment."""
+        return environment in self.allowed_environments
+
+
+class RateLimitGuard(EnvironmentGuard):
+    """Guard that enforces rate limits on operations."""
+
+    def __init__(self, default_limit: int = 100):
+        """Initialize rate limit guard."""
+        self.default_limit = default_limit
+        self.operation_counts: Dict[str, Dict[str, int]] = defaultdict(
+            lambda: defaultdict(int)
+        )
+        self.operation_times: Dict[str, List[datetime]] = defaultdict(list)
+        self.limits: Dict[Tuple[Environment, str], int] = {}
+
+    def set_limit(self, environment: Environment, operation: str, limit: int) -> None:
+        """Set rate limit for operation in environment."""
+        self.limits[(environment, operation)] = limit
+
+    async def check_operation(
+        self, operation: str, environment: Environment
+    ) -> Tuple[bool, str]:
+        """Check if operation is within rate limits."""
+        # Get limit for this operation
+        limit = self.limits.get((environment, operation), self.default_limit)
+
+        # Clean old entries (older than 1 hour)
+        now = datetime.now()
+        cutoff = now - timedelta(hours=1)
+
+        if operation in self.operation_times:
+            self.operation_times[operation] = [
+                t for t in self.operation_times[operation] if t > cutoff
+            ]
+
+        # Check current count
+        current_count = len(self.operation_times[operation])
+
+        if current_count >= limit:
+            return (
+                False,
+                f"Rate limit exceeded: {current_count}/{limit} operations in last hour",
+            )
+
+        # Record operation
+        self.operation_times[operation].append(now)
+
+        return True, f"Operation allowed: {current_count + 1}/{limit}"
+
+    async def check_switch(
+        self, from_env: Environment, to_env: Environment
+    ) -> Tuple[bool, str]:
+        """Check if environment switch is allowed."""
+        # Always allow switching for rate limit guard
+        return True, "Switch allowed"
+
+
+class DataIntegrityGuard(EnvironmentGuard):
+    """Guard that ensures data integrity across environments."""
+
+    def __init__(self):
+        """Initialize data integrity guard."""
+        self.data_checksums: Dict[Environment, Dict[str, str]] = defaultdict(dict)
+        self.migration_history: List[Dict[str, Any]] = []
+
+    async def check_switch(
+        self, from_env: Environment, to_env: Environment
+    ) -> Tuple[bool, str]:
+        """Check if environment switch maintains data integrity."""
+        # Don't allow direct switch from training to production
+        if from_env == Environment.TRAINING and to_env == Environment.PRODUCTION:
+            return (
+                False,
+                "Direct switch from training to production not allowed. Use staging first.",
+            )
+
+        # Warn about data loss when switching from production
+        if from_env == Environment.PRODUCTION and to_env != Environment.STAGING:
+            print("\n⚠️  WARNING: Switching from production may result in data loss.")
+            confirm = input("Type 'ACKNOWLEDGE' to continue: ")
+            if confirm != "ACKNOWLEDGE":
+                return False, "Switch cancelled - data loss not acknowledged"
+
+        return True, "Data integrity check passed"
+
+    async def check_operation(
+        self, operation: str, environment: Environment
+    ) -> Tuple[bool, str]:
+        """Check if operation maintains data integrity."""
+        # Prevent data deletion in production
+        if environment == Environment.PRODUCTION and "delete" in operation.lower():
+            return False, "Data deletion operations not allowed in production"
+
+        return True, "Operation allowed"
+
+    def record_checksum(
+        self, environment: Environment, data_type: str, data: str
+    ) -> str:
+        """Record checksum for data integrity tracking."""
+        checksum = hashlib.sha256(data.encode()).hexdigest()
+        self.data_checksums[environment][data_type] = checksum
+        return checksum
+
+    def verify_checksum(
+        self, environment: Environment, data_type: str, data: str
+    ) -> bool:
+        """Verify data checksum."""
+        expected = self.data_checksums[environment].get(data_type)
+        if not expected:
+            return True  # No checksum recorded
+
+        actual = hashlib.sha256(data.encode()).hexdigest()
+        return actual == expected
+
+
+class ComplianceGuard(EnvironmentGuard):
+    """Guard that ensures regulatory compliance."""
+
+    def __init__(self):
+        """Initialize compliance guard."""
+        self.audit_log: List[Dict[str, Any]] = []
+        self.compliance_rules: Dict[str, GuardPolicy] = {}
+        self._setup_default_rules()
+
+    def _setup_default_rules(self) -> None:
+        """Setup default compliance rules."""
+        # Trading must be audited in production
+        self.compliance_rules["trade_execution"] = GuardPolicy(
+            operation_type=OperationType.TRADE_EXECUTION,
+            allowed_environments=list(Environment),
+            require_confirmation=True,
+            require_mfa=True,
+            cooldown_seconds=1,
+            max_daily_count=100,
+            audit_log=True,
+        )
+
+        # Data deletion requires special permission
+        self.compliance_rules["data_deletion"] = GuardPolicy(
+            operation_type=OperationType.DATA_DELETION,
+            allowed_environments=[
+                Environment.DEVELOPMENT,
+                Environment.TRAINING,
+                Environment.SANDBOX,
+            ],
+            require_confirmation=True,
+            require_mfa=False,
+            cooldown_seconds=60,
+            max_daily_count=10,
+            audit_log=True,
+        )
+
+    async def check_operation(
+        self, operation: str, environment: Environment
+    ) -> Tuple[bool, str]:
+        """Check if operation is compliant."""
+        # Check if operation has compliance rules
+        if operation in self.compliance_rules:
+            policy = self.compliance_rules[operation]
+
+            if not policy.is_allowed_in(environment):
+                self._audit(operation, environment, False, "Environment not allowed")
+                return (
+                    False,
+                    f"Operation '{operation}' not allowed in {environment.value}",
+                )
+
+            # Audit if required
+            if policy.audit_log:
+                self._audit(operation, environment, True, "Operation allowed")
+
+        return True, "Compliance check passed"
+
+    async def check_switch(
+        self, from_env: Environment, to_env: Environment
+    ) -> Tuple[bool, str]:
+        """Check if environment switch is compliant."""
+        # Audit all environment switches
+        self._audit(
+            f"switch_{from_env.value}_to_{to_env.value}",
+            to_env,
+            True,
+            "Environment switch",
+        )
+
+        return True, "Switch compliant"
+
+    def _audit(
+        self, operation: str, environment: Environment, allowed: bool, reason: str
+    ) -> None:
+        """Add entry to audit log."""
+        self.audit_log.append(
+            {
+                "timestamp": datetime.now().isoformat(),
+                "operation": operation,
+                "environment": environment.value,
+                "allowed": allowed,
+                "reason": reason,
+                "user": os.getenv("USER", "unknown"),
+            }
+        )
+
+    def get_audit_log(
+        self, start_time: Optional[datetime] = None, end_time: Optional[datetime] = None
+    ) -> List[Dict[str, Any]]:
+        """Get audit log entries."""
+        if not start_time and not end_time:
+            return self.audit_log
+
+        filtered = []
+        for entry in self.audit_log:
+            entry_time = datetime.fromisoformat(entry["timestamp"])
+
+            if start_time and entry_time < start_time:
+                continue
+            if end_time and entry_time > end_time:
+                continue
+
+            filtered.append(entry)
+
+        return filtered
+
+
+class ResourceGuard(EnvironmentGuard):
+    """Guard that monitors and limits resource usage."""
+
+    def __init__(self):
+        """Initialize resource guard."""
+        self.resource_limits: Dict[Environment, Dict[str, float]] = {
+            Environment.PRODUCTION: {
+                "memory_gb": 4.0,
+                "cpu_percent": 80.0,
+                "disk_gb": 100.0,
+                "connections": 100,
+            },
+            Environment.STAGING: {
+                "memory_gb": 8.0,
+                "cpu_percent": 90.0,
+                "disk_gb": 200.0,
+                "connections": 200,
+            },
+            Environment.SANDBOX: {
+                "memory_gb": 4.0,
+                "cpu_percent": 90.0,
+                "disk_gb": 50.0,
+                "connections": 50,
+            },
+            Environment.TRAINING: {
+                "memory_gb": 16.0,
+                "cpu_percent": 95.0,
+                "disk_gb": 500.0,
+                "connections": 500,
+            },
+            Environment.DEVELOPMENT: {
+                "memory_gb": 32.0,
+                "cpu_percent": 100.0,
+                "disk_gb": 1000.0,
+                "connections": 1000,
+            },
+        }
+        self.current_usage: Dict[str, float] = defaultdict(float)
+
+    async def check_operation(
+        self, operation: str, environment: Environment
+    ) -> Tuple[bool, str]:
+        """Check if operation can proceed given resource constraints."""
+        # Get current resource usage (simplified - in production use psutil)
+        import random
+
+        self.current_usage["memory_gb"] = random.uniform(1, 10)
+        self.current_usage["cpu_percent"] = random.uniform(10, 100)
+
+        limits = self.resource_limits[environment]
+
+        # Check memory
+        if self.current_usage["memory_gb"] > limits["memory_gb"]:
+            return (
+                False,
+                f"Memory limit exceeded: {self.current_usage['memory_gb']:.1f}GB > {limits['memory_gb']}GB",
+            )
+
+        # Check CPU
+        if self.current_usage["cpu_percent"] > limits["cpu_percent"]:
+            return (
+                False,
+                f"CPU limit exceeded: {self.current_usage['cpu_percent']:.1f}% > {limits['cpu_percent']}%",
+            )
+
+        return True, "Resource check passed"
+
+    async def check_switch(
+        self, from_env: Environment, to_env: Environment
+    ) -> Tuple[bool, str]:
+        """Check if environment switch is possible given resources."""
+        # Check if target environment has enough resources
+        target_limits = self.resource_limits[to_env]
+
+        if self.current_usage["memory_gb"] > target_limits["memory_gb"]:
+            return (
+                False,
+                f"Insufficient memory for {to_env.value}: need {self.current_usage['memory_gb']:.1f}GB, limit {target_limits['memory_gb']}GB",
+            )
+
+        return True, "Resources available"
+
+
+class CrossEnvironmentGuard(EnvironmentGuard):
+    """Guard that prevents cross-environment contamination."""
+
+    def __init__(self):
+        """Initialize cross-environment guard."""
+        self.environment_boundaries: Dict[Environment, Set[str]] = {
+            Environment.PRODUCTION: {"prod_db", "prod_api", "prod_redis"},
+            Environment.STAGING: {"staging_db", "staging_api", "staging_redis"},
+            Environment.SANDBOX: {"sandbox_db", "sandbox_api", "sandbox_redis"},
+            Environment.TRAINING: {"training_db", "training_api", "training_redis"},
+            Environment.DEVELOPMENT: {"dev_db", "dev_api", "dev_redis"},
+        }
+        self.active_connections: Dict[str, Environment] = {}
+
+    async def check_operation(
+        self, operation: str, environment: Environment
+    ) -> Tuple[bool, str]:
+        """Check if operation respects environment boundaries."""
+        # Parse operation for resource access
+        resources = self._extract_resources(operation)
+
+        allowed_resources = self.environment_boundaries[environment]
+
+        for resource in resources:
+            # Check if resource belongs to current environment
+            if resource not in allowed_resources:
+                # Check if it belongs to another environment
+                for env, env_resources in self.environment_boundaries.items():
+                    if env != environment and resource in env_resources:
+                        return (
+                            False,
+                            f"Cross-environment access denied: {resource} belongs to {env.value}",
+                        )
+
+        return True, "Environment boundaries respected"
+
+    async def check_switch(
+        self, from_env: Environment, to_env: Environment
+    ) -> Tuple[bool, str]:
+        """Check if environment switch is clean."""
+        # Check for active connections to old environment
+        active_in_old = [
+            conn for conn, env in self.active_connections.items() if env == from_env
+        ]
+
+        if active_in_old:
+            return (
+                False,
+                f"Active connections to {from_env.value}: {', '.join(active_in_old)}",
+            )
+
+        return True, "No active connections to close"
+
+    def _extract_resources(self, operation: str) -> Set[str]:
+        """Extract resource names from operation."""
+        # Simplified extraction - in production use proper parsing
+        resources = set()
+
+        for env_resources in self.environment_boundaries.values():
+            for resource in env_resources:
+                if resource in operation:
+                    resources.add(resource)
+
+        return resources
+
+    def register_connection(self, resource: str, environment: Environment) -> None:
+        """Register active connection to resource."""
+        self.active_connections[resource] = environment
+
+    def unregister_connection(self, resource: str) -> None:
+        """Unregister connection to resource."""
+        self.active_connections.pop(resource, None)
+
+
+class TransitionGuard(EnvironmentGuard):
+    """Guard that manages safe environment transitions."""
+
+    def __init__(self):
+        """Initialize transition guard."""
+        self.transition_rules: Dict[Tuple[Environment, Environment], List[str]] = {
+            # From Dev to others
+            (Environment.DEVELOPMENT, Environment.TRAINING): [],
+            (Environment.DEVELOPMENT, Environment.SANDBOX): ["run_tests"],
+            (Environment.DEVELOPMENT, Environment.STAGING): [
+                "run_tests",
+                "code_review",
+            ],
+            (Environment.DEVELOPMENT, Environment.PRODUCTION): ["forbidden"],
+            # From Training to others
+            (Environment.TRAINING, Environment.DEVELOPMENT): [],
+            (Environment.TRAINING, Environment.SANDBOX): ["save_model"],
+            (Environment.TRAINING, Environment.STAGING): ["validate_model"],
+            (Environment.TRAINING, Environment.PRODUCTION): ["forbidden"],
+            # From Sandbox to others
+            (Environment.SANDBOX, Environment.DEVELOPMENT): [],
+            (Environment.SANDBOX, Environment.TRAINING): [],
+            (Environment.SANDBOX, Environment.STAGING): ["integration_test"],
+            (Environment.SANDBOX, Environment.PRODUCTION): ["forbidden"],
+            # From Staging to others
+            (Environment.STAGING, Environment.DEVELOPMENT): [],
+            (Environment.STAGING, Environment.TRAINING): [],
+            (Environment.STAGING, Environment.SANDBOX): [],
+            (Environment.STAGING, Environment.PRODUCTION): [
+                "approval",
+                "backup",
+                "health_check",
+            ],
+            # From Production to others
+            (Environment.PRODUCTION, Environment.STAGING): ["backup"],
+            (Environment.PRODUCTION, Environment.SANDBOX): ["forbidden"],
+            (Environment.PRODUCTION, Environment.TRAINING): ["forbidden"],
+            (Environment.PRODUCTION, Environment.DEVELOPMENT): ["forbidden"],
+        }
+
+        self.completed_checks: Set[str] = set()
+
+    async def check_switch(
+        self, from_env: Environment, to_env: Environment
+    ) -> Tuple[bool, str]:
+        """Check if environment transition is allowed."""
+        if from_env == to_env:
+            return True, "Same environment"
+
+        # Get transition rules
+        rules = self.transition_rules.get((from_env, to_env), [])
+
+        # Check if transition is forbidden
+        if "forbidden" in rules:
+            return (
+                False,
+                f"Direct transition from {from_env.value} to {to_env.value} is forbidden",
+            )
+
+        # Check if all required checks are completed
+        missing_checks = [
+            check for check in rules if check not in self.completed_checks
+        ]
+
+        if missing_checks:
+            return False, f"Required checks not completed: {', '.join(missing_checks)}"
+
+        # Clear completed checks after successful transition
+        self.completed_checks.clear()
+
+        return True, f"Transition from {from_env.value} to {to_env.value} allowed"
+
+    async def check_operation(
+        self, operation: str, environment: Environment
+    ) -> Tuple[bool, str]:
+        """Check if operation is allowed in current environment."""
+        return True, "Operation allowed"
+
+    def complete_check(self, check_name: str) -> None:
+        """Mark a transition check as completed."""
+        self.completed_checks.add(check_name)
+
+    def get_required_checks(
+        self, from_env: Environment, to_env: Environment
+    ) -> List[str]:
+        """Get list of required checks for transition."""
+        return self.transition_rules.get((from_env, to_env), [])
+
+
+class EmergencyStopGuard(EnvironmentGuard):
+    """Guard that implements emergency stop functionality."""
+
+    def __init__(self):
+        """Initialize emergency stop guard."""
+        self.emergency_active = False
+        self.emergency_reason = ""
+        self.emergency_time: Optional[datetime] = None
+        self.allowed_during_emergency = [
+            "get_status",
+            "cancel_order",
+            "close_position",
+            "emergency_stop",
+        ]
+
+    def activate_emergency_stop(self, reason: str) -> None:
+        """Activate emergency stop."""
+        self.emergency_active = True
+        self.emergency_reason = reason
+        self.emergency_time = datetime.now()
+        print(f"\n🚨 EMERGENCY STOP ACTIVATED: {reason}")
+
+    def deactivate_emergency_stop(self) -> None:
+        """Deactivate emergency stop."""
+        if self.emergency_active:
+            duration = datetime.now() - self.emergency_time
+            print(f"\n✅ Emergency stop deactivated after {duration}")
+
+        self.emergency_active = False
+        self.emergency_reason = ""
+        self.emergency_time = None
+
+    async def check_operation(
+        self, operation: str, environment: Environment
+    ) -> Tuple[bool, str]:
+        """Check if operation is allowed during emergency."""
+        if not self.emergency_active:
+            return True, "No emergency"
+
+        # Only allow specific operations during emergency
+        if operation in self.allowed_during_emergency:
+            return True, f"Operation allowed during emergency: {operation}"
+
+        return False, f"Emergency stop active: {self.emergency_reason}"
+
+    async def check_switch(
+        self, from_env: Environment, to_env: Environment
+    ) -> Tuple[bool, str]:
+        """Check if environment switch is allowed during emergency."""
+        if self.emergency_active:
+            return (
+                False,
+                f"Environment switch blocked: emergency stop active ({self.emergency_reason})",
+            )
+
+        return True, "No emergency"
+
+    def is_emergency(self) -> bool:
+        """Check if emergency stop is active."""
+        return self.emergency_active
+
+    def get_emergency_status(self) -> Dict[str, Any]:
+        """Get emergency stop status."""
+        if not self.emergency_active:
+            return {"active": False}
+
+        return {
+            "active": True,
+            "reason": self.emergency_reason,
+            "start_time": self.emergency_time.isoformat(),
+            "duration": str(datetime.now() - self.emergency_time),
+        }
diff --git a/neural_sdk/core/environment_manager.py b/neural_sdk/core/environment_manager.py
new file mode 100644
index 00000000..421a1543
--- /dev/null
+++ b/neural_sdk/core/environment_manager.py
@@ -0,0 +1,672 @@
+"""
+Environment Manager
+
+Manages environment detection, configuration, and safety mechanisms
+for training/sandbox vs production modes.
+"""
+
+import hashlib
+import json
+import os
+import sys
+import warnings
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import redis.asyncio as redis
+import yaml
+from colorama import Back, Fore, Style, init
+
+# Initialize colorama for cross-platform color support
+init(autoreset=True)
+
+
+class Environment(Enum):
+    """Environment types."""
+
+    DEVELOPMENT = "development"
+    TRAINING = "training"
+    SANDBOX = "sandbox"
+    STAGING = "staging"
+    PRODUCTION = "production"
+
+
+class VisualTheme(Enum):
+    """Visual themes for different environments."""
+
+    DEVELOPMENT = (Fore.CYAN, "🔧")
+    TRAINING = (Fore.YELLOW, "🎓")
+    SANDBOX = (Fore.GREEN, "📦")
+    STAGING = (Fore.MAGENTA, "🚦")
+    PRODUCTION = (Fore.RED, "🔥")
+
+
+@dataclass
+class EnvironmentConfig:
+    """Configuration for a specific environment."""
+
+    name: str
+    environment: Environment
+    redis_db: int
+    redis_prefix: str
+    api_endpoints: Dict[str, str]
+    rate_limits: Dict[str, int]
+    safety_checks: bool
+    require_confirmation: bool
+    require_mfa: bool
+    allowed_operations: List[str]
+    restricted_operations: List[str]
+    data_retention_hours: int
+    max_position_size: float
+    max_daily_trades: int
+    enable_logging: bool
+    log_level: str
+    telemetry_enabled: bool
+    features: Dict[str, bool] = field(default_factory=dict)
+    # Optional fields from YAML
+    backup_enabled: bool = False
+    backup_frequency_hours: int = 0
+    max_concurrent_positions: int = 100
+    max_order_value: float = 10000.0
+    min_order_value: float = 1.0
+    stop_loss_percentage: float = 0.10
+    max_drawdown_percentage: float = 0.20
+    position_sizing_method: str = "kelly_fraction"
+    kelly_fraction: float = 0.25
+    alert_enabled: bool = False
+    alert_channels: List[str] = field(default_factory=list)
+    monitoring: Dict[str, Any] = field(default_factory=dict)
+    training: Dict[str, Any] = field(default_factory=dict)
+    synthetic_data: Dict[str, Any] = field(default_factory=dict)
+    sandbox: Dict[str, Any] = field(default_factory=dict)
+    development: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_yaml(cls, file_path: Path) -> "EnvironmentConfig":
+        """Load configuration from YAML file."""
+        with open(file_path, "r") as f:
+            data = yaml.safe_load(f)
+        return cls(**data)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "name": self.name,
+            "environment": self.environment.value,
+            "redis_db": self.redis_db,
+            "redis_prefix": self.redis_prefix,
+            "api_endpoints": self.api_endpoints,
+            "rate_limits": self.rate_limits,
+            "safety_checks": self.safety_checks,
+            "require_confirmation": self.require_confirmation,
+            "require_mfa": self.require_mfa,
+            "allowed_operations": self.allowed_operations,
+            "restricted_operations": self.restricted_operations,
+            "data_retention_hours": self.data_retention_hours,
+            "max_position_size": self.max_position_size,
+            "max_daily_trades": self.max_daily_trades,
+            "enable_logging": self.enable_logging,
+            "log_level": self.log_level,
+            "telemetry_enabled": self.telemetry_enabled,
+            "features": self.features,
+        }
+
+
+@dataclass
+class EnvironmentStatus:
+    """Current environment status."""
+
+    environment: Environment
+    config: EnvironmentConfig
+    is_authenticated: bool
+    session_id: str
+    session_start: datetime
+    operations_count: int
+    last_operation: Optional[datetime]
+    warnings: List[str]
+
+    def is_production(self) -> bool:
+        """Check if in production environment."""
+        return self.environment == Environment.PRODUCTION
+
+    def is_safe_mode(self) -> bool:
+        """Check if in a safe mode (non-production)."""
+        return self.environment in [
+            Environment.DEVELOPMENT,
+            Environment.TRAINING,
+            Environment.SANDBOX,
+        ]
+
+    def session_duration(self) -> timedelta:
+        """Get current session duration."""
+        return datetime.now() - self.session_start
+
+
+class EnvironmentManager:
+    """Manages environment detection and configuration."""
+
+    def __init__(self, config_dir: Optional[Path] = None):
+        """Initialize environment manager."""
+        self.config_dir = config_dir or Path("config/environments")
+        self._current_env: Optional[Environment] = None
+        self._config: Optional[EnvironmentConfig] = None
+        self._status: Optional[EnvironmentStatus] = None
+        self._redis_clients: Dict[Environment, redis.Redis] = {}
+        self._guards: List["EnvironmentGuard"] = []
+        self._callbacks: Dict[str, List[Callable]] = {
+            "pre_switch": [],
+            "post_switch": [],
+            "operation": [],
+        }
+
+        # Auto-detect environment on initialization
+        self._detect_environment()
+
+    def _detect_environment(self) -> Environment:
+        """Auto-detect current environment from various sources."""
+        # Priority order for environment detection
+
+        # 1. Explicit environment variable
+        env_var = os.getenv("KALSHI_ENVIRONMENT", "").lower()
+        if env_var:
+            # Support legacy aliases commonly used for Neural API selection
+            alias_map = {
+                "prod": Environment.PRODUCTION,
+                "production": Environment.PRODUCTION,
+                "demo": Environment.SANDBOX,
+                "sandbox": Environment.SANDBOX,
+                "staging": Environment.STAGING,
+                "train": Environment.TRAINING,
+                "training": Environment.TRAINING,
+                "dev": Environment.DEVELOPMENT,
+                "development": Environment.DEVELOPMENT,
+            }
+            if env_var in alias_map:
+                return alias_map[env_var]
+            try:
+                return Environment(env_var)
+            except ValueError:
+                warnings.warn(f"Invalid environment: {env_var}")
+
+        # 2. Check for production indicators
+        if os.getenv("PRODUCTION_MODE") == "true":
+            return Environment.PRODUCTION
+
+        # 3. Check for training indicators
+        if os.getenv("TRAINING_MODE") == "true":
+            return Environment.TRAINING
+
+        # 4. Check for CI/CD indicators
+        if os.getenv("CI") or os.getenv("GITHUB_ACTIONS"):
+            return Environment.STAGING
+
+        # 5. Check for development indicators
+        if os.getenv("DEBUG") == "true" or os.getenv("DEV_MODE"):
+            return Environment.DEVELOPMENT
+
+        # 6. Check hostname patterns
+        hostname = os.uname().nodename.lower()
+        if "prod" in hostname:
+            return Environment.PRODUCTION
+        elif "staging" in hostname:
+            return Environment.STAGING
+        elif "sandbox" in hostname:
+            return Environment.SANDBOX
+
+        # 7. Default to development for safety
+        warnings.warn("Environment not detected, defaulting to DEVELOPMENT")
+        return Environment.DEVELOPMENT
+
+    def initialize(self, environment: Optional[Environment] = None) -> None:
+        """Initialize with specific environment."""
+        if environment:
+            self._current_env = environment
+        else:
+            self._current_env = self._detect_environment()
+
+        # Load configuration
+        self._load_config()
+
+        # Initialize status
+        self._status = EnvironmentStatus(
+            environment=self._current_env,
+            config=self._config,
+            is_authenticated=False,
+            session_id=self._generate_session_id(),
+            session_start=datetime.now(),
+            operations_count=0,
+            last_operation=None,
+            warnings=[],
+        )
+
+        # Apply visual theme
+        self._apply_visual_theme()
+
+        # Print environment banner
+        self._print_banner()
+
+    def _load_config(self) -> None:
+        """Load configuration for current environment."""
+        config_file = self.config_dir / f"{self._current_env.value}.yaml"
+
+        if config_file.exists():
+            self._config = EnvironmentConfig.from_yaml(config_file)
+        else:
+            # Use default configuration
+            self._config = self._get_default_config(self._current_env)
+
+    def _get_default_config(self, env: Environment) -> EnvironmentConfig:
+        """Get default configuration for environment."""
+        base_config = {
+            "name": env.value.title(),
+            "environment": env,
+            "enable_logging": True,
+            "features": {},
+        }
+
+        if env == Environment.PRODUCTION:
+            return EnvironmentConfig(
+                **base_config,
+                redis_db=0,
+                redis_prefix="prod:",
+                api_endpoints={
+                    "neural": "https://api.elections.neural.com",
+                    "odds": "https://api.theoddsapi.com/v4",
+                },
+                rate_limits={"neural": 100, "odds": 50},
+                safety_checks=True,
+                require_confirmation=True,
+                require_mfa=True,
+                allowed_operations=["*"],
+                restricted_operations=[],
+                data_retention_hours=720,  # 30 days
+                max_position_size=0.05,
+                max_daily_trades=20,
+                log_level="INFO",
+                telemetry_enabled=True,
+            )
+
+        elif env == Environment.STAGING:
+            return EnvironmentConfig(
+                **base_config,
+                redis_db=1,
+                redis_prefix="staging:",
+                api_endpoints={
+                    "neural": "https://demo-api.neural.co",
+                    "odds": "https://api.theoddsapi.com/v4",
+                },
+                rate_limits={"neural": 200, "odds": 100},
+                safety_checks=True,
+                require_confirmation=True,
+                require_mfa=False,
+                allowed_operations=["*"],
+                restricted_operations=["delete_all"],
+                data_retention_hours=168,  # 7 days
+                max_position_size=0.10,
+                max_daily_trades=50,
+                log_level="DEBUG",
+                telemetry_enabled=True,
+            )
+
+        elif env == Environment.SANDBOX:
+            return EnvironmentConfig(
+                **base_config,
+                redis_db=2,
+                redis_prefix="sandbox:",
+                api_endpoints={
+                    "neural": "https://demo-api.neural.co",
+                    "odds": "https://api.theoddsapi.com/v4",
+                },
+                rate_limits={"neural": 500, "odds": 200},
+                safety_checks=True,
+                require_confirmation=False,
+                require_mfa=False,
+                allowed_operations=["*"],
+                restricted_operations=[],
+                data_retention_hours=24,
+                max_position_size=0.20,
+                max_daily_trades=100,
+                log_level="DEBUG",
+                telemetry_enabled=False,
+            )
+
+        elif env == Environment.TRAINING:
+            return EnvironmentConfig(
+                **base_config,
+                redis_db=3,
+                redis_prefix="training:",
+                api_endpoints={
+                    "neural": "http://localhost:8000/mock",
+                    "odds": "http://localhost:8001/mock",
+                },
+                rate_limits={"neural": 1000, "odds": 1000},
+                safety_checks=False,
+                require_confirmation=False,
+                require_mfa=False,
+                allowed_operations=["*"],
+                restricted_operations=[],
+                data_retention_hours=4,
+                max_position_size=1.0,
+                max_daily_trades=1000,
+                log_level="DEBUG",
+                telemetry_enabled=False,
+            )
+
+        else:  # DEVELOPMENT
+            return EnvironmentConfig(
+                **base_config,
+                redis_db=4,
+                redis_prefix="dev:",
+                api_endpoints={
+                    "neural": "http://localhost:8000/mock",
+                    "odds": "http://localhost:8001/mock",
+                },
+                rate_limits={"neural": 10000, "odds": 10000},
+                safety_checks=False,
+                require_confirmation=False,
+                require_mfa=False,
+                allowed_operations=["*"],
+                restricted_operations=[],
+                data_retention_hours=1,
+                max_position_size=1.0,
+                max_daily_trades=10000,
+                log_level="DEBUG",
+                telemetry_enabled=False,
+            )
+
+    def _generate_session_id(self) -> str:
+        """Generate unique session ID."""
+        data = f"{datetime.now().isoformat()}-{os.getpid()}-{os.urandom(8).hex()}"
+        return hashlib.sha256(data.encode()).hexdigest()[:16]
+
+    def _apply_visual_theme(self) -> None:
+        """Apply visual theme for current environment."""
+        theme = VisualTheme[self._current_env.name]
+        _, icon = theme.value
+
+        # Set terminal title if supported (skip in non-interactive environments)
+        try:
+            if os.name != "nt" and sys.stdout.isatty():  # Unix-like systems with TTY
+                sys.stdout.write(
+                    f"\033]0;Neural Agent - {icon} {self._current_env.value.upper()}\007"
+                )
+                sys.stdout.flush()
+        except Exception:
+            pass  # Skip terminal title setting if not supported
+
+    def _print_banner(self) -> None:
+        """Print environment banner."""
+        theme = VisualTheme[self._current_env.name]
+        color, icon = theme.value
+
+        banner = f"""
+{color}{'='*60}
+{icon} KALSHI TRADING AGENT - {self._current_env.value.upper()} ENVIRONMENT {icon}
+{'='*60}
+Session ID: {self._status.session_id}
+Started: {self._status.session_start.strftime('%Y-%m-%d %H:%M:%S')}
+Redis DB: {self._config.redis_db}
+Safety Checks: {'✓' if self._config.safety_checks else '✗'}
+MFA Required: {'✓' if self._config.require_mfa else '✗'}
+{'='*60}{Style.RESET_ALL}
+"""
+        print(banner)
+
+        if self._current_env == Environment.PRODUCTION:
+            self._print_production_warning()
+
+    def _print_production_warning(self) -> None:
+        """Print production environment warning."""
+        warning = f"""
+{Back.RED}{Fore.WHITE}{'!'*60}
+                    PRODUCTION ENVIRONMENT
+                    
+  You are operating in PRODUCTION mode with REAL MONEY.
+  All trades will be executed on live markets.
+  
+  Ensure you have:
+  ✓ Verified all risk parameters
+  ✓ Tested changes in sandbox first
+  ✓ Proper authorization to trade
+  ✓ Emergency stop procedures ready
+  
+  Type 'CONFIRM PRODUCTION' to proceed...
+{'!'*60}{Style.RESET_ALL}
+"""
+        print(warning)
+
+    def get_current_environment(self) -> Environment:
+        """Get current environment."""
+        return self._current_env
+
+    def get_config(self) -> EnvironmentConfig:
+        """Get current environment configuration."""
+        return self._config
+
+    def get_status(self) -> EnvironmentStatus:
+        """Get current environment status."""
+        return self._status
+
+    def is_production(self) -> bool:
+        """Check if in production environment."""
+        return self._current_env == Environment.PRODUCTION
+
+    def is_safe_mode(self) -> bool:
+        """Check if in safe mode (non-production)."""
+        return self._current_env in [
+            Environment.DEVELOPMENT,
+            Environment.TRAINING,
+            Environment.SANDBOX,
+        ]
+
+    def can_execute_operation(self, operation: str) -> Tuple[bool, str]:
+        """Check if operation is allowed in current environment."""
+        # Check if operation is restricted
+        if operation in self._config.restricted_operations:
+            return (
+                False,
+                f"Operation '{operation}' is restricted in {self._current_env.value}",
+            )
+
+        # Check if operation is explicitly allowed
+        if "*" in self._config.allowed_operations:
+            return True, "Operation allowed"
+
+        if operation in self._config.allowed_operations:
+            return True, "Operation allowed"
+
+        return (
+            False,
+            f"Operation '{operation}' not allowed in {self._current_env.value}",
+        )
+
+    async def get_redis_client(self) -> redis.Redis:
+        """Get Redis client for current environment."""
+        if self._current_env not in self._redis_clients:
+            self._redis_clients[self._current_env] = redis.Redis(
+                host=os.getenv("REDIS_HOST", "localhost"),
+                port=int(os.getenv("REDIS_PORT", 6379)),
+                db=self._config.redis_db,
+                decode_responses=True,
+            )
+
+        return self._redis_clients[self._current_env]
+
+    def add_guard(self, guard: "EnvironmentGuard") -> None:
+        """Add environment guard."""
+        self._guards.append(guard)
+
+    def register_callback(self, event: str, callback: Callable) -> None:
+        """Register callback for environment events."""
+        if event in self._callbacks:
+            self._callbacks[event].append(callback)
+
+    async def switch_environment(
+        self, new_env: Environment, force: bool = False
+    ) -> Tuple[bool, str]:
+        """Switch to different environment."""
+        if self._current_env == new_env:
+            return True, "Already in requested environment"
+
+        # Check if switch is allowed
+        if not force:
+            # Run pre-switch callbacks
+            for callback in self._callbacks["pre_switch"]:
+                if not await callback(self._current_env, new_env):
+                    return False, "Switch blocked by callback"
+
+            # Check guards
+            for guard in self._guards:
+                allowed, reason = await guard.check_switch(self._current_env, new_env)
+                if not allowed:
+                    return False, f"Switch blocked: {reason}"
+
+        # Perform switch
+        old_env = self._current_env
+        self._current_env = new_env
+        self._load_config()
+
+        # Update status
+        self._status = EnvironmentStatus(
+            environment=self._current_env,
+            config=self._config,
+            is_authenticated=False,
+            session_id=self._generate_session_id(),
+            session_start=datetime.now(),
+            operations_count=0,
+            last_operation=None,
+            warnings=[],
+        )
+
+        # Apply new theme
+        self._apply_visual_theme()
+        self._print_banner()
+
+        # Run post-switch callbacks
+        for callback in self._callbacks["post_switch"]:
+            await callback(old_env, new_env)
+
+        return True, f"Switched from {old_env.value} to {new_env.value}"
+
+    def require_confirmation(self, message: str) -> bool:
+        """Require user confirmation for sensitive operations."""
+        if not self._config.require_confirmation:
+            return True
+
+        print(f"\n{Fore.YELLOW}⚠️  {message}")
+        response = input(f"{Fore.YELLOW}Type 'yes' to confirm: {Style.RESET_ALL}")
+
+        return response.lower() == "yes"
+
+    def log_operation(self, operation: str, details: Dict[str, Any]) -> None:
+        """Log an operation in current environment."""
+        self._status.operations_count += 1
+        self._status.last_operation = datetime.now()
+
+        # Run operation callbacks
+        for callback in self._callbacks["operation"]:
+            callback(operation, details)
+
+    def add_warning(self, warning: str) -> None:
+        """Add warning to current session."""
+        self._status.warnings.append(f"[{datetime.now().isoformat()}] {warning}")
+
+    def get_api_endpoint(self, service: str) -> str:
+        """Get API endpoint for service in current environment."""
+        return self._config.api_endpoints.get(service, "")
+
+    def get_rate_limit(self, service: str) -> int:
+        """Get rate limit for service in current environment."""
+        return self._config.rate_limits.get(service, 100)
+
+    def is_feature_enabled(self, feature: str) -> bool:
+        """Check if feature is enabled in current environment."""
+        return self._config.features.get(feature, False)
+
+    def get_visual_indicator(self) -> str:
+        """Get visual indicator for current environment."""
+        theme = VisualTheme[self._current_env.name]
+        color, icon = theme.value
+        return f"{color}{icon} {self._current_env.value.upper()}{Style.RESET_ALL}"
+
+
+class EnvironmentGuard:
+    """Base class for environment guards."""
+
+    async def check_switch(
+        self, from_env: Environment, to_env: Environment
+    ) -> Tuple[bool, str]:
+        """Check if environment switch is allowed."""
+        raise NotImplementedError
+
+    async def check_operation(
+        self, operation: str, environment: Environment
+    ) -> Tuple[bool, str]:
+        """Check if operation is allowed."""
+        raise NotImplementedError
+
+
+class ProductionGuard(EnvironmentGuard):
+    """Guard for production environment access."""
+
+    def __init__(self, require_mfa: bool = True):
+        """Initialize production guard."""
+        self.require_mfa = require_mfa
+        self._authenticated_sessions: Dict[str, datetime] = {}
+
+    async def check_switch(
+        self, from_env: Environment, to_env: Environment
+    ) -> Tuple[bool, str]:
+        """Check if switch to production is allowed."""
+        if to_env != Environment.PRODUCTION:
+            return True, "Not switching to production"
+
+        # Require explicit confirmation
+        print(
+            f"\n{Back.RED}{Fore.WHITE}SWITCHING TO PRODUCTION ENVIRONMENT{Style.RESET_ALL}"
+        )
+        print("This will enable REAL MONEY trading.")
+
+        confirmation = input("Type 'PRODUCTION' to confirm: ")
+        if confirmation != "PRODUCTION":
+            return False, "Production switch not confirmed"
+
+        # Check MFA if required
+        if self.require_mfa:
+            mfa_code = input("Enter MFA code: ")
+            if not self._verify_mfa(mfa_code):
+                return False, "Invalid MFA code"
+
+        return True, "Production access granted"
+
+    async def check_operation(
+        self, operation: str, environment: Environment
+    ) -> Tuple[bool, str]:
+        """Check if operation is allowed in production."""
+        if environment != Environment.PRODUCTION:
+            return True, "Not in production"
+
+        # List of operations requiring extra confirmation
+        sensitive_ops = [
+            "delete_all_data",
+            "reset_positions",
+            "emergency_stop",
+            "modify_risk_params",
+        ]
+
+        if operation in sensitive_ops:
+            print(f"\n{Fore.RED}⚠️  SENSITIVE OPERATION: {operation}{Style.RESET_ALL}")
+            confirmation = input("Type operation name to confirm: ")
+            if confirmation != operation:
+                return False, "Operation not confirmed"
+
+        return True, "Operation allowed"
+
+    def _verify_mfa(self, code: str) -> bool:
+        """Verify MFA code (placeholder - implement actual MFA)."""
+        # In production, integrate with actual MFA provider
+        # For now, accept a specific code for testing
+        return code == "123456"  # TODO: Implement real MFA
diff --git a/neural_sdk/core/environment_ui.py b/neural_sdk/core/environment_ui.py
new file mode 100644
index 00000000..d37d96b1
--- /dev/null
+++ b/neural_sdk/core/environment_ui.py
@@ -0,0 +1,566 @@
+"""
+Environment UI Components
+
+Visual interface components for environment management with
+clear distinctions between training/sandbox and production modes.
+"""
+
+import asyncio
+import os
+import sys
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+from colorama import Back, Fore
+from colorama import Style as ColoramaStyle
+from colorama import init
+from rich.console import Console
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Confirm, Prompt
+from rich.style import Style
+from rich.table import Table
+from rich.text import Text
+
+from .environment_manager import Environment, EnvironmentManager, EnvironmentStatus
+
+# Initialize colorama
+init(autoreset=True)
+
+
+class UITheme:
+    """UI themes for different environments."""
+
+    THEMES = {
+        Environment.DEVELOPMENT: {
+            "primary": "cyan",
+            "secondary": "blue",
+            "accent": "white",
+            "background": "black",
+            "warning": "yellow",
+            "error": "red",
+            "success": "green",
+            "border_style": "cyan",
+            "title_style": "bold cyan",
+            "icon": "🔧",
+        },
+        Environment.TRAINING: {
+            "primary": "yellow",
+            "secondary": "orange",
+            "accent": "white",
+            "background": "black",
+            "warning": "magenta",
+            "error": "red",
+            "success": "green",
+            "border_style": "yellow",
+            "title_style": "bold yellow",
+            "icon": "🎓",
+        },
+        Environment.SANDBOX: {
+            "primary": "green",
+            "secondary": "lime",
+            "accent": "white",
+            "background": "black",
+            "warning": "yellow",
+            "error": "red",
+            "success": "bright_green",
+            "border_style": "green",
+            "title_style": "bold green",
+            "icon": "📦",
+        },
+        Environment.STAGING: {
+            "primary": "magenta",
+            "secondary": "purple",
+            "accent": "white",
+            "background": "black",
+            "warning": "yellow",
+            "error": "red",
+            "success": "green",
+            "border_style": "magenta",
+            "title_style": "bold magenta",
+            "icon": "🚦",
+        },
+        Environment.PRODUCTION: {
+            "primary": "red",
+            "secondary": "bright_red",
+            "accent": "white",
+            "background": "black",
+            "warning": "bright_yellow",
+            "error": "bright_red",
+            "success": "green",
+            "border_style": "bold red",
+            "title_style": "bold white on red",
+            "icon": "🔥",
+        },
+    }
+
+    @classmethod
+    def get_theme(cls, environment: Environment) -> Dict[str, Any]:
+        """Get theme for environment."""
+        return cls.THEMES.get(environment, cls.THEMES[Environment.DEVELOPMENT])
+
+
+class EnvironmentUI:
+    """Main UI class for environment management."""
+
+    def __init__(self, manager: EnvironmentManager):
+        """Initialize environment UI."""
+        self.manager = manager
+        self.console = Console()
+        self.current_theme = UITheme.get_theme(manager.get_current_environment())
+
+    def display_banner(self) -> None:
+        """Display environment banner with visual indicators."""
+        env = self.manager.get_current_environment()
+        theme = UITheme.get_theme(env)
+        status = self.manager.get_status()
+
+        # Create banner content
+        banner_text = Text()
+        banner_text.append(f"\n{theme['icon']} ", style=theme["primary"])
+        banner_text.append(f"KALSHI TRADING AGENT", style="bold white")
+        banner_text.append(f" - ", style="white")
+        banner_text.append(f"{env.value.upper()}", style=f"bold {theme['primary']}")
+        banner_text.append(f" {theme['icon']}\n", style=theme["primary"])
+
+        # Add status information
+        status_table = Table(show_header=False, box=None, padding=0)
+        status_table.add_column("Key", style="dim")
+        status_table.add_column("Value", style=theme["accent"])
+
+        status_table.add_row("Session ID:", status.session_id)
+        status_table.add_row(
+            "Started:", status.session_start.strftime("%Y-%m-%d %H:%M:%S")
+        )
+        status_table.add_row("Duration:", str(status.session_duration()).split(".")[0])
+        status_table.add_row("Operations:", str(status.operations_count))
+        status_table.add_row("Redis DB:", str(status.config.redis_db))
+        status_table.add_row(
+            "Safety Checks:", "✓" if status.config.safety_checks else "✗"
+        )
+        status_table.add_row("MFA Required:", "✓" if status.config.require_mfa else "✗")
+
+        # Create panel
+        panel = Panel(
+            status_table,
+            title=banner_text,
+            border_style=theme["border_style"],
+            padding=(1, 2),
+        )
+
+        self.console.print(panel)
+
+        # Show production warning if needed
+        if env == Environment.PRODUCTION:
+            self._display_production_warning()
+
+    def _display_production_warning(self) -> None:
+        """Display prominent production warning."""
+        warning = Panel(
+            Text.from_markup(
+                "[bold white on red] ⚠️  PRODUCTION ENVIRONMENT ⚠️  [/]\n\n"
+                "[bold yellow]You are operating with REAL MONEY[/]\n"
+                "All trades will be executed on live markets\n\n"
+                "[dim]Ensure you have:[/]\n"
+                "  • Verified all risk parameters\n"
+                "  • Tested changes in sandbox\n"
+                "  • Proper authorization\n"
+                "  • Emergency procedures ready"
+            ),
+            title="[bold red]CRITICAL WARNING[/]",
+            border_style="bold red",
+            padding=(1, 2),
+        )
+        self.console.print(warning)
+
+    def display_status(self) -> None:
+        """Display current environment status."""
+        status = self.manager.get_status()
+        theme = self.current_theme
+
+        # Create status table
+        table = Table(
+            title=f"{theme['icon']} Environment Status",
+            title_style=theme["title_style"],
+            border_style=theme["border_style"],
+        )
+
+        table.add_column("Property", style="cyan", no_wrap=True)
+        table.add_column("Value", style="white")
+
+        # Add rows
+        table.add_row("Environment", status.environment.value.upper())
+        table.add_row("Session ID", status.session_id)
+        table.add_row("Authenticated", "✓" if status.is_authenticated else "✗")
+        table.add_row("Session Duration", str(status.session_duration()).split(".")[0])
+        table.add_row("Operations Count", str(status.operations_count))
+
+        if status.last_operation:
+            table.add_row("Last Operation", status.last_operation.strftime("%H:%M:%S"))
+
+        if status.warnings:
+            table.add_row("Warnings", str(len(status.warnings)))
+
+        table.add_row("Safe Mode", "✓" if status.is_safe_mode() else "✗")
+
+        self.console.print(table)
+
+    def display_config(self) -> None:
+        """Display environment configuration."""
+        config = self.manager.get_config()
+        theme = self.current_theme
+
+        # Create config panels
+        layout = Layout()
+        layout.split_column(
+            Layout(name="limits"), Layout(name="features"), Layout(name="api")
+        )
+
+        # Trading limits table
+        limits_table = Table(title="Trading Limits", border_style=theme["border_style"])
+        limits_table.add_column("Limit", style="cyan")
+        limits_table.add_column("Value", style="white")
+
+        limits_table.add_row("Max Position Size", f"{config.max_position_size:.1%}")
+        limits_table.add_row("Max Daily Trades", str(config.max_daily_trades))
+        limits_table.add_row("Data Retention", f"{config.data_retention_hours}h")
+
+        # Features table
+        features_table = Table(title="Features", border_style=theme["border_style"])
+        features_table.add_column("Feature", style="cyan")
+        features_table.add_column("Status", style="white")
+
+        for feature, enabled in config.features.items():
+            status = "✓" if enabled else "✗"
+            color = "green" if enabled else "red"
+            features_table.add_row(
+                feature.replace("_", " ").title(), f"[{color}]{status}[/]"
+            )
+
+        # API endpoints table
+        api_table = Table(title="API Endpoints", border_style=theme["border_style"])
+        api_table.add_column("Service", style="cyan")
+        api_table.add_column("Endpoint", style="white")
+
+        for service, endpoint in config.api_endpoints.items():
+            api_table.add_row(service, endpoint)
+
+        # Display all tables
+        self.console.print(limits_table)
+        self.console.print(features_table)
+        self.console.print(api_table)
+
+    async def confirm_operation(
+        self, operation: str, details: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        """Confirm sensitive operation with visual prompt."""
+        env = self.manager.get_current_environment()
+        theme = UITheme.get_theme(env)
+
+        # Build confirmation message
+        message = Text()
+        message.append(f"\n{theme['icon']} ", style=theme["primary"])
+        message.append("Operation Confirmation\n", style="bold white")
+        message.append(f"Operation: ", style="dim")
+        message.append(f"{operation}\n", style="yellow")
+
+        if details:
+            for key, value in details.items():
+                message.append(f"{key}: ", style="dim")
+                message.append(f"{value}\n", style="white")
+
+        # Add environment warning
+        if env == Environment.PRODUCTION:
+            message.append("\n⚠️  ", style="red")
+            message.append("This is a PRODUCTION operation!\n", style="bold red")
+
+        # Create confirmation panel
+        panel = Panel(
+            message,
+            border_style=(
+                theme["warning"] if env != Environment.PRODUCTION else "bold red"
+            ),
+            padding=(1, 2),
+        )
+
+        self.console.print(panel)
+
+        # Get confirmation
+        return Confirm.ask(
+            f"Do you want to proceed?",
+            default=False if env == Environment.PRODUCTION else True,
+        )
+
+    async def select_environment(self) -> Optional[Environment]:
+        """Interactive environment selection."""
+        theme = self.current_theme
+
+        # Create environment table
+        table = Table(
+            title="Available Environments",
+            title_style=theme["title_style"],
+            border_style=theme["border_style"],
+        )
+
+        table.add_column("#", style="cyan", width=3)
+        table.add_column("Environment", style="white")
+        table.add_column("Icon", width=3)
+        table.add_column("Description", style="dim")
+
+        descriptions = {
+            Environment.DEVELOPMENT: "Local development and testing",
+            Environment.TRAINING: "Agent training with synthetic data",
+            Environment.SANDBOX: "Safe testing with demo APIs",
+            Environment.STAGING: "Pre-production validation",
+            Environment.PRODUCTION: "Live trading with real money",
+        }
+
+        environments = list(Environment)
+        for i, env in enumerate(environments, 1):
+            env_theme = UITheme.get_theme(env)
+            style = "red bold" if env == Environment.PRODUCTION else "white"
+            table.add_row(
+                str(i),
+                env.value.upper(),
+                env_theme["icon"],
+                descriptions[env],
+                style=style,
+            )
+
+        self.console.print(table)
+
+        # Get selection
+        choice = Prompt.ask("Select environment (number or name)", default="cancel")
+
+        if choice.lower() == "cancel":
+            return None
+
+        # Parse choice
+        try:
+            if choice.isdigit():
+                index = int(choice) - 1
+                if 0 <= index < len(environments):
+                    return environments[index]
+            else:
+                return Environment(choice.lower())
+        except (ValueError, IndexError):
+            self.console.print("[red]Invalid selection[/]")
+            return None
+
+    def display_transition_plan(
+        self, from_env: Environment, to_env: Environment, checks: List[str]
+    ) -> None:
+        """Display environment transition plan."""
+        theme = UITheme.get_theme(to_env)
+
+        # Create transition panel
+        content = Text()
+        content.append("Transition Plan\n\n", style="bold white")
+        content.append(f"From: ", style="dim")
+        content.append(f"{from_env.value.upper()}\n", style="cyan")
+        content.append(f"To: ", style="dim")
+        content.append(f"{to_env.value.upper()}\n", style=theme["primary"])
+
+        if checks:
+            content.append(f"\nRequired Checks:\n", style="yellow")
+            for check in checks:
+                content.append(f"  • {check}\n", style="white")
+
+        panel = Panel(
+            content,
+            title="Environment Transition",
+            border_style=theme["border_style"],
+            padding=(1, 2),
+        )
+
+        self.console.print(panel)
+
+    async def show_progress(self, task: str, total: int = 100) -> Progress:
+        """Show progress bar for long operations."""
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=self.console,
+        )
+
+        task_id = progress.add_task(task, total=total)
+        return progress
+
+    def display_error(self, error: str) -> None:
+        """Display error message."""
+        theme = self.current_theme
+
+        error_panel = Panel(
+            Text(error, style="bold red"),
+            title="❌ Error",
+            border_style="red",
+            padding=(1, 2),
+        )
+
+        self.console.print(error_panel)
+
+    def display_success(self, message: str) -> None:
+        """Display success message."""
+        theme = self.current_theme
+
+        success_panel = Panel(
+            Text(message, style="bold green"),
+            title="✅ Success",
+            border_style="green",
+            padding=(1, 2),
+        )
+
+        self.console.print(success_panel)
+
+    def display_warning(self, warning: str) -> None:
+        """Display warning message."""
+        theme = self.current_theme
+
+        warning_panel = Panel(
+            Text(warning, style="bold yellow"),
+            title="⚠️  Warning",
+            border_style="yellow",
+            padding=(1, 2),
+        )
+
+        self.console.print(warning_panel)
+
+
+class EnvironmentCLI:
+    """Command-line interface for environment management."""
+
+    def __init__(self, manager: EnvironmentManager):
+        """Initialize CLI."""
+        self.manager = manager
+        self.ui = EnvironmentUI(manager)
+        self.commands = {
+            "status": self.cmd_status,
+            "config": self.cmd_config,
+            "switch": self.cmd_switch,
+            "check": self.cmd_check,
+            "help": self.cmd_help,
+            "exit": self.cmd_exit,
+        }
+
+    async def run(self) -> None:
+        """Run interactive CLI."""
+        self.ui.display_banner()
+
+        while True:
+            try:
+                # Get command
+                env_indicator = self.manager.get_visual_indicator()
+                command = input(f"\n{env_indicator} > ").strip().lower()
+
+                if not command:
+                    continue
+
+                # Parse command
+                parts = command.split()
+                cmd = parts[0]
+                args = parts[1:] if len(parts) > 1 else []
+
+                # Execute command
+                if cmd in self.commands:
+                    result = await self.commands[cmd](args)
+                    if result == "exit":
+                        break
+                else:
+                    self.ui.display_error(f"Unknown command: {cmd}")
+                    self.cmd_help([])
+
+            except KeyboardInterrupt:
+                print("\n")
+                if self.manager.is_production():
+                    if await self.ui.confirm_operation(
+                        "Exit from production environment"
+                    ):
+                        break
+                else:
+                    break
+            except Exception as e:
+                self.ui.display_error(f"Error: {str(e)}")
+
+    async def cmd_status(self, args: List[str]) -> None:
+        """Show environment status."""
+        self.ui.display_status()
+
+    async def cmd_config(self, args: List[str]) -> None:
+        """Show environment configuration."""
+        self.ui.display_config()
+
+    async def cmd_switch(self, args: List[str]) -> None:
+        """Switch environment."""
+        # Select new environment
+        new_env = await self.ui.select_environment()
+        if not new_env:
+            return
+
+        # Get transition requirements
+        from .environment_guards import TransitionGuard
+
+        guard = TransitionGuard()
+        checks = guard.get_required_checks(
+            self.manager.get_current_environment(), new_env
+        )
+
+        # Display transition plan
+        self.ui.display_transition_plan(
+            self.manager.get_current_environment(), new_env, checks
+        )
+
+        # Confirm switch
+        if await self.ui.confirm_operation(f"Switch to {new_env.value}"):
+            success, message = await self.manager.switch_environment(new_env)
+
+            if success:
+                self.ui.display_success(message)
+                self.ui.display_banner()
+            else:
+                self.ui.display_error(message)
+
+    async def cmd_check(self, args: List[str]) -> None:
+        """Check if operation is allowed."""
+        if not args:
+            self.ui.display_error("Usage: check <operation>")
+            return
+
+        operation = " ".join(args)
+        allowed, reason = self.manager.can_execute_operation(operation)
+
+        if allowed:
+            self.ui.display_success(f"Operation '{operation}' is allowed: {reason}")
+        else:
+            self.ui.display_warning(f"Operation '{operation}' is blocked: {reason}")
+
+    def cmd_help(self, args: List[str]) -> None:
+        """Show help."""
+        help_text = """
+Available Commands:
+  status  - Show environment status
+  config  - Show environment configuration
+  switch  - Switch to different environment
+  check   - Check if operation is allowed
+  help    - Show this help message
+  exit    - Exit the CLI
+"""
+        self.ui.console.print(help_text)
+
+    async def cmd_exit(self, args: List[str]) -> str:
+        """Exit CLI."""
+        if self.manager.is_production():
+            if await self.ui.confirm_operation("Exit from production environment"):
+                return "exit"
+        else:
+            return "exit"
+
+
+def create_environment_cli() -> EnvironmentCLI:
+    """Create and initialize environment CLI."""
+    manager = EnvironmentManager()
+    manager.initialize()
+    return EnvironmentCLI(manager)
diff --git a/neural_sdk/core/environment_validator.py b/neural_sdk/core/environment_validator.py
new file mode 100644
index 00000000..52f89f3b
--- /dev/null
+++ b/neural_sdk/core/environment_validator.py
@@ -0,0 +1,804 @@
+"""
+Environment Validator
+
+Validation and testing utilities for environment configurations
+and transitions.
+"""
+
+import asyncio
+import hashlib
+import json
+import os
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+import pytest
+import redis.asyncio as redis
+
+from .environment_guards import (
+    ComplianceGuard,
+    CrossEnvironmentGuard,
+    DataIntegrityGuard,
+    EmergencyStopGuard,
+    RateLimitGuard,
+    ResourceGuard,
+    TransitionGuard,
+)
+from .environment_manager import Environment, EnvironmentConfig, EnvironmentManager
+from .redis_config import EnvironmentRedisManager, RedisConfig
+from .transition_protocol import ModeTransitionProtocol, TransitionPlan
+
+
+@dataclass
+class ValidationResult:
+    """Result of validation check."""
+
+    check_name: str
+    passed: bool
+    message: str
+    details: Dict[str, Any] = field(default_factory=dict)
+    timestamp: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "check_name": self.check_name,
+            "passed": self.passed,
+            "message": self.message,
+            "details": self.details,
+            "timestamp": self.timestamp.isoformat(),
+        }
+
+
+@dataclass
+class ValidationReport:
+    """Complete validation report."""
+
+    environment: Environment
+    total_checks: int
+    passed_checks: int
+    failed_checks: int
+    results: List[ValidationResult]
+    duration: timedelta
+    generated_at: datetime
+
+    @property
+    def success_rate(self) -> float:
+        """Calculate success rate."""
+        if self.total_checks == 0:
+            return 0.0
+        return self.passed_checks / self.total_checks
+
+    def get_failures(self) -> List[ValidationResult]:
+        """Get failed validation results."""
+        return [r for r in self.results if not r.passed]
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "environment": self.environment.value,
+            "total_checks": self.total_checks,
+            "passed_checks": self.passed_checks,
+            "failed_checks": self.failed_checks,
+            "success_rate": self.success_rate,
+            "duration": str(self.duration),
+            "generated_at": self.generated_at.isoformat(),
+            "results": [r.to_dict() for r in self.results],
+        }
+
+
+class EnvironmentValidator:
+    """Validator for environment configurations."""
+
+    def __init__(self, manager: EnvironmentManager):
+        """Initialize validator."""
+        self.manager = manager
+        self.redis_manager = EnvironmentRedisManager(manager)
+        self.checks = {
+            "config": self.validate_config,
+            "redis": self.validate_redis,
+            "api": self.validate_api_endpoints,
+            "guards": self.validate_guards,
+            "isolation": self.validate_isolation,
+            "permissions": self.validate_permissions,
+            "resources": self.validate_resources,
+            "data_integrity": self.validate_data_integrity,
+        }
+
+    async def validate_environment(
+        self,
+        environment: Optional[Environment] = None,
+        checks: Optional[List[str]] = None,
+    ) -> ValidationReport:
+        """Run complete environment validation."""
+        env = environment or self.manager.get_current_environment()
+        checks_to_run = checks or list(self.checks.keys())
+
+        start_time = datetime.now()
+        results = []
+
+        for check_name in checks_to_run:
+            if check_name in self.checks:
+                result = await self.checks[check_name](env)
+                results.append(result)
+
+        # Calculate statistics
+        passed = sum(1 for r in results if r.passed)
+        failed = len(results) - passed
+
+        report = ValidationReport(
+            environment=env,
+            total_checks=len(results),
+            passed_checks=passed,
+            failed_checks=failed,
+            results=results,
+            duration=datetime.now() - start_time,
+            generated_at=datetime.now(),
+        )
+
+        return report
+
+    async def validate_config(self, env: Environment) -> ValidationResult:
+        """Validate environment configuration."""
+        try:
+            config = self.manager.get_config()
+
+            # Check required fields
+            required_fields = [
+                "name",
+                "environment",
+                "redis_db",
+                "redis_prefix",
+                "api_endpoints",
+                "rate_limits",
+                "max_position_size",
+            ]
+
+            missing = []
+            for field in required_fields:
+                if not hasattr(config, field):
+                    missing.append(field)
+
+            if missing:
+                return ValidationResult(
+                    check_name="config",
+                    passed=False,
+                    message=f"Missing required fields: {missing}",
+                    details={"missing_fields": missing},
+                )
+
+            # Validate field values
+            issues = []
+
+            if config.redis_db < 0 or config.redis_db > 15:
+                issues.append("Redis DB must be between 0 and 15")
+
+            if config.max_position_size < 0 or config.max_position_size > 1:
+                issues.append("Max position size must be between 0 and 1")
+
+            if config.max_daily_trades < 0:
+                issues.append("Max daily trades must be non-negative")
+
+            if issues:
+                return ValidationResult(
+                    check_name="config",
+                    passed=False,
+                    message="Configuration validation issues",
+                    details={"issues": issues},
+                )
+
+            return ValidationResult(
+                check_name="config",
+                passed=True,
+                message="Configuration valid",
+                details={"config": config.name},
+            )
+
+        except Exception as e:
+            return ValidationResult(
+                check_name="config",
+                passed=False,
+                message=f"Configuration validation error: {str(e)}",
+                details={"error": str(e)},
+            )
+
+    async def validate_redis(self, env: Environment) -> ValidationResult:
+        """Validate Redis connectivity."""
+        try:
+            # Test connection
+            connected = await self.redis_manager.ping(env)
+
+            if not connected:
+                return ValidationResult(
+                    check_name="redis",
+                    passed=False,
+                    message="Redis connection failed",
+                    details={"environment": env.value},
+                )
+
+            # Test basic operations
+            test_key = f"validation:test:{env.value}"
+            test_value = f"test_{datetime.now().timestamp()}"
+
+            # Set
+            await self.redis_manager.set_key(
+                test_key, test_value, ttl=60, environment=env
+            )
+
+            # Get
+            retrieved = await self.redis_manager.get_key(test_key, environment=env)
+
+            if retrieved != test_value:
+                return ValidationResult(
+                    check_name="redis",
+                    passed=False,
+                    message="Redis read/write test failed",
+                    details={"expected": test_value, "retrieved": retrieved},
+                )
+
+            # Clean up
+            if env != Environment.PRODUCTION:
+                await self.redis_manager.delete_key(test_key, environment=env)
+
+            return ValidationResult(
+                check_name="redis",
+                passed=True,
+                message="Redis connection and operations successful",
+                details={"db": RedisConfig.for_environment(env).db},
+            )
+
+        except Exception as e:
+            return ValidationResult(
+                check_name="redis",
+                passed=False,
+                message=f"Redis validation error: {str(e)}",
+                details={"error": str(e)},
+            )
+
+    async def validate_api_endpoints(self, env: Environment) -> ValidationResult:
+        """Validate API endpoint configuration."""
+        try:
+            config = self.manager.get_config()
+            endpoints = config.api_endpoints
+
+            if not endpoints:
+                return ValidationResult(
+                    check_name="api",
+                    passed=False,
+                    message="No API endpoints configured",
+                    details={},
+                )
+
+            # Check endpoint formats
+            invalid = []
+            for service, endpoint in endpoints.items():
+                if not endpoint:
+                    invalid.append(f"{service}: empty")
+                elif not (
+                    endpoint.startswith("http://") or endpoint.startswith("https://")
+                ):
+                    invalid.append(f"{service}: invalid protocol")
+
+            if invalid:
+                return ValidationResult(
+                    check_name="api",
+                    passed=False,
+                    message="Invalid API endpoints",
+                    details={"invalid": invalid},
+                )
+
+            # Check production requirements
+            if env == Environment.PRODUCTION:
+                if any(
+                    "localhost" in ep or "127.0.0.1" in ep for ep in endpoints.values()
+                ):
+                    return ValidationResult(
+                        check_name="api",
+                        passed=False,
+                        message="Production cannot use localhost endpoints",
+                        details={"endpoints": endpoints},
+                    )
+
+            return ValidationResult(
+                check_name="api",
+                passed=True,
+                message="API endpoints valid",
+                details={"endpoints": list(endpoints.keys())},
+            )
+
+        except Exception as e:
+            return ValidationResult(
+                check_name="api",
+                passed=False,
+                message=f"API validation error: {str(e)}",
+                details={"error": str(e)},
+            )
+
+    async def validate_guards(self, env: Environment) -> ValidationResult:
+        """Validate environment guards."""
+        try:
+            # Test each guard type
+            guards_tested = []
+            guards_failed = []
+
+            # Rate limit guard
+            rate_guard = RateLimitGuard()
+            allowed, msg = await rate_guard.check_operation("test_op", env)
+            guards_tested.append("rate_limit")
+            if not allowed and env != Environment.PRODUCTION:
+                guards_failed.append(f"rate_limit: {msg}")
+
+            # Data integrity guard
+            integrity_guard = DataIntegrityGuard()
+            allowed, msg = await integrity_guard.check_operation("read_data", env)
+            guards_tested.append("data_integrity")
+            if not allowed:
+                guards_failed.append(f"data_integrity: {msg}")
+
+            # Compliance guard
+            compliance_guard = ComplianceGuard()
+            allowed, msg = await compliance_guard.check_operation("get_status", env)
+            guards_tested.append("compliance")
+            if not allowed:
+                guards_failed.append(f"compliance: {msg}")
+
+            # Resource guard
+            resource_guard = ResourceGuard()
+            allowed, msg = await resource_guard.check_operation("test_op", env)
+            guards_tested.append("resource")
+            if not allowed:
+                guards_failed.append(f"resource: {msg}")
+
+            if guards_failed:
+                return ValidationResult(
+                    check_name="guards",
+                    passed=False,
+                    message="Some guards failed validation",
+                    details={"tested": guards_tested, "failed": guards_failed},
+                )
+
+            return ValidationResult(
+                check_name="guards",
+                passed=True,
+                message="All guards operational",
+                details={"guards_tested": guards_tested},
+            )
+
+        except Exception as e:
+            return ValidationResult(
+                check_name="guards",
+                passed=False,
+                message=f"Guard validation error: {str(e)}",
+                details={"error": str(e)},
+            )
+
+    async def validate_isolation(self, env: Environment) -> ValidationResult:
+        """Validate environment isolation."""
+        try:
+            # Check Redis isolation
+            redis_config = RedisConfig.for_environment(env)
+
+            # Verify different DBs for different environments
+            db_mapping = {}
+            for test_env in Environment:
+                test_config = RedisConfig.for_environment(test_env)
+                if test_config.db in db_mapping:
+                    return ValidationResult(
+                        check_name="isolation",
+                        passed=False,
+                        message="Redis DB collision detected",
+                        details={
+                            "collision": f"{test_env.value} and {db_mapping[test_config.db]} use same DB {test_config.db}"
+                        },
+                    )
+                db_mapping[test_config.db] = test_env.value
+
+            # Check channel isolation
+            test_channel = f"test:channel:{env.value}"
+            allowed = self.redis_manager.is_channel_allowed(test_channel, env)
+
+            # Production should have restricted channels
+            if env == Environment.PRODUCTION:
+                dev_channel = "dev:test"
+                if self.redis_manager.is_channel_allowed(dev_channel, env):
+                    return ValidationResult(
+                        check_name="isolation",
+                        passed=False,
+                        message="Production allows dev channels",
+                        details={"channel": dev_channel},
+                    )
+
+            return ValidationResult(
+                check_name="isolation",
+                passed=True,
+                message="Environment properly isolated",
+                details={"redis_db": redis_config.db, "prefix": redis_config.prefix},
+            )
+
+        except Exception as e:
+            return ValidationResult(
+                check_name="isolation",
+                passed=False,
+                message=f"Isolation validation error: {str(e)}",
+                details={"error": str(e)},
+            )
+
+    async def validate_permissions(self, env: Environment) -> ValidationResult:
+        """Validate environment permissions."""
+        try:
+            config = self.manager.get_config()
+
+            # Check critical operations
+            critical_ops = [
+                "delete_all_data",
+                "reset_positions",
+                "modify_system_config",
+            ]
+
+            issues = []
+
+            for op in critical_ops:
+                allowed, reason = self.manager.can_execute_operation(op)
+
+                # Critical ops should be restricted in production
+                if env == Environment.PRODUCTION and allowed:
+                    issues.append(f"{op} allowed in production")
+
+                # Should be allowed in development
+                if env == Environment.DEVELOPMENT and not allowed:
+                    issues.append(f"{op} blocked in development")
+
+            if issues:
+                return ValidationResult(
+                    check_name="permissions",
+                    passed=False,
+                    message="Permission configuration issues",
+                    details={"issues": issues},
+                )
+
+            # Check authentication requirements
+            if env == Environment.PRODUCTION and not config.require_mfa:
+                return ValidationResult(
+                    check_name="permissions",
+                    passed=False,
+                    message="Production must require MFA",
+                    details={"require_mfa": config.require_mfa},
+                )
+
+            return ValidationResult(
+                check_name="permissions",
+                passed=True,
+                message="Permissions properly configured",
+                details={
+                    "require_confirmation": config.require_confirmation,
+                    "require_mfa": config.require_mfa,
+                },
+            )
+
+        except Exception as e:
+            return ValidationResult(
+                check_name="permissions",
+                passed=False,
+                message=f"Permission validation error: {str(e)}",
+                details={"error": str(e)},
+            )
+
+    async def validate_resources(self, env: Environment) -> ValidationResult:
+        """Validate resource limits."""
+        try:
+            config = self.manager.get_config()
+
+            issues = []
+
+            # Check trading limits
+            if config.max_position_size <= 0:
+                issues.append("Invalid max position size")
+
+            if config.max_daily_trades <= 0:
+                issues.append("Invalid max daily trades")
+
+            # Production should have conservative limits
+            if env == Environment.PRODUCTION:
+                if config.max_position_size > 0.1:  # 10%
+                    issues.append("Production position size too high")
+
+                if config.max_daily_trades > 100:
+                    issues.append("Production daily trade limit too high")
+
+            # Development should have relaxed limits
+            if env == Environment.DEVELOPMENT:
+                if config.max_position_size < 0.5:
+                    issues.append("Development position size too restrictive")
+
+            if issues:
+                return ValidationResult(
+                    check_name="resources",
+                    passed=False,
+                    message="Resource limit issues",
+                    details={"issues": issues},
+                )
+
+            return ValidationResult(
+                check_name="resources",
+                passed=True,
+                message="Resource limits appropriate",
+                details={
+                    "max_position_size": config.max_position_size,
+                    "max_daily_trades": config.max_daily_trades,
+                },
+            )
+
+        except Exception as e:
+            return ValidationResult(
+                check_name="resources",
+                passed=False,
+                message=f"Resource validation error: {str(e)}",
+                details={"error": str(e)},
+            )
+
+    async def validate_data_integrity(self, env: Environment) -> ValidationResult:
+        """Validate data integrity measures."""
+        try:
+            config = self.manager.get_config()
+
+            issues = []
+
+            # Check data retention
+            if config.data_retention_hours <= 0:
+                issues.append("Invalid data retention period")
+
+            # Production should have longer retention
+            if env == Environment.PRODUCTION:
+                if config.data_retention_hours < 168:  # 1 week
+                    issues.append("Production retention too short")
+
+            # Check logging
+            if env == Environment.PRODUCTION and not config.enable_logging:
+                issues.append("Logging must be enabled in production")
+
+            # Check telemetry
+            if env == Environment.PRODUCTION and not config.telemetry_enabled:
+                issues.append("Telemetry should be enabled in production")
+
+            if issues:
+                return ValidationResult(
+                    check_name="data_integrity",
+                    passed=False,
+                    message="Data integrity issues",
+                    details={"issues": issues},
+                )
+
+            return ValidationResult(
+                check_name="data_integrity",
+                passed=True,
+                message="Data integrity measures in place",
+                details={
+                    "retention_hours": config.data_retention_hours,
+                    "logging": config.enable_logging,
+                    "telemetry": config.telemetry_enabled,
+                },
+            )
+
+        except Exception as e:
+            return ValidationResult(
+                check_name="data_integrity",
+                passed=False,
+                message=f"Data integrity validation error: {str(e)}",
+                details={"error": str(e)},
+            )
+
+
+class EnvironmentTester:
+    """Testing utilities for environment transitions."""
+
+    def __init__(self, manager: EnvironmentManager):
+        """Initialize tester."""
+        self.manager = manager
+        self.validator = EnvironmentValidator(manager)
+        self.transition_protocol = ModeTransitionProtocol(manager)
+
+    async def test_transition(
+        self, from_env: Environment, to_env: Environment, dry_run: bool = True
+    ) -> Dict[str, Any]:
+        """Test environment transition."""
+        results = {
+            "from_env": from_env.value,
+            "to_env": to_env.value,
+            "dry_run": dry_run,
+            "tests": [],
+        }
+
+        # Validate source environment
+        from_validation = await self.validator.validate_environment(from_env)
+        results["tests"].append(
+            {
+                "name": f"Validate {from_env.value}",
+                "passed": from_validation.success_rate == 1.0,
+                "details": from_validation.to_dict(),
+            }
+        )
+
+        # Create transition plan
+        plan = self.transition_protocol.create_transition_plan(
+            from_env, to_env, gradual=False
+        )
+
+        results["tests"].append(
+            {
+                "name": "Create transition plan",
+                "passed": True,
+                "details": {
+                    "phases": [p.value for p in plan.phases],
+                    "auth_required": [a.value for a in plan.auth_required],
+                    "estimated_duration": str(plan.estimated_duration),
+                },
+            }
+        )
+
+        # Test guards
+        guard = TransitionGuard()
+        allowed, reason = await guard.check_switch(from_env, to_env)
+
+        results["tests"].append(
+            {
+                "name": "Guard check",
+                "passed": allowed or (not allowed and "forbidden" in reason),
+                "details": {"allowed": allowed, "reason": reason},
+            }
+        )
+
+        # Test data migration (dry run)
+        if plan.data_migration and not dry_run:
+            redis_manager = EnvironmentRedisManager(self.manager)
+            migration_result = await redis_manager.migrate_data(
+                from_env, to_env, pattern="test:*", dry_run=True
+            )
+
+            results["tests"].append(
+                {
+                    "name": "Data migration test",
+                    "passed": migration_result["errors"] == 0,
+                    "details": migration_result,
+                }
+            )
+
+        # Calculate overall result
+        all_passed = all(test["passed"] for test in results["tests"])
+        results["overall_passed"] = all_passed
+        results["recommendation"] = (
+            "Safe to proceed"
+            if all_passed
+            else "Issues detected - review before proceeding"
+        )
+
+        return results
+
+    async def test_isolation(self) -> Dict[str, Any]:
+        """Test environment isolation."""
+        results = {"timestamp": datetime.now().isoformat(), "tests": []}
+
+        # Test Redis isolation
+        redis_manager = EnvironmentRedisManager(self.manager)
+
+        for env in Environment:
+            # Try to access other environment's data
+            test_key = f"isolation_test:{env.value}"
+
+            # Set in one environment
+            await redis_manager.set_key(
+                test_key, f"data_{env.value}", ttl=60, environment=env
+            )
+
+            # Try to read from different environment
+            for other_env in Environment:
+                if other_env != env:
+                    value = await redis_manager.get_key(test_key, environment=other_env)
+
+                    # Should not see other environment's data
+                    if value == f"data_{env.value}":
+                        results["tests"].append(
+                            {
+                                "name": f"Isolation {env.value} from {other_env.value}",
+                                "passed": False,
+                                "message": f"Data leaked from {env.value} to {other_env.value}",
+                            }
+                        )
+                    else:
+                        results["tests"].append(
+                            {
+                                "name": f"Isolation {env.value} from {other_env.value}",
+                                "passed": True,
+                                "message": "Properly isolated",
+                            }
+                        )
+
+        results["overall_passed"] = all(test["passed"] for test in results["tests"])
+        return results
+
+    async def test_guards(self) -> Dict[str, Any]:
+        """Test all environment guards."""
+        results = {"timestamp": datetime.now().isoformat(), "guards": []}
+
+        guards_to_test = [
+            ("RateLimitGuard", RateLimitGuard()),
+            ("DataIntegrityGuard", DataIntegrityGuard()),
+            ("ComplianceGuard", ComplianceGuard()),
+            ("ResourceGuard", ResourceGuard()),
+            ("CrossEnvironmentGuard", CrossEnvironmentGuard()),
+            ("TransitionGuard", TransitionGuard()),
+            ("EmergencyStopGuard", EmergencyStopGuard()),
+        ]
+
+        for guard_name, guard in guards_to_test:
+            guard_results = {"name": guard_name, "tests": []}
+
+            # Test operation checks
+            for env in Environment:
+                allowed, reason = await guard.check_operation("test_operation", env)
+                guard_results["tests"].append(
+                    {
+                        "type": "operation",
+                        "environment": env.value,
+                        "allowed": allowed,
+                        "reason": reason,
+                    }
+                )
+
+            # Test transition checks
+            for from_env in [Environment.DEVELOPMENT, Environment.TRAINING]:
+                for to_env in [Environment.STAGING, Environment.PRODUCTION]:
+                    allowed, reason = await guard.check_switch(from_env, to_env)
+                    guard_results["tests"].append(
+                        {
+                            "type": "transition",
+                            "from": from_env.value,
+                            "to": to_env.value,
+                            "allowed": allowed,
+                            "reason": reason,
+                        }
+                    )
+
+            results["guards"].append(guard_results)
+
+        return results
+
+
+# Pytest fixtures and tests
+@pytest.fixture
+async def env_manager():
+    """Create environment manager for testing."""
+    manager = EnvironmentManager()
+    manager.initialize(Environment.DEVELOPMENT)
+    return manager
+
+
+@pytest.fixture
+async def validator(env_manager):
+    """Create validator for testing."""
+    return EnvironmentValidator(env_manager)
+
+
+@pytest.mark.asyncio
+async def test_environment_validation(validator):
+    """Test environment validation."""
+    report = await validator.validate_environment(Environment.DEVELOPMENT)
+    assert report.total_checks > 0
+    assert report.success_rate >= 0.8  # At least 80% should pass
+
+
+@pytest.mark.asyncio
+async def test_redis_isolation(env_manager):
+    """Test Redis isolation between environments."""
+    tester = EnvironmentTester(env_manager)
+    results = await tester.test_isolation()
+    assert results["overall_passed"]
+
+
+@pytest.mark.asyncio
+async def test_guard_functionality(env_manager):
+    """Test environment guards."""
+    tester = EnvironmentTester(env_manager)
+    results = await tester.test_guards()
+    assert len(results["guards"]) > 0
diff --git a/neural_sdk/core/exceptions.py b/neural_sdk/core/exceptions.py
new file mode 100644
index 00000000..282b7989
--- /dev/null
+++ b/neural_sdk/core/exceptions.py
@@ -0,0 +1,106 @@
+"""
+Custom exceptions for the Neural Trading SDK.
+
+This module defines all custom exceptions used throughout the SDK
+to provide clear error messages and proper error handling.
+"""
+
+from typing import Any, Optional
+
+
+class SDKError(Exception):
+    """Base exception for all SDK errors."""
+
+    def __init__(self, message: str, details: Optional[dict[str, Any]] = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.details = details or {}
+
+
+class ConfigurationError(SDKError):
+    """Raised when there's a configuration error."""
+
+    def __init__(self, message: str, config_key: Optional[str] = None) -> None:
+        super().__init__(message, {"config_key": config_key} if config_key else None)
+        self.config_key = config_key
+
+
+class ConnectionError(SDKError):
+    """Raised when there's a connection error."""
+
+    def __init__(
+        self, message: str, service: Optional[str] = None, retry_count: int = 0
+    ) -> None:
+        super().__init__(message, {"service": service, "retry_count": retry_count})
+        self.service = service
+        self.retry_count = retry_count
+
+
+class TradingError(SDKError):
+    """Raised when there's a trading-related error."""
+
+    def __init__(
+        self,
+        message: str,
+        market_ticker: Optional[str] = None,
+        order_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(
+            message, {"market_ticker": market_ticker, "order_id": order_id}
+        )
+        self.market_ticker = market_ticker
+        self.order_id = order_id
+
+
+class ValidationError(SDKError):
+    """Raised when there's a validation error."""
+
+    def __init__(
+        self, message: str, field: Optional[str] = None, value: Optional[Any] = None
+    ) -> None:
+        super().__init__(message, {"field": field, "value": value})
+        self.field = field
+        self.value = value
+
+
+class AuthenticationError(SDKError):
+    """Raised when there's an authentication error."""
+
+    def __init__(self, message: str, service: Optional[str] = None) -> None:
+        super().__init__(message, {"service": service})
+        self.service = service
+
+
+class RateLimitError(SDKError):
+    """Raised when rate limits are exceeded."""
+
+    def __init__(self, message: str, retry_after: Optional[int] = None) -> None:
+        super().__init__(message, {"retry_after": retry_after})
+        self.retry_after = retry_after
+
+
+class InsufficientFundsError(TradingError):
+    """Raised when there are insufficient funds for a trade."""
+
+    def __init__(self, message: str, required: float, available: float) -> None:
+        super().__init__(message, None, None)
+        self.required = required
+        self.available = available
+        self.details.update({"required": required, "available": available})
+
+
+class MarketNotFoundError(TradingError):
+    """Raised when a market is not found."""
+
+    def __init__(self, message: str, market_ticker: str) -> None:
+        super().__init__(message, market_ticker, None)
+        self.market_ticker = market_ticker
+
+
+class OrderRejectedError(TradingError):
+    """Raised when an order is rejected."""
+
+    def __init__(self, message: str, market_ticker: str, reason: str) -> None:
+        super().__init__(message, market_ticker, None)
+        self.reason = reason
+        self.details["reason"] = reason
diff --git a/neural_sdk/core/redis_config.py b/neural_sdk/core/redis_config.py
new file mode 100644
index 00000000..d8beef16
--- /dev/null
+++ b/neural_sdk/core/redis_config.py
@@ -0,0 +1,512 @@
+"""
+Environment-specific Redis Configuration
+
+Manages Redis connections and configurations for different environments
+with proper isolation and safety mechanisms.
+"""
+
+import asyncio
+import json
+import os
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+import redis.asyncio as redis
+from redis.asyncio import ConnectionPool
+from redis.asyncio.sentinel import Sentinel
+
+from .environment_manager import Environment, EnvironmentManager
+
+
+@dataclass
+class RedisConfig:
+    """Redis configuration for an environment."""
+
+    host: str
+    port: int
+    db: int
+    password: Optional[str]
+    prefix: str
+    max_connections: int
+    socket_timeout: int
+    socket_connect_timeout: int
+    socket_keepalive: bool
+    socket_keepalive_options: Dict[str, Any]
+    connection_pool_class: str
+    ssl: bool
+    ssl_certfile: Optional[str]
+    ssl_keyfile: Optional[str]
+    ssl_ca_certs: Optional[str]
+    sentinel_hosts: List[Tuple[str, int]]
+    sentinel_service_name: Optional[str]
+    cluster_mode: bool
+
+    @classmethod
+    def for_environment(cls, env: Environment) -> "RedisConfig":
+        """Get Redis configuration for environment."""
+        base_config = {
+            "host": os.getenv("REDIS_HOST", "localhost"),
+            "port": int(os.getenv("REDIS_PORT", 6379)),
+            "password": os.getenv("REDIS_PASSWORD"),
+            "max_connections": 50,
+            "socket_timeout": 5,
+            "socket_connect_timeout": 5,
+            "socket_keepalive": True,
+            "socket_keepalive_options": {},
+            "connection_pool_class": "BlockingConnectionPool",
+            "ssl": False,
+            "ssl_certfile": None,
+            "ssl_keyfile": None,
+            "ssl_ca_certs": None,
+            "sentinel_hosts": [],
+            "sentinel_service_name": None,
+            "cluster_mode": False,
+        }
+
+        # Environment-specific configurations
+        if env == Environment.PRODUCTION:
+            config = base_config.copy()
+            config.update(
+                {
+                    "db": 0,
+                    "prefix": "prod:",
+                    "max_connections": 100,
+                    "ssl": True,
+                    "ssl_ca_certs": os.getenv("REDIS_SSL_CA"),
+                    "sentinel_hosts": cls._parse_sentinel_hosts(
+                        os.getenv("REDIS_SENTINELS", "")
+                    ),
+                    "sentinel_service_name": "production-master",
+                    "cluster_mode": True,
+                }
+            )
+            return cls(**config)
+
+        elif env == Environment.STAGING:
+            config = base_config.copy()
+            config.update(
+                {
+                    "db": 1,
+                    "prefix": "staging:",
+                    "max_connections": 75,
+                    "ssl": True,
+                    "ssl_ca_certs": os.getenv("REDIS_SSL_CA"),
+                }
+            )
+            return cls(**config)
+
+        elif env == Environment.SANDBOX:
+            config = base_config.copy()
+            config.update({"db": 2, "prefix": "sandbox:", "max_connections": 50})
+            return cls(**config)
+
+        elif env == Environment.TRAINING:
+            config = base_config.copy()
+            config.update(
+                {
+                    "db": 3,
+                    "prefix": "training:",
+                    "max_connections": 200,  # Higher for parallel training
+                    "socket_timeout": 10,  # Longer timeout for training ops
+                }
+            )
+            return cls(**config)
+
+        else:  # DEVELOPMENT
+            config = base_config.copy()
+            config.update({"db": 4, "prefix": "dev:", "max_connections": 25})
+            return cls(**config)
+
+    @staticmethod
+    def _parse_sentinel_hosts(hosts_str: str) -> List[Tuple[str, int]]:
+        """Parse sentinel hosts from string."""
+        hosts = []
+        if hosts_str:
+            for host in hosts_str.split(","):
+                if ":" in host:
+                    h, p = host.split(":")
+                    hosts.append((h.strip(), int(p)))
+        return hosts
+
+    def to_connection_kwargs(self) -> Dict[str, Any]:
+        """Convert to Redis connection kwargs."""
+        kwargs = {
+            "host": self.host,
+            "port": self.port,
+            "db": self.db,
+            "password": self.password,
+            "socket_timeout": self.socket_timeout,
+            "socket_connect_timeout": self.socket_connect_timeout,
+            "socket_keepalive": self.socket_keepalive,
+            "socket_keepalive_options": self.socket_keepalive_options,
+            "max_connections": self.max_connections,
+        }
+
+        if self.ssl:
+            kwargs["ssl"] = True
+            if self.ssl_certfile:
+                kwargs["ssl_certfile"] = self.ssl_certfile
+            if self.ssl_keyfile:
+                kwargs["ssl_keyfile"] = self.ssl_keyfile
+            if self.ssl_ca_certs:
+                kwargs["ssl_ca_certs"] = self.ssl_ca_certs
+
+        return kwargs
+
+
+class EnvironmentRedisManager:
+    """Manages Redis connections for different environments."""
+
+    def __init__(self, env_manager: EnvironmentManager):
+        """Initialize Redis manager."""
+        self.env_manager = env_manager
+        self._connections: Dict[Environment, redis.Redis] = {}
+        self._pools: Dict[Environment, ConnectionPool] = {}
+        self._sentinels: Dict[Environment, Sentinel] = {}
+        self._pubsub_connections: Dict[str, redis.client.PubSub] = {}
+        self._channel_isolation: bool = True
+        self._allowed_channels: Dict[Environment, Set[str]] = {
+            Environment.PRODUCTION: {"prod:*", "market:*", "trade:*", "risk:*"},
+            Environment.STAGING: {"staging:*", "test:*", "market:*"},
+            Environment.SANDBOX: {"sandbox:*", "demo:*", "test:*"},
+            Environment.TRAINING: {"training:*", "synthetic:*", "replay:*"},
+            Environment.DEVELOPMENT: {"*"},  # All channels allowed in dev
+        }
+
+    async def get_connection(
+        self, environment: Optional[Environment] = None
+    ) -> redis.Redis:
+        """Get Redis connection for environment."""
+        env = environment or self.env_manager.get_current_environment()
+
+        if env not in self._connections:
+            config = RedisConfig.for_environment(env)
+
+            # Use sentinel if configured
+            if config.sentinel_hosts:
+                conn = await self._create_sentinel_connection(env, config)
+            # Use cluster if configured
+            elif config.cluster_mode:
+                conn = await self._create_cluster_connection(env, config)
+            # Use standard connection
+            else:
+                conn = await self._create_standard_connection(env, config)
+
+            self._connections[env] = conn
+
+        return self._connections[env]
+
+    async def _create_standard_connection(
+        self, env: Environment, config: RedisConfig
+    ) -> redis.Redis:
+        """Create standard Redis connection."""
+        # Create connection pool
+        if env not in self._pools:
+            pool_class = getattr(redis, config.connection_pool_class)
+            self._pools[env] = pool_class(**config.to_connection_kwargs())
+
+        return redis.Redis(connection_pool=self._pools[env])
+
+    async def _create_sentinel_connection(
+        self, env: Environment, config: RedisConfig
+    ) -> redis.Redis:
+        """Create sentinel-based Redis connection."""
+        if env not in self._sentinels:
+            self._sentinels[env] = Sentinel(
+                config.sentinel_hosts, socket_timeout=config.socket_timeout
+            )
+
+        # Get master from sentinel
+        master = self._sentinels[env].master_for(
+            config.sentinel_service_name,
+            socket_timeout=config.socket_timeout,
+            db=config.db,
+            password=config.password,
+        )
+
+        return master
+
+    async def _create_cluster_connection(
+        self, env: Environment, config: RedisConfig
+    ) -> redis.Redis:
+        """Create cluster Redis connection."""
+        # Simplified - in production use redis.cluster.RedisCluster
+        return await self._create_standard_connection(env, config)
+
+    async def get_pubsub(
+        self, channels: List[str], environment: Optional[Environment] = None
+    ) -> redis.client.PubSub:
+        """Get pub/sub connection for channels."""
+        env = environment or self.env_manager.get_current_environment()
+
+        # Validate channels if isolation enabled
+        if self._channel_isolation:
+            valid, invalid = self._validate_channels(env, channels)
+            if invalid:
+                raise ValueError(f"Channels not allowed in {env.value}: {invalid}")
+
+        # Create unique key for this subscription
+        sub_key = f"{env.value}:{','.join(sorted(channels))}"
+
+        if sub_key not in self._pubsub_connections:
+            conn = await self.get_connection(env)
+            pubsub = conn.pubsub()
+
+            # Subscribe to channels
+            for channel in channels:
+                await pubsub.subscribe(channel)
+
+            self._pubsub_connections[sub_key] = pubsub
+
+        return self._pubsub_connections[sub_key]
+
+    def _validate_channels(
+        self, env: Environment, channels: List[str]
+    ) -> Tuple[List[str], List[str]]:
+        """Validate channels for environment."""
+        allowed = self._allowed_channels.get(env, set())
+        valid = []
+        invalid = []
+
+        for channel in channels:
+            # Check if channel matches any allowed pattern
+            is_valid = False
+            for pattern in allowed:
+                if pattern == "*" or self._matches_pattern(channel, pattern):
+                    is_valid = True
+                    break
+
+            if is_valid:
+                valid.append(channel)
+            else:
+                invalid.append(channel)
+
+        return valid, invalid
+
+    def _matches_pattern(self, channel: str, pattern: str) -> bool:
+        """Check if channel matches pattern."""
+        if "*" in pattern:
+            prefix = pattern.replace("*", "")
+            return channel.startswith(prefix)
+        return channel == pattern
+
+    async def publish(
+        self, channel: str, message: Any, environment: Optional[Environment] = None
+    ) -> int:
+        """Publish message to channel."""
+        env = environment or self.env_manager.get_current_environment()
+
+        # Validate channel
+        if self._channel_isolation:
+            valid, _ = self._validate_channels(env, [channel])
+            if not valid:
+                raise ValueError(f"Channel '{channel}' not allowed in {env.value}")
+
+        # Get connection and publish
+        conn = await self.get_connection(env)
+
+        # Add environment prefix if not present
+        config = RedisConfig.for_environment(env)
+        if not channel.startswith(config.prefix):
+            channel = f"{config.prefix}{channel}"
+
+        # Serialize message
+        if not isinstance(message, (str, bytes)):
+            message = json.dumps(message)
+
+        return await conn.publish(channel, message)
+
+    async def get_key(
+        self, key: str, environment: Optional[Environment] = None
+    ) -> Optional[str]:
+        """Get value for key."""
+        env = environment or self.env_manager.get_current_environment()
+        conn = await self.get_connection(env)
+
+        # Add environment prefix
+        config = RedisConfig.for_environment(env)
+        if not key.startswith(config.prefix):
+            key = f"{config.prefix}{key}"
+
+        return await conn.get(key)
+
+    async def set_key(
+        self,
+        key: str,
+        value: Any,
+        ttl: Optional[int] = None,
+        environment: Optional[Environment] = None,
+    ) -> bool:
+        """Set value for key."""
+        env = environment or self.env_manager.get_current_environment()
+        conn = await self.get_connection(env)
+
+        # Add environment prefix
+        config = RedisConfig.for_environment(env)
+        if not key.startswith(config.prefix):
+            key = f"{config.prefix}{key}"
+
+        # Serialize value if needed
+        if not isinstance(value, (str, bytes)):
+            value = json.dumps(value)
+
+        if ttl:
+            return await conn.setex(key, ttl, value)
+        else:
+            return await conn.set(key, value)
+
+    async def delete_key(
+        self, key: str, environment: Optional[Environment] = None
+    ) -> int:
+        """Delete key."""
+        env = environment or self.env_manager.get_current_environment()
+
+        # Check if deletion is allowed
+        if env == Environment.PRODUCTION:
+            raise PermissionError("Key deletion not allowed in production")
+
+        conn = await self.get_connection(env)
+
+        # Add environment prefix
+        config = RedisConfig.for_environment(env)
+        if not key.startswith(config.prefix):
+            key = f"{config.prefix}{key}"
+
+        return await conn.delete(key)
+
+    async def flush_db(
+        self, environment: Optional[Environment] = None, force: bool = False
+    ) -> bool:
+        """Flush database for environment."""
+        env = environment or self.env_manager.get_current_environment()
+
+        # Safety checks
+        if env == Environment.PRODUCTION and not force:
+            raise PermissionError("Cannot flush production database without force flag")
+
+        if env in [Environment.PRODUCTION, Environment.STAGING]:
+            # Require additional confirmation
+            confirm = input(f"Type 'FLUSH {env.value.upper()}' to confirm: ")
+            if confirm != f"FLUSH {env.value.upper()}":
+                return False
+
+        conn = await self.get_connection(env)
+        await conn.flushdb()
+        return True
+
+    async def get_info(
+        self, section: Optional[str] = None, environment: Optional[Environment] = None
+    ) -> Dict[str, Any]:
+        """Get Redis server info."""
+        env = environment or self.env_manager.get_current_environment()
+        conn = await self.get_connection(env)
+
+        info = await conn.info(section) if section else await conn.info()
+        return info
+
+    async def ping(self, environment: Optional[Environment] = None) -> bool:
+        """Ping Redis server."""
+        env = environment or self.env_manager.get_current_environment()
+        conn = await self.get_connection(env)
+
+        try:
+            return await conn.ping()
+        except Exception:
+            return False
+
+    async def close_all(self) -> None:
+        """Close all connections."""
+        # Close pub/sub connections
+        for pubsub in self._pubsub_connections.values():
+            await pubsub.close()
+        self._pubsub_connections.clear()
+
+        # Close regular connections
+        for conn in self._connections.values():
+            await conn.close()
+        self._connections.clear()
+
+        # Close pools
+        for pool in self._pools.values():
+            await pool.disconnect()
+        self._pools.clear()
+
+    async def migrate_data(
+        self,
+        from_env: Environment,
+        to_env: Environment,
+        pattern: str = "*",
+        dry_run: bool = True,
+    ) -> Dict[str, Any]:
+        """Migrate data between environments."""
+        # Safety check
+        if to_env == Environment.PRODUCTION and not dry_run:
+            raise PermissionError("Cannot migrate to production without dry run first")
+
+        from_conn = await self.get_connection(from_env)
+        to_conn = await self.get_connection(to_env)
+
+        from_config = RedisConfig.for_environment(from_env)
+        to_config = RedisConfig.for_environment(to_env)
+
+        # Find keys to migrate
+        search_pattern = f"{from_config.prefix}{pattern}"
+        keys = []
+        cursor = 0
+
+        while True:
+            cursor, batch = await from_conn.scan(
+                cursor, match=search_pattern, count=100
+            )
+            keys.extend(batch)
+            if cursor == 0:
+                break
+
+        migrated = []
+        errors = []
+
+        for key in keys:
+            try:
+                # Get value and TTL
+                value = await from_conn.get(key)
+                ttl = await from_conn.ttl(key)
+
+                if not dry_run:
+                    # Transform key for new environment
+                    new_key = key.replace(from_config.prefix, to_config.prefix)
+
+                    # Set in new environment
+                    if ttl > 0:
+                        await to_conn.setex(new_key, ttl, value)
+                    else:
+                        await to_conn.set(new_key, value)
+
+                migrated.append(key)
+
+            except Exception as e:
+                errors.append({"key": key, "error": str(e)})
+
+        return {
+            "total_keys": len(keys),
+            "migrated": len(migrated),
+            "errors": len(errors),
+            "dry_run": dry_run,
+            "from_env": from_env.value,
+            "to_env": to_env.value,
+            "error_details": errors[:10],  # First 10 errors
+        }
+
+    def get_channel_prefix(self, environment: Optional[Environment] = None) -> str:
+        """Get channel prefix for environment."""
+        env = environment or self.env_manager.get_current_environment()
+        config = RedisConfig.for_environment(env)
+        return config.prefix
+
+    def is_channel_allowed(
+        self, channel: str, environment: Optional[Environment] = None
+    ) -> bool:
+        """Check if channel is allowed in environment."""
+        env = environment or self.env_manager.get_current_environment()
+        valid, _ = self._validate_channels(env, [channel])
+        return len(valid) > 0
diff --git a/neural_sdk/core/transition_protocol.py b/neural_sdk/core/transition_protocol.py
new file mode 100644
index 00000000..2558a339
--- /dev/null
+++ b/neural_sdk/core/transition_protocol.py
@@ -0,0 +1,699 @@
+"""
+Mode Transition Protocol
+
+Manages safe transitions between training and production modes
+with authentication, validation, and rollback capabilities.
+"""
+
+import asyncio
+import hashlib
+import json
+import os
+import secrets
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import pyotp
+import redis.asyncio as redis
+
+from .environment_manager import Environment, EnvironmentManager
+
+
+class TransitionPhase(Enum):
+    """Phases of environment transition."""
+
+    VALIDATION = "validation"
+    PREPARATION = "preparation"
+    MIGRATION = "migration"
+    VERIFICATION = "verification"
+    ACTIVATION = "activation"
+    MONITORING = "monitoring"
+    COMPLETE = "complete"
+    ROLLBACK = "rollback"
+
+
+class AuthenticationMethod(Enum):
+    """Authentication methods for transitions."""
+
+    NONE = "none"
+    PASSWORD = "password"
+    MFA_TOTP = "mfa_totp"
+    MFA_SMS = "mfa_sms"
+    API_KEY = "api_key"
+    HARDWARE_TOKEN = "hardware_token"
+
+
+@dataclass
+class TransitionCheckpoint:
+    """Checkpoint in transition process."""
+
+    phase: TransitionPhase
+    timestamp: datetime
+    status: str
+    details: Dict[str, Any]
+    can_rollback: bool
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "phase": self.phase.value,
+            "timestamp": self.timestamp.isoformat(),
+            "status": self.status,
+            "details": self.details,
+            "can_rollback": self.can_rollback,
+        }
+
+
+@dataclass
+class TransitionPlan:
+    """Plan for environment transition."""
+
+    id: str
+    from_env: Environment
+    to_env: Environment
+    phases: List[TransitionPhase]
+    auth_required: List[AuthenticationMethod]
+    estimated_duration: timedelta
+    rollback_points: List[TransitionPhase]
+    validation_checks: List[str]
+    data_migration: bool
+    gradual_rollout: bool
+    rollout_percentage: float = 0.0
+
+    def get_next_phase(self, current: TransitionPhase) -> Optional[TransitionPhase]:
+        """Get next phase in plan."""
+        try:
+            current_index = self.phases.index(current)
+            if current_index < len(self.phases) - 1:
+                return self.phases[current_index + 1]
+        except ValueError:
+            pass
+        return None
+
+    def can_rollback_from(self, phase: TransitionPhase) -> bool:
+        """Check if rollback is possible from phase."""
+        return phase in self.rollback_points
+
+
+@dataclass
+class TransitionState:
+    """Current state of transition."""
+
+    plan: TransitionPlan
+    current_phase: TransitionPhase
+    started_at: datetime
+    checkpoints: List[TransitionCheckpoint] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    authenticated: bool = False
+    auth_methods_completed: List[AuthenticationMethod] = field(default_factory=list)
+    rollback_initiated: bool = False
+
+    def add_checkpoint(
+        self,
+        phase: TransitionPhase,
+        status: str,
+        details: Dict[str, Any],
+        can_rollback: bool = True,
+    ) -> None:
+        """Add checkpoint to transition."""
+        checkpoint = TransitionCheckpoint(
+            phase=phase,
+            timestamp=datetime.now(),
+            status=status,
+            details=details,
+            can_rollback=can_rollback,
+        )
+        self.checkpoints.append(checkpoint)
+
+    def get_duration(self) -> timedelta:
+        """Get transition duration."""
+        return datetime.now() - self.started_at
+
+    def is_complete(self) -> bool:
+        """Check if transition is complete."""
+        return self.current_phase == TransitionPhase.COMPLETE
+
+    def is_failed(self) -> bool:
+        """Check if transition has failed."""
+        return self.rollback_initiated or len(self.errors) > 0
+
+
+class AuthenticationProvider:
+    """Provider for authentication services."""
+
+    def __init__(self):
+        """Initialize authentication provider."""
+        self.totp_secrets: Dict[str, str] = {}
+        self.api_keys: Dict[str, str] = {}
+        self.session_tokens: Dict[str, datetime] = {}
+
+    def setup_totp(self, user_id: str) -> str:
+        """Setup TOTP for user."""
+        secret = pyotp.random_base32()
+        self.totp_secrets[user_id] = secret
+
+        # Generate provisioning URI for QR code
+        totp = pyotp.TOTP(secret)
+        provisioning_uri = totp.provisioning_uri(
+            name=user_id, issuer_name="Neural Trading Agent"
+        )
+
+        return provisioning_uri
+
+    def verify_totp(self, user_id: str, token: str) -> bool:
+        """Verify TOTP token."""
+        if user_id not in self.totp_secrets:
+            return False
+
+        totp = pyotp.TOTP(self.totp_secrets[user_id])
+        return totp.verify(token, valid_window=1)
+
+    def generate_api_key(self, user_id: str) -> str:
+        """Generate API key for user."""
+        key = secrets.token_urlsafe(32)
+        self.api_keys[user_id] = key
+        return key
+
+    def verify_api_key(self, user_id: str, key: str) -> bool:
+        """Verify API key."""
+        return self.api_keys.get(user_id) == key
+
+    def create_session(self, user_id: str) -> str:
+        """Create authenticated session."""
+        token = secrets.token_urlsafe(32)
+        self.session_tokens[token] = datetime.now()
+        return token
+
+    def verify_session(
+        self, token: str, max_age: timedelta = timedelta(hours=1)
+    ) -> bool:
+        """Verify session token."""
+        if token not in self.session_tokens:
+            return False
+
+        age = datetime.now() - self.session_tokens[token]
+        return age < max_age
+
+
+class ModeTransitionProtocol:
+    """Protocol for managing mode transitions."""
+
+    def __init__(
+        self,
+        manager: EnvironmentManager,
+        auth_provider: Optional[AuthenticationProvider] = None,
+    ):
+        """Initialize transition protocol."""
+        self.manager = manager
+        self.auth_provider = auth_provider or AuthenticationProvider()
+        self.active_transitions: Dict[str, TransitionState] = {}
+        self.completed_transitions: List[TransitionState] = []
+        self.transition_hooks: Dict[TransitionPhase, List[Callable]] = defaultdict(list)
+        self.rollback_handlers: Dict[TransitionPhase, Callable] = {}
+
+    def create_transition_plan(
+        self, from_env: Environment, to_env: Environment, gradual: bool = False
+    ) -> TransitionPlan:
+        """Create transition plan between environments."""
+        plan_id = f"{from_env.value}-to-{to_env.value}-{int(time.time())}"
+
+        # Determine required phases
+        phases = [TransitionPhase.VALIDATION]
+
+        # Add authentication phase for production
+        if to_env == Environment.PRODUCTION:
+            phases.append(TransitionPhase.PREPARATION)
+
+        # Add migration if needed
+        if self._needs_data_migration(from_env, to_env):
+            phases.append(TransitionPhase.MIGRATION)
+
+        phases.extend(
+            [
+                TransitionPhase.VERIFICATION,
+                TransitionPhase.ACTIVATION,
+                TransitionPhase.MONITORING,
+                TransitionPhase.COMPLETE,
+            ]
+        )
+
+        # Determine authentication requirements
+        auth_required = self._get_auth_requirements(from_env, to_env)
+
+        # Determine rollback points
+        rollback_points = [
+            TransitionPhase.VALIDATION,
+            TransitionPhase.PREPARATION,
+            TransitionPhase.MIGRATION,
+            TransitionPhase.VERIFICATION,
+        ]
+
+        # Validation checks
+        validation_checks = self._get_validation_checks(from_env, to_env)
+
+        # Estimate duration
+        duration = self._estimate_duration(from_env, to_env, gradual)
+
+        return TransitionPlan(
+            id=plan_id,
+            from_env=from_env,
+            to_env=to_env,
+            phases=phases,
+            auth_required=auth_required,
+            estimated_duration=duration,
+            rollback_points=rollback_points,
+            validation_checks=validation_checks,
+            data_migration=self._needs_data_migration(from_env, to_env),
+            gradual_rollout=gradual,
+            rollout_percentage=0.0 if gradual else 100.0,
+        )
+
+    def _needs_data_migration(self, from_env: Environment, to_env: Environment) -> bool:
+        """Check if data migration is needed."""
+        # Migration needed when moving to/from production
+        return from_env == Environment.PRODUCTION or to_env == Environment.PRODUCTION
+
+    def _get_auth_requirements(
+        self, from_env: Environment, to_env: Environment
+    ) -> List[AuthenticationMethod]:
+        """Get authentication requirements for transition."""
+        if to_env == Environment.PRODUCTION:
+            return [AuthenticationMethod.PASSWORD, AuthenticationMethod.MFA_TOTP]
+        elif to_env == Environment.STAGING:
+            return [AuthenticationMethod.PASSWORD]
+        else:
+            return []
+
+    def _get_validation_checks(
+        self, from_env: Environment, to_env: Environment
+    ) -> List[str]:
+        """Get validation checks for transition."""
+        checks = ["system_health", "dependency_check"]
+
+        if to_env == Environment.PRODUCTION:
+            checks.extend(
+                [
+                    "risk_parameters",
+                    "api_connectivity",
+                    "backup_verification",
+                    "emergency_procedures",
+                ]
+            )
+
+        if from_env == Environment.TRAINING:
+            checks.append("model_validation")
+
+        return checks
+
+    def _estimate_duration(
+        self, from_env: Environment, to_env: Environment, gradual: bool
+    ) -> timedelta:
+        """Estimate transition duration."""
+        base_duration = timedelta(minutes=5)
+
+        if to_env == Environment.PRODUCTION:
+            base_duration = timedelta(minutes=30)
+
+        if gradual:
+            base_duration *= 3  # Gradual rollout takes longer
+
+        if self._needs_data_migration(from_env, to_env):
+            base_duration += timedelta(minutes=15)
+
+        return base_duration
+
+    async def start_transition(
+        self, plan: TransitionPlan, user_id: str
+    ) -> Tuple[bool, str]:
+        """Start environment transition."""
+        # Check if transition already active
+        if plan.id in self.active_transitions:
+            return False, "Transition already in progress"
+
+        # Create transition state
+        state = TransitionState(
+            plan=plan,
+            current_phase=TransitionPhase.VALIDATION,
+            started_at=datetime.now(),
+        )
+
+        self.active_transitions[plan.id] = state
+
+        # Start validation phase
+        success = await self._execute_phase(state, TransitionPhase.VALIDATION)
+
+        if not success:
+            return False, "Validation failed"
+
+        return True, f"Transition {plan.id} started"
+
+    async def authenticate_transition(
+        self,
+        plan_id: str,
+        user_id: str,
+        method: AuthenticationMethod,
+        credentials: Dict[str, str],
+    ) -> Tuple[bool, str]:
+        """Authenticate for transition."""
+        if plan_id not in self.active_transitions:
+            return False, "Transition not found"
+
+        state = self.active_transitions[plan_id]
+
+        # Verify authentication
+        authenticated = False
+
+        if method == AuthenticationMethod.PASSWORD:
+            # Verify password (simplified - use proper password hashing)
+            authenticated = credentials.get("password") == os.getenv(
+                "TRANSITION_PASSWORD"
+            )
+
+        elif method == AuthenticationMethod.MFA_TOTP:
+            token = credentials.get("token", "")
+            authenticated = self.auth_provider.verify_totp(user_id, token)
+
+        elif method == AuthenticationMethod.API_KEY:
+            key = credentials.get("api_key", "")
+            authenticated = self.auth_provider.verify_api_key(user_id, key)
+
+        if authenticated:
+            state.auth_methods_completed.append(method)
+
+            # Check if all required auth completed
+            if set(state.auth_methods_completed) >= set(state.plan.auth_required):
+                state.authenticated = True
+                return True, "Authentication complete"
+            else:
+                remaining = set(state.plan.auth_required) - set(
+                    state.auth_methods_completed
+                )
+                return True, f"Authentication successful. Remaining: {remaining}"
+
+        return False, f"Authentication failed for {method.value}"
+
+    async def continue_transition(self, plan_id: str) -> Tuple[bool, str]:
+        """Continue transition to next phase."""
+        if plan_id not in self.active_transitions:
+            return False, "Transition not found"
+
+        state = self.active_transitions[plan_id]
+
+        # Check authentication
+        if state.plan.auth_required and not state.authenticated:
+            return False, "Authentication required"
+
+        # Get next phase
+        next_phase = state.plan.get_next_phase(state.current_phase)
+
+        if not next_phase:
+            return False, "No next phase available"
+
+        # Execute next phase
+        success = await self._execute_phase(state, next_phase)
+
+        if success:
+            state.current_phase = next_phase
+
+            # Check if complete
+            if state.is_complete():
+                self._complete_transition(plan_id)
+                return True, "Transition complete"
+
+            return True, f"Advanced to {next_phase.value}"
+        else:
+            return False, f"Failed to execute {next_phase.value}"
+
+    async def _execute_phase(
+        self, state: TransitionState, phase: TransitionPhase
+    ) -> bool:
+        """Execute transition phase."""
+        try:
+            # Run phase hooks
+            for hook in self.transition_hooks[phase]:
+                await hook(state)
+
+            # Phase-specific execution
+            if phase == TransitionPhase.VALIDATION:
+                return await self._validate_transition(state)
+
+            elif phase == TransitionPhase.PREPARATION:
+                return await self._prepare_transition(state)
+
+            elif phase == TransitionPhase.MIGRATION:
+                return await self._migrate_data(state)
+
+            elif phase == TransitionPhase.VERIFICATION:
+                return await self._verify_transition(state)
+
+            elif phase == TransitionPhase.ACTIVATION:
+                return await self._activate_environment(state)
+
+            elif phase == TransitionPhase.MONITORING:
+                return await self._monitor_transition(state)
+
+            elif phase == TransitionPhase.COMPLETE:
+                return True
+
+            else:
+                return False
+
+        except Exception as e:
+            state.errors.append(f"Phase {phase.value} failed: {str(e)}")
+            return False
+
+    async def _validate_transition(self, state: TransitionState) -> bool:
+        """Validate transition readiness."""
+        results = {}
+
+        for check in state.plan.validation_checks:
+            # Run validation check
+            if check == "system_health":
+                results[check] = await self._check_system_health()
+            elif check == "dependency_check":
+                results[check] = await self._check_dependencies()
+            elif check == "risk_parameters":
+                results[check] = await self._check_risk_parameters()
+            elif check == "api_connectivity":
+                results[check] = await self._check_api_connectivity()
+            elif check == "backup_verification":
+                results[check] = await self._verify_backups()
+            elif check == "emergency_procedures":
+                results[check] = await self._check_emergency_procedures()
+            elif check == "model_validation":
+                results[check] = await self._validate_models()
+            else:
+                results[check] = True
+
+        # Check if all passed
+        all_passed = all(results.values())
+
+        state.add_checkpoint(
+            TransitionPhase.VALIDATION,
+            "passed" if all_passed else "failed",
+            results,
+            can_rollback=True,
+        )
+
+        return all_passed
+
+    async def _prepare_transition(self, state: TransitionState) -> bool:
+        """Prepare for transition."""
+        # Create backups
+        backup_created = await self._create_backup(state.plan.from_env)
+
+        # Prepare new environment
+        env_prepared = await self._prepare_environment(state.plan.to_env)
+
+        state.add_checkpoint(
+            TransitionPhase.PREPARATION,
+            "complete" if (backup_created and env_prepared) else "failed",
+            {"backup_created": backup_created, "environment_prepared": env_prepared},
+            can_rollback=True,
+        )
+
+        return backup_created and env_prepared
+
+    async def _migrate_data(self, state: TransitionState) -> bool:
+        """Migrate data between environments."""
+        if not state.plan.data_migration:
+            return True
+
+        # Simplified data migration
+        migrated = await self._copy_data(state.plan.from_env, state.plan.to_env)
+
+        state.add_checkpoint(
+            TransitionPhase.MIGRATION,
+            "complete" if migrated else "failed",
+            {"data_migrated": migrated},
+            can_rollback=True,
+        )
+
+        return migrated
+
+    async def _verify_transition(self, state: TransitionState) -> bool:
+        """Verify transition integrity."""
+        # Run verification tests
+        tests_passed = await self._run_verification_tests(state.plan.to_env)
+
+        state.add_checkpoint(
+            TransitionPhase.VERIFICATION,
+            "passed" if tests_passed else "failed",
+            {"tests_passed": tests_passed},
+            can_rollback=True,
+        )
+
+        return tests_passed
+
+    async def _activate_environment(self, state: TransitionState) -> bool:
+        """Activate new environment."""
+        # Switch environment
+        success, message = await self.manager.switch_environment(
+            state.plan.to_env, force=True
+        )
+
+        state.add_checkpoint(
+            TransitionPhase.ACTIVATION,
+            "active" if success else "failed",
+            {"switch_result": message},
+            can_rollback=False,  # Cannot rollback after activation
+        )
+
+        return success
+
+    async def _monitor_transition(self, state: TransitionState) -> bool:
+        """Monitor transition for issues."""
+        # Monitor for specified duration
+        monitor_duration = min(timedelta(minutes=5), state.plan.estimated_duration / 10)
+
+        start_time = datetime.now()
+        issues = []
+
+        while datetime.now() - start_time < monitor_duration:
+            # Check for issues
+            health = await self._check_system_health()
+            if not health:
+                issues.append(f"Health check failed at {datetime.now()}")
+
+            await asyncio.sleep(10)  # Check every 10 seconds
+
+        state.add_checkpoint(
+            TransitionPhase.MONITORING,
+            "complete" if not issues else "issues_detected",
+            {"issues": issues},
+            can_rollback=False,
+        )
+
+        return len(issues) == 0
+
+    def _complete_transition(self, plan_id: str) -> None:
+        """Complete and archive transition."""
+        if plan_id in self.active_transitions:
+            state = self.active_transitions[plan_id]
+            state.current_phase = TransitionPhase.COMPLETE
+            self.completed_transitions.append(state)
+            del self.active_transitions[plan_id]
+
+    async def rollback_transition(self, plan_id: str) -> Tuple[bool, str]:
+        """Rollback active transition."""
+        if plan_id not in self.active_transitions:
+            return False, "Transition not found"
+
+        state = self.active_transitions[plan_id]
+
+        # Check if rollback is possible
+        if not state.plan.can_rollback_from(state.current_phase):
+            return False, f"Cannot rollback from {state.current_phase.value}"
+
+        state.rollback_initiated = True
+
+        # Execute rollback
+        success = await self._execute_rollback(state)
+
+        if success:
+            # Switch back to original environment
+            await self.manager.switch_environment(state.plan.from_env, force=True)
+            self._complete_transition(plan_id)
+            return True, "Rollback successful"
+
+        return False, "Rollback failed"
+
+    async def _execute_rollback(self, state: TransitionState) -> bool:
+        """Execute rollback procedures."""
+        # Run rollback in reverse order
+        for checkpoint in reversed(state.checkpoints):
+            if checkpoint.can_rollback:
+                handler = self.rollback_handlers.get(checkpoint.phase)
+                if handler:
+                    await handler(state, checkpoint)
+
+        return True
+
+    # Helper methods for validation checks
+    async def _check_system_health(self) -> bool:
+        """Check system health."""
+        # Simplified health check
+        return True
+
+    async def _check_dependencies(self) -> bool:
+        """Check dependencies."""
+        return True
+
+    async def _check_risk_parameters(self) -> bool:
+        """Check risk parameters."""
+        return True
+
+    async def _check_api_connectivity(self) -> bool:
+        """Check API connectivity."""
+        return True
+
+    async def _verify_backups(self) -> bool:
+        """Verify backups."""
+        return True
+
+    async def _check_emergency_procedures(self) -> bool:
+        """Check emergency procedures."""
+        return True
+
+    async def _validate_models(self) -> bool:
+        """Validate ML models."""
+        return True
+
+    async def _create_backup(self, env: Environment) -> bool:
+        """Create environment backup."""
+        return True
+
+    async def _prepare_environment(self, env: Environment) -> bool:
+        """Prepare environment."""
+        return True
+
+    async def _copy_data(self, from_env: Environment, to_env: Environment) -> bool:
+        """Copy data between environments."""
+        return True
+
+    async def _run_verification_tests(self, env: Environment) -> bool:
+        """Run verification tests."""
+        return True
+
+    def register_hook(self, phase: TransitionPhase, hook: Callable) -> None:
+        """Register hook for transition phase."""
+        self.transition_hooks[phase].append(hook)
+
+    def register_rollback_handler(
+        self, phase: TransitionPhase, handler: Callable
+    ) -> None:
+        """Register rollback handler for phase."""
+        self.rollback_handlers[phase] = handler
+
+    def get_active_transitions(self) -> List[TransitionState]:
+        """Get list of active transitions."""
+        return list(self.active_transitions.values())
+
+    def get_transition_status(self, plan_id: str) -> Optional[TransitionState]:
+        """Get status of specific transition."""
+        return self.active_transitions.get(plan_id)
diff --git a/neural_sdk/strategies/__init__.py b/neural_sdk/strategies/__init__.py
new file mode 100644
index 00000000..52d7774c
--- /dev/null
+++ b/neural_sdk/strategies/__init__.py
@@ -0,0 +1,46 @@
+"""
+Strategy Development Module
+
+This module provides base classes and utilities for developing trading strategies.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class StrategySignal:
+    """Base class for strategy signals."""
+
+    action: str  # "BUY", "SELL", "HOLD"
+    symbol: str
+    confidence: float
+    quantity: Optional[int] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class BaseStrategy(ABC):
+    """
+    Abstract base class for trading strategies.
+
+    All strategies should inherit from this class and implement
+    the generate_signal method.
+    """
+
+    def __init__(self, name: str, **config):
+        self.name = name
+        self.config = config
+
+    @abstractmethod
+    def generate_signal(self, market_data: Dict[str, Any]) -> Optional[StrategySignal]:
+        """
+        Generate a trading signal based on market data.
+
+        Args:
+            market_data: Dictionary containing market information
+
+        Returns:
+            StrategySignal or None if no action should be taken
+        """
+        pass
diff --git a/src/trading/README.md b/neural_sdk/trading/README.md
similarity index 100%
rename from src/trading/README.md
rename to neural_sdk/trading/README.md
diff --git a/src/trading/__init__.py b/neural_sdk/trading/__init__.py
similarity index 65%
rename from src/trading/__init__.py
rename to neural_sdk/trading/__init__.py
index e9b30aa4..ae191337 100644
--- a/src/trading/__init__.py
+++ b/neural_sdk/trading/__init__.py
@@ -1,16 +1,16 @@
 """
-Custom tools for the Kalshi trading system
+Custom tools for the Neural SDK trading system
 """
 
 # Tools are imported directly when needed to avoid loading all dependencies
 __all__ = [
-    "KalshiTools",
+    "NeuralTools",
     "DataAggregator",
     "MarketContext",
     "kelly_tools",
     "sentiment_probability",
     "stop_loss",
-    "kalshi_websocket",
+    "neural_websocket",
     "espn_websocket",
-    "twitter_websocket"
-]
\ No newline at end of file
+    "twitter_websocket",
+]
diff --git a/src/trading/data_aggregator.py b/neural_sdk/trading/data_aggregator.py
similarity index 81%
rename from src/trading/data_aggregator.py
rename to neural_sdk/trading/data_aggregator.py
index da526a0b..c1d98f0f 100644
--- a/src/trading/data_aggregator.py
+++ b/neural_sdk/trading/data_aggregator.py
@@ -1,23 +1,25 @@
 """
 Data Aggregator
 Bridge between StreamManager and legacy code
-DEPRECATED: Use kalshi_web_infra.stream_manager.StreamManager directly
+DEPRECATED: Use neural_web_infra.stream_manager.StreamManager directly
 """
 
 import asyncio
-from typing import Dict, Any, List, Optional, Callable
-from datetime import datetime, timedelta
 import logging
 from dataclasses import dataclass, field
+from datetime import datetime, timedelta
 from enum import Enum
+from typing import Any, Callable, Dict, List, Optional
 
 # Import the new StreamManager
+from data_pipeline.orchestration.unified_stream_manager import DataSource
+from data_pipeline.orchestration.unified_stream_manager import (
+    EventType as StreamEventType,
+)
 from data_pipeline.orchestration.unified_stream_manager import (
-    StreamManager,
     MarketContext,
+    StreamManager,
     UnifiedEvent,
-    EventType as StreamEventType,
-    DataSource
 )
 
 logger = logging.getLogger(__name__)
@@ -26,7 +28,8 @@
 
 class DataSource(Enum):
     """Data source types."""
-    KALSHI = "kalshi"
+
+    KALSHI = "neural"
     ESPN = "espn"
     TWITTER = "twitter"
 
@@ -34,15 +37,16 @@ class DataSource(Enum):
 @dataclass
 class MarketContext:
     """Aggregated context for a market."""
+
     market_ticker: str
     last_update: datetime = field(default_factory=datetime.now)
-    
-    # Kalshi data
+
+    # Neural data
     yes_bid: Optional[float] = None
     yes_ask: Optional[float] = None
     volume_24h: Optional[float] = None
     orderbook_pressure: Optional[float] = None  # Buy vs sell pressure
-    
+
     # ESPN data
     game_id: Optional[str] = None
     home_team: Optional[str] = None
@@ -50,35 +54,37 @@ class MarketContext:
     score: Optional[Dict[str, int]] = None
     win_probability: Optional[Dict[str, float]] = None
     recent_events: List[Dict[str, Any]] = field(default_factory=list)
-    
+
     # Twitter sentiment
     sentiment_score: float = 0.0
     sentiment_velocity: float = 0.0  # Rate of change
     tweet_volume: int = 0
     high_impact_tweets: List[Dict[str, Any]] = field(default_factory=list)
-    
+
     # Computed metrics
     sentiment_price_divergence: Optional[float] = None
     opportunity_score: Optional[float] = None
-    
-    def update_kalshi(self, data: Dict[str, Any]):
-        """Update Kalshi market data."""
+
+    def update_neural(self, data: Dict[str, Any]):
+        """Update Neural market data."""
         self.yes_bid = data.get("yes_bid", self.yes_bid)
         self.yes_ask = data.get("yes_ask", self.yes_ask)
         self.volume_24h = data.get("volume_24h", self.volume_24h)
         self.last_update = datetime.now()
-        
+
         # Calculate orderbook pressure
         if "yes_levels" in data and "no_levels" in data:
             yes_volume = sum(l.get("quantity", 0) for l in data["yes_levels"][:5])
             no_volume = sum(l.get("quantity", 0) for l in data["no_levels"][:5])
             if yes_volume + no_volume > 0:
-                self.orderbook_pressure = (yes_volume - no_volume) / (yes_volume + no_volume)
-    
+                self.orderbook_pressure = (yes_volume - no_volume) / (
+                    yes_volume + no_volume
+                )
+
     def update_espn(self, data: Dict[str, Any]):
         """Update ESPN game data."""
         event_type = data.get("type")
-        
+
         if event_type == ESPNEventType.SCORE_UPDATE.value:
             self.score = data.get("score")
         elif event_type == ESPNEventType.WIN_PROBABILITY.value:
@@ -87,74 +93,74 @@ def update_espn(self, data: Dict[str, Any]):
             self.recent_events.append(data)
             # Keep only last 10 events
             self.recent_events = self.recent_events[-10:]
-        
+
         self.last_update = datetime.now()
-    
+
     def update_twitter(self, tweet: Dict[str, Any]):
         """Update Twitter sentiment data."""
         self.tweet_volume += 1
-        
+
         # Update sentiment score (weighted average)
         new_sentiment = tweet.get("sentiment_score", 0)
-        self.sentiment_score = (self.sentiment_score * 0.9 + new_sentiment * 0.1)
-        
+        self.sentiment_score = self.sentiment_score * 0.9 + new_sentiment * 0.1
+
         # Track high-impact tweets
         if tweet.get("impact") == "HIGH":
             self.high_impact_tweets.append(tweet)
             self.high_impact_tweets = self.high_impact_tweets[-5:]  # Keep last 5
-        
+
         # Calculate sentiment velocity
         # (This would need historical data in production)
         self.sentiment_velocity = new_sentiment - self.sentiment_score
-        
+
         self.last_update = datetime.now()
-    
+
     def calculate_opportunity(self):
         """Calculate trading opportunity score."""
         if self.yes_bid is None or self.yes_ask is None:
             return
-        
+
         # Current market price (midpoint)
         market_price = (self.yes_bid + self.yes_ask) / 2
-        
+
         # Expected price based on sentiment
         if self.sentiment_score != 0:
             sentiment_implied_price = 0.5 + (self.sentiment_score * 0.3)
             sentiment_implied_price = max(0.01, min(0.99, sentiment_implied_price))
-            
+
             # Divergence between sentiment and market
             self.sentiment_price_divergence = sentiment_implied_price - market_price
-        
+
         # Win probability divergence (if ESPN data available)
         win_prob_divergence = 0
         if self.win_probability and self.home_team:
             espn_implied_price = self.win_probability.get("home", 50) / 100
             win_prob_divergence = espn_implied_price - market_price
-        
+
         # Opportunity score factors:
         # 1. Sentiment-price divergence
         # 2. Win probability divergence
         # 3. Orderbook pressure
         # 4. Recent high-impact events
-        
+
         factors = []
-        
+
         if self.sentiment_price_divergence:
             factors.append(abs(self.sentiment_price_divergence) * 2)
-        
+
         if win_prob_divergence != 0:
             factors.append(abs(win_prob_divergence) * 3)
-        
+
         if self.orderbook_pressure is not None:
             factors.append(abs(self.orderbook_pressure))
-        
+
         if len(self.recent_events) > 0:
             # Recent events increase opportunity
             factors.append(0.2 * len(self.recent_events))
-        
+
         if len(self.high_impact_tweets) > 0:
             factors.append(0.3 * len(self.high_impact_tweets))
-        
+
         # Calculate final score (0-1 scale)
         if factors:
             self.opportunity_score = min(1.0, sum(factors) / len(factors))
@@ -167,194 +173,189 @@ class DataAggregator:
     DEPRECATED: Wrapper around StreamManager for backward compatibility.
     Use StreamManager directly for new code.
     """
-    
+
     def __init__(
         self,
-        kalshi_api_key: Optional[str] = None,
+        neural_api_key: Optional[str] = None,
         twitter_api_key: Optional[str] = None,
-        redis_url: str = "redis://localhost:6379"
+        redis_url: str = "redis://localhost:6379",
     ):
         """
         Initialize data aggregator (deprecated wrapper).
-        
+
         Args:
-            kalshi_api_key: Kalshi API key (unused - uses env vars)
+            neural_api_key: Neural API key (unused - uses env vars)
             twitter_api_key: TwitterAPI.io API key (unused - uses env vars)
             redis_url: Redis connection URL (unused)
         """
         logger.warning("DataAggregator is deprecated. Migrate to StreamManager.")
-        
+
         # Use StreamManager internally
         self.stream_manager = StreamManager()
-        
+
         # Legacy compatibility
         self.markets = self.stream_manager.markets
-        
+
         # Callbacks mapping
         self.callbacks: Dict[str, List[Callable]] = {
             "market_update": [],
             "opportunity_alert": [],
-            "sentiment_shift": []
+            "sentiment_shift": [],
         }
-        
+
         # State
         self.is_running = False
-    
+
     async def initialize(self):
         """Initialize all data sources."""
         logger.info("Initializing data aggregator...")
-        
-        # Initialize Kalshi
-        if self.kalshi_api_key:
-            self.kalshi_client = KalshiWebSocket(
-                api_key=self.kalshi_api_key,
-                on_message=self._handle_kalshi_message,
-                on_error=self._handle_error
+
+        # Initialize Neural
+        if self.neural_api_key:
+            self.neural_client = NeuralWebSocket(
+                api_key=self.neural_api_key,
+                on_message=self._handle_neural_message,
+                on_error=self._handle_error,
             )
-        
+
         # Initialize ESPN
         self.espn_adapter = ESPNWebSocketAdapter(
             on_message=self._handle_espn_message,
             on_error=self._handle_error,
-            poll_interval=10
+            poll_interval=10,
         )
-        
+
         # Initialize Twitter
         if self.twitter_api_key:
-            self.twitter_client = TwitterWebSocket(
-                api_key=self.twitter_api_key
-            )
-        
+            self.twitter_client = TwitterWebSocket(api_key=self.twitter_api_key)
+
         # Initialize Redis
         self.redis_pubsub = RedisPubSub(redis_url=self.redis_url)
-        
+
         logger.info("Data aggregator initialized")
-    
+
     async def start(self):
         """Start all data sources."""
         if self.is_running:
             logger.warning("Aggregator already running")
             return
-        
+
         self.is_running = True
         logger.info("Starting data aggregator...")
-        
+
         # Connect to data sources
-        if self.kalshi_client:
-            await self.kalshi_client.connect()
-        
+        if self.neural_client:
+            await self.neural_client.connect()
+
         await self.espn_adapter.connect()
-        
+
         if self.twitter_client:
             await self.twitter_client.connect()
-        
+
         await self.redis_pubsub.connect()
-        
+
         # Start aggregation loop
-        self.tasks.append(
-            asyncio.create_task(self._aggregation_loop())
-        )
-        
+        self.tasks.append(asyncio.create_task(self._aggregation_loop()))
+
         # Start Twitter streaming if available
         if self.twitter_client:
-            self.tasks.append(
-                asyncio.create_task(self._stream_twitter())
-            )
-        
+            self.tasks.append(asyncio.create_task(self._stream_twitter()))
+
         logger.info("Data aggregator started")
-    
+
     async def track_market(
         self,
         market_ticker: str,
         game_id: Optional[str] = None,
-        teams: Optional[List[str]] = None
+        teams: Optional[List[str]] = None,
     ):
         """
         Start tracking a specific market.
-        
+
         Args:
-            market_ticker: Kalshi market ticker
+            market_ticker: Neural market ticker
             game_id: ESPN game ID
             teams: Teams to track on Twitter
         """
         logger.info(f"Tracking market: {market_ticker}")
-        
+
         # Create market context
         if market_ticker not in self.markets:
             self.markets[market_ticker] = MarketContext(market_ticker=market_ticker)
-        
+
         context = self.markets[market_ticker]
         context.game_id = game_id
-        
-        # Subscribe to Kalshi channels
-        if self.kalshi_client:
-            await self.kalshi_client.subscribe(
-                channel=KalshiChannel.TICKER,
-                market_tickers=[market_ticker]
+
+        # Subscribe to Neural channels
+        if self.neural_client:
+            await self.neural_client.subscribe(
+                channel=NeuralChannel.TICKER, market_tickers=[market_ticker]
             )
-            
-            await self.kalshi_client.subscribe(
-                channel=KalshiChannel.ORDERBOOK_DELTA,
-                market_tickers=[market_ticker]
+
+            await self.neural_client.subscribe(
+                channel=NeuralChannel.ORDERBOOK_DELTA, market_tickers=[market_ticker]
             )
-        
+
         # Subscribe to ESPN game
         if game_id and self.espn_adapter:
             await self.espn_adapter.subscribe_game(game_id)
-        
+
         # Set up Twitter filters
         if teams and self.twitter_client:
             await self.twitter_client.setup_filters(teams=teams)
-    
-    async def _handle_kalshi_message(self, msg: Dict[str, Any]):
-        """Handle Kalshi WebSocket messages."""
+
+    async def _handle_neural_message(self, msg: Dict[str, Any]):
+        """Handle Neural WebSocket messages."""
         market_ticker = msg.get("market_ticker")
         if not market_ticker:
             return
-        
+
         # Get or create market context
         if market_ticker not in self.markets:
             self.markets[market_ticker] = MarketContext(market_ticker=market_ticker)
-        
+
         context = self.markets[market_ticker]
-        context.update_kalshi(msg)
-        
+        context.update_neural(msg)
+
         # Calculate opportunity
         context.calculate_opportunity()
-        
+
         # Notify callbacks
         await self._notify_market_update(context)
-        
+
         # Check for opportunities
         if context.opportunity_score and context.opportunity_score > 0.7:
             await self._notify_opportunity(context)
-        
+
         # Publish to Redis
         await self._publish_to_redis(context)
-    
+
     async def _handle_espn_message(self, msg: Dict[str, Any]):
         """Handle ESPN adapter messages."""
         game_id = msg.get("game_id")
-        
+
         # Find market for this game
         for context in self.markets.values():
             if context.game_id == game_id:
                 context.update_espn(msg)
                 context.calculate_opportunity()
-                
+
                 await self._notify_market_update(context)
-                
+
                 # Check for high-impact events
-                if msg.get("type") in [ESPNEventType.INJURY.value, ESPNEventType.BIG_PLAY.value]:
+                if msg.get("type") in [
+                    ESPNEventType.INJURY.value,
+                    ESPNEventType.BIG_PLAY.value,
+                ]:
                     await self._notify_opportunity(context)
-                
+
                 break
-    
+
     async def _stream_twitter(self):
         """Stream and process Twitter data."""
         if not self.twitter_client:
             return
-        
+
         try:
             async for tweet in self.twitter_client.stream_tweets():
                 # Match tweet to markets based on content
@@ -362,21 +363,23 @@ async def _stream_twitter(self):
                     # Simple matching - in production would be more sophisticated
                     if context.home_team and context.away_team:
                         text = tweet.get("text", "").lower()
-                        if (context.home_team.lower() in text or 
-                            context.away_team.lower() in text):
-                            
+                        if (
+                            context.home_team.lower() in text
+                            or context.away_team.lower() in text
+                        ):
+
                             context.update_twitter(tweet)
                             context.calculate_opportunity()
-                            
+
                             # Check for sentiment shifts
                             if abs(context.sentiment_velocity) > 0.2:
                                 await self._notify_sentiment_shift(context)
-                            
+
                             await self._notify_market_update(context)
-                            
+
         except Exception as e:
             logger.error(f"Twitter streaming error: {e}")
-    
+
     async def _aggregation_loop(self):
         """Main aggregation loop."""
         while self.is_running:
@@ -384,22 +387,22 @@ async def _aggregation_loop(self):
                 # Periodic opportunity calculation
                 for context in self.markets.values():
                     context.calculate_opportunity()
-                    
+
                     # Check for stale data
                     if (datetime.now() - context.last_update).seconds > 60:
                         logger.warning(f"Stale data for {context.market_ticker}")
-                
+
                 await asyncio.sleep(5)
-                
+
             except Exception as e:
                 logger.error(f"Aggregation loop error: {e}")
                 await asyncio.sleep(10)
-    
+
     async def _publish_to_redis(self, context: MarketContext):
         """Publish aggregated data to Redis."""
         if not self.redis_pubsub:
             return
-        
+
         # Publish market data
         await self.redis_pubsub.publish(
             channel=Channel.MARKET_DATA,
@@ -410,11 +413,11 @@ async def _publish_to_redis(self, context: MarketContext):
                 "yes_ask": context.yes_ask,
                 "opportunity_score": context.opportunity_score,
                 "sentiment_divergence": context.sentiment_price_divergence,
-                "orderbook_pressure": context.orderbook_pressure
+                "orderbook_pressure": context.orderbook_pressure,
             },
-            sender="data_aggregator"
+            sender="data_aggregator",
         )
-    
+
     async def _notify_market_update(self, context: MarketContext):
         """Notify callbacks of market update."""
         for callback in self.callbacks["market_update"]:
@@ -422,7 +425,7 @@ async def _notify_market_update(self, context: MarketContext):
                 await callback(context)
             except Exception as e:
                 logger.error(f"Callback error: {e}")
-    
+
     async def _notify_opportunity(self, context: MarketContext):
         """Notify callbacks of trading opportunity."""
         for callback in self.callbacks["opportunity_alert"]:
@@ -430,7 +433,7 @@ async def _notify_opportunity(self, context: MarketContext):
                 await callback(context)
             except Exception as e:
                 logger.error(f"Callback error: {e}")
-    
+
     async def _notify_sentiment_shift(self, context: MarketContext):
         """Notify callbacks of sentiment shift."""
         for callback in self.callbacks["sentiment_shift"]:
@@ -438,49 +441,47 @@ async def _notify_sentiment_shift(self, context: MarketContext):
                 await callback(context)
             except Exception as e:
                 logger.error(f"Callback error: {e}")
-    
+
     async def _handle_error(self, error: Any):
         """Handle errors from data sources."""
         logger.error(f"Data source error: {error}")
-    
+
     def register_callback(self, event_type: str, callback: Callable):
         """Register a callback for specific events."""
         if event_type in self.callbacks:
             self.callbacks[event_type].append(callback)
-    
+
     async def stop(self):
         """Stop all data sources."""
         self.is_running = False
-        
+
         # Cancel tasks
         for task in self.tasks:
             task.cancel()
-        
+
         # Close connections
-        if self.kalshi_client:
-            await self.kalshi_client.close()
-        
+        if self.neural_client:
+            await self.neural_client.close()
+
         if self.espn_adapter:
             await self.espn_adapter.close()
-        
+
         if self.twitter_client:
             await self.twitter_client.close()
-        
+
         if self.redis_pubsub:
             await self.redis_pubsub.close()
-        
+
         logger.info("Data aggregator stopped")
-    
+
     def get_market_context(self, market_ticker: str) -> Optional[MarketContext]:
         """Get context for a specific market."""
         return self.markets.get(market_ticker)
-    
+
     def get_top_opportunities(self, limit: int = 5) -> List[MarketContext]:
         """Get markets with highest opportunity scores."""
         sorted_markets = sorted(
-            self.markets.values(),
-            key=lambda m: m.opportunity_score or 0,
-            reverse=True
+            self.markets.values(), key=lambda m: m.opportunity_score or 0, reverse=True
         )
         return sorted_markets[:limit]
 
@@ -489,7 +490,7 @@ def get_top_opportunities(self, limit: int = 5) -> List[MarketContext]:
 async def example_usage():
     """Example of using the data aggregator."""
     import os
-    
+
     # Callback for opportunities
     async def on_opportunity(context: MarketContext):
         print(f"\n🎯 OPPORTUNITY ALERT: {context.market_ticker}")
@@ -498,39 +499,37 @@ async def on_opportunity(context: MarketContext):
         print(f"  Sentiment: {context.sentiment_score:.2f}")
         if context.sentiment_price_divergence:
             print(f"  Divergence: {context.sentiment_price_divergence:.2f}")
-    
+
     # Initialize aggregator
     aggregator = DataAggregator(
-        kalshi_api_key=os.getenv("KALSHI_API_KEY"),
-        twitter_api_key=os.getenv("TWITTERAPI_KEY")
+        neural_api_key=os.getenv("KALSHI_API_KEY"),
+        twitter_api_key=os.getenv("TWITTERAPI_KEY"),
     )
-    
+
     # Register callbacks
     aggregator.register_callback("opportunity_alert", on_opportunity)
-    
+
     # Initialize and start
     await aggregator.initialize()
     await aggregator.start()
-    
+
     # Track a market
     await aggregator.track_market(
-        market_ticker="SUPERBOWL-2025",
-        game_id="401547435",
-        teams=["Chiefs", "Bills"]
+        market_ticker="SUPERBOWL-2025", game_id="401547435", teams=["Chiefs", "Bills"]
     )
-    
+
     # Run for a while
     await asyncio.sleep(60)
-    
+
     # Get top opportunities
     top = aggregator.get_top_opportunities()
     print("\nTop Opportunities:")
     for context in top:
         print(f"  {context.market_ticker}: {context.opportunity_score:.2f}")
-    
+
     # Stop
     await aggregator.stop()
 
 
 if __name__ == "__main__":
-    asyncio.run(example_usage())
\ No newline at end of file
+    asyncio.run(example_usage())
diff --git a/src/trading/espn_tools.py b/neural_sdk/trading/espn_tools.py
similarity index 59%
rename from src/trading/espn_tools.py
rename to neural_sdk/trading/espn_tools.py
index 1399a6a9..21d29675 100644
--- a/src/trading/espn_tools.py
+++ b/neural_sdk/trading/espn_tools.py
@@ -4,50 +4,53 @@
 No API key required - completely free
 """
 
-import httpx
-from typing import Dict, Any, List, Optional
-from datetime import datetime
 import asyncio
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import httpx
 
 
 class ESPNTools:
     """
     Free ESPN API endpoints for real-time sports data.
-    Perfect for correlating game events with Kalshi market movements.
+    Perfect for correlating game events with Neural market movements.
     """
-    
+
     BASE_URL = "http://site.api.espn.com/apis/site/v2/sports"
-    
+
     def __init__(self):
         self.client = httpx.AsyncClient(timeout=30.0)
-    
+
     async def get_nfl_scoreboard(self) -> Dict[str, Any]:
         """Get all current NFL games with scores and status."""
         url = f"{self.BASE_URL}/football/nfl/scoreboard"
         response = await self.client.get(url)
         return response.json()
-    
+
     async def get_nba_scoreboard(self) -> Dict[str, Any]:
         """Get all current NBA games with scores and status."""
         url = f"{self.BASE_URL}/basketball/nba/scoreboard"
         response = await self.client.get(url)
         return response.json()
-    
+
     async def get_cfb_scoreboard(self) -> Dict[str, Any]:
         """Get all current College Football games."""
         url = f"{self.BASE_URL}/football/college-football/scoreboard"
         response = await self.client.get(url)
         return response.json()
-    
-    async def get_game_summary(self, game_id: str, sport: str = "nfl") -> Dict[str, Any]:
+
+    async def get_game_summary(
+        self, game_id: str, sport: str = "nfl"
+    ) -> Dict[str, Any]:
         """
         Get detailed game summary including play-by-play and win probability.
-        This is the MOST VALUABLE endpoint for Kalshi correlation.
-        
+        This is the MOST VALUABLE endpoint for Neural correlation.
+
         Args:
             game_id: ESPN game ID
             sport: 'nfl', 'nba', or 'college-football'
-            
+
         Returns:
             Complete game data with plays, injuries, win probability
         """
@@ -55,133 +58,160 @@ async def get_game_summary(self, game_id: str, sport: str = "nfl") -> Dict[str,
             "nfl": "football/nfl",
             "nba": "basketball/nba",
             "cfb": "football/college-football",
-            "college-football": "football/college-football"
+            "college-football": "football/college-football",
         }
-        
+
         sport_path = sport_map.get(sport, sport)
         url = f"{self.BASE_URL}/{sport_path}/summary?event={game_id}"
-        
+
         response = await self.client.get(url)
         return response.json()
-    
-    async def get_win_probability(self, game_id: str, sport: str = "nfl") -> Optional[Dict[str, float]]:
+
+    async def get_win_probability(
+        self, game_id: str, sport: str = "nfl"
+    ) -> Optional[Dict[str, float]]:
         """
         Extract win probability from game summary.
-        Direct correlation to Kalshi market prices!
+        Direct correlation to Neural market prices!
         """
         summary = await self.get_game_summary(game_id, sport)
-        
+
         if "winprobability" in summary:
-            latest = summary["winprobability"][-1] if isinstance(summary["winprobability"], list) else summary["winprobability"]
+            latest = (
+                summary["winprobability"][-1]
+                if isinstance(summary["winprobability"], list)
+                else summary["winprobability"]
+            )
             return {
                 "home_win_pct": latest.get("homeWinPercentage", 0),
                 "away_win_pct": latest.get("awayWinPercentage", 0),
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
         return None
-    
-    async def get_game_events(self, game_id: str, sport: str = "nfl") -> List[Dict[str, Any]]:
+
+    async def get_game_events(
+        self, game_id: str, sport: str = "nfl"
+    ) -> List[Dict[str, Any]]:
         """
         Extract market-moving events from game.
         Injuries, touchdowns, turnovers, etc.
         """
         summary = await self.get_game_summary(game_id, sport)
         events = []
-        
+
         # Extract injuries (huge market movers)
         if "injuries" in summary:
             for team_injuries in summary.get("injuries", {}).values():
                 for injury in team_injuries:
-                    events.append({
-                        "type": "injury",
-                        "player": injury.get("athlete", {}).get("displayName"),
-                        "status": injury.get("status"),
-                        "impact": "HIGH",  # Injuries always high impact
-                        "timestamp": datetime.now().isoformat()
-                    })
-        
+                    events.append(
+                        {
+                            "type": "injury",
+                            "player": injury.get("athlete", {}).get("displayName"),
+                            "status": injury.get("status"),
+                            "impact": "HIGH",  # Injuries always high impact
+                            "timestamp": datetime.now().isoformat(),
+                        }
+                    )
+
         # Extract scoring plays
         if "scoringPlays" in summary:
             for play in summary["scoringPlays"]:
-                events.append({
-                    "type": "scoring",
-                    "description": play.get("text"),
-                    "impact": "MEDIUM",
-                    "timestamp": play.get("wallclock")
-                })
-        
+                events.append(
+                    {
+                        "type": "scoring",
+                        "description": play.get("text"),
+                        "impact": "MEDIUM",
+                        "timestamp": play.get("wallclock"),
+                    }
+                )
+
         # Extract big plays from play-by-play
         if "drives" in summary:
             for drive in summary.get("drives", {}).get("previous", []):
                 for play in drive.get("plays", []):
                     # Turnovers, big gains, etc.
-                    if any(word in play.get("text", "").lower() for word in ["intercepted", "fumble", "touchdown"]):
-                        events.append({
-                            "type": "big_play",
-                            "description": play.get("text"),
-                            "impact": "HIGH" if "intercepted" in play.get("text", "").lower() else "MEDIUM",
-                            "timestamp": play.get("wallclock")
-                        })
-        
+                    if any(
+                        word in play.get("text", "").lower()
+                        for word in ["intercepted", "fumble", "touchdown"]
+                    ):
+                        events.append(
+                            {
+                                "type": "big_play",
+                                "description": play.get("text"),
+                                "impact": (
+                                    "HIGH"
+                                    if "intercepted" in play.get("text", "").lower()
+                                    else "MEDIUM"
+                                ),
+                                "timestamp": play.get("wallclock"),
+                            }
+                        )
+
         return events
-    
-    async def monitor_games_for_events(self, sport: str = "nfl", interval: int = 30) -> None:
+
+    async def monitor_games_for_events(
+        self, sport: str = "nfl", interval: int = 30
+    ) -> None:
         """
         Monitor all active games for market-moving events.
-        Perfect for real-time Kalshi correlation.
+        Perfect for real-time Neural correlation.
         """
         while True:
-            scoreboard = await self.get_nfl_scoreboard() if sport == "nfl" else await self.get_nba_scoreboard()
-            
+            scoreboard = (
+                await self.get_nfl_scoreboard()
+                if sport == "nfl"
+                else await self.get_nba_scoreboard()
+            )
+
             for game in scoreboard.get("events", []):
                 game_id = game["id"]
                 status = game.get("status", {}).get("type", {}).get("state")
-                
+
                 if status == "in":  # Game is live
                     events = await self.get_game_events(game_id, sport)
                     win_prob = await self.get_win_probability(game_id, sport)
-                    
-                    # This is where you'd correlate with Kalshi prices
+
+                    # This is where you'd correlate with Neural prices
                     if events or win_prob:
                         yield {
                             "game_id": game_id,
                             "events": events,
                             "win_probability": win_prob,
-                            "teams": f"{game['competitions'][0]['competitors'][0]['team']['displayName']} vs {game['competitions'][0]['competitors'][1]['team']['displayName']}"
+                            "teams": f"{game['competitions'][0]['competitors'][0]['team']['displayName']} vs {game['competitions'][0]['competitors'][1]['team']['displayName']}",
                         }
-            
+
             await asyncio.sleep(interval)
-    
+
     async def close(self):
         """Clean up HTTP client."""
         await self.client.aclose()
 
 
-# Example usage for Kalshi correlation
-async def correlate_with_kalshi():
+# Example usage for Neural correlation
+async def correlate_with_neural():
     """
-    Example of how to use ESPN data with Kalshi markets.
+    Example of how to use ESPN data with Neural markets.
     """
     espn = ESPNTools()
-    
+
     # Get current NFL games
     scoreboard = await espn.get_nfl_scoreboard()
-    
+
     for game in scoreboard.get("events", []):
         game_id = game["id"]
-        
-        # Get win probability (correlates with Kalshi prices)
+
+        # Get win probability (correlates with Neural prices)
         win_prob = await espn.get_win_probability(game_id)
-        
+
         # Get market-moving events
         events = await espn.get_game_events(game_id)
-        
+
         # Find injuries (biggest market movers)
         injuries = [e for e in events if e["type"] == "injury"]
-        
+
         if injuries:
             print(f"MARKET ALERT: Injury detected!")
             print(f"Current win probability: {win_prob}")
-            print(f"Check Kalshi market for arbitrage opportunity")
-    
-    await espn.close()
\ No newline at end of file
+            print(f"Check Neural market for arbitrage opportunity")
+
+    await espn.close()
diff --git a/neural_sdk/trading/llm_client.py b/neural_sdk/trading/llm_client.py
new file mode 100644
index 00000000..ad291653
--- /dev/null
+++ b/neural_sdk/trading/llm_client.py
@@ -0,0 +1,178 @@
+"""
+Ollama LLM Client
+Direct integration with local Ollama server for fine-tuned models
+"""
+
+import asyncio
+import json
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class LLMClient:
+    """Direct Ollama client for local LLM interactions"""
+
+    def __init__(self, model_name: str = "nfl_playbypay_lfm2:latest"):
+        """
+        Initialize Ollama client
+
+        Args:
+            model_name: Ollama model name to use
+        """
+        self.model_name = model_name
+        self.timeout = 30  # seconds
+
+    async def complete(
+        self,
+        prompt: str,
+        model: Optional[str] = None,
+        temperature: float = 0.3,
+        max_tokens: int = 2000,
+        system_prompt: Optional[str] = None,
+    ) -> str:
+        """
+        Get completion from Ollama
+
+        Args:
+            prompt: User prompt
+            model: Model to use (default: nfl_playbypay_lfm2:latest)
+            temperature: Sampling temperature (not used by Ollama CLI)
+            max_tokens: Maximum tokens to generate (not used by Ollama CLI)
+            system_prompt: Optional system prompt
+
+        Returns:
+            Generated text response
+        """
+        # Combine system prompt and user prompt
+        full_prompt = prompt
+        if system_prompt:
+            full_prompt = f"System: {system_prompt}\n\nUser: {prompt}"
+
+        # Use specified model or default
+        model_name = model or self.model_name
+
+        try:
+            # Run Ollama command
+            process = await asyncio.wait_for(
+                asyncio.create_subprocess_exec(
+                    "ollama",
+                    "run",
+                    model_name,
+                    full_prompt,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                ),
+                timeout=self.timeout,
+            )
+
+            stdout, stderr = await process.communicate()
+
+            if process.returncode != 0:
+                error_msg = stderr.decode().strip() if stderr else "Unknown error"
+                logger.error(
+                    f"Ollama error (exit code {process.returncode}): {error_msg}"
+                )
+                raise Exception(f"Ollama error: {error_msg}")
+
+            response = stdout.decode().strip()
+            if not response:
+                raise Exception("Empty response from Ollama")
+
+            return response
+
+        except asyncio.TimeoutError:
+            raise Exception(f"Ollama call timed out after {self.timeout} seconds")
+        except FileNotFoundError:
+            raise Exception(
+                "Ollama not found. Please install Ollama: https://ollama.ai"
+            )
+        except Exception as e:
+            logger.error(f"Failed to call Ollama: {str(e)}")
+            raise
+
+    async def complete_json(
+        self, prompt: str, model: Optional[str] = None, temperature: float = 0.1
+    ) -> Dict[str, Any]:
+        """
+        Get JSON response from Ollama
+
+        Args:
+            prompt: User prompt (should request JSON format)
+            model: Model to use
+            temperature: Lower temperature for structured output (not used by Ollama CLI)
+
+        Returns:
+            Parsed JSON response
+        """
+        # Add JSON instruction to prompt
+        json_prompt = f"{prompt}\n\nRespond with valid JSON only. Do not include any other text or formatting."
+
+        response = await self.complete(
+            prompt=json_prompt, model=model, temperature=temperature
+        )
+
+        # Try to extract JSON from response
+        try:
+            # Clean the response
+            response = response.strip()
+
+            # Handle potential markdown formatting
+            if "```json" in response:
+                response = response.split("```json")[1].split("```")[0].strip()
+            elif "```" in response:
+                response = response.split("```")[1].split("```")[0].strip()
+
+            return json.loads(response)
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse JSON response: {e}")
+            logger.error(f"Raw response: {response}")
+            return {"error": "Failed to parse JSON", "raw": response}
+
+    async def analyze_market(
+        self,
+        market_data: Dict[str, Any],
+        sentiment_data: Optional[Dict[str, Any]] = None,
+        game_data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Analyze market opportunity using LLM
+
+        Args:
+            market_data: Neural market data
+            sentiment_data: Twitter sentiment data
+            game_data: ESPN game data
+
+        Returns:
+            Analysis with trading recommendation
+        """
+        prompt = f"""
+        Analyze this trading opportunity:
+        
+        Market Data: {market_data}
+        Sentiment Data: {sentiment_data or 'N/A'}
+        Game Data: {game_data or 'N/A'}
+        
+        Provide analysis as JSON with:
+        - signal: BUY_YES, BUY_NO, or HOLD
+        - confidence: 0-1 score
+        - reasoning: brief explanation
+        - risk_level: low, medium, or high
+        - suggested_size: percentage of capital (0-25)
+        """
+
+        return await self.complete_json(prompt, temperature=0.2)
+
+
+# Singleton instance for easy import
+llm_client = None
+
+
+def get_llm_client() -> LLMClient:
+    """Get or create LLM client singleton"""
+    global llm_client
+    if llm_client is None:
+        llm_client = LLMClient()
+    return llm_client
diff --git a/src/trading/sentiment_probability.py b/neural_sdk/trading/sentiment_probability.py
similarity index 87%
rename from src/trading/sentiment_probability.py
rename to neural_sdk/trading/sentiment_probability.py
index a48bf9b1..70e18d59 100644
--- a/src/trading/sentiment_probability.py
+++ b/neural_sdk/trading/sentiment_probability.py
@@ -3,10 +3,10 @@
 Combines sentiment scores, ESPN win probabilities, and orderbook pressure.
 """
 
-from typing import Dict, List, Optional, Tuple
-import math
 import logging
+import math
 from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
 
 logger = logging.getLogger(__name__)
 
@@ -14,33 +14,33 @@
 class SentimentProbabilityConverter:
     """
     Convert sentiment signals into actionable trading probabilities.
-    
+
     Combines multiple data sources:
     - Twitter sentiment analysis
     - ESPN win probabilities
-    - Kalshi orderbook pressure
+    - Neural orderbook pressure
     - Historical correlations
     """
-    
+
     @staticmethod
     def sentiment_to_probability(
         sentiment_score: float,  # -1 to 1
         confidence: float = 1.0,  # 0 to 1
-        base_prob: float = 0.5,   # Prior probability
-        strength: float = 2.0      # Transformation strength
+        base_prob: float = 0.5,  # Prior probability
+        strength: float = 2.0,  # Transformation strength
     ) -> float:
         """
         Convert sentiment score to win probability using sigmoid transformation.
-        
+
         Args:
             sentiment_score: Sentiment from -1 (negative) to 1 (positive)
             confidence: Confidence in the sentiment (0-1)
             base_prob: Prior probability before sentiment adjustment
             strength: Steepness of sigmoid transformation
-        
+
         Returns:
             Probability between 0.01 and 0.99
-            
+
         Example:
             sentiment=0.5, confidence=0.8 -> ~70% probability
             sentiment=-0.3, confidence=0.6 -> ~38% probability
@@ -49,42 +49,42 @@ def sentiment_to_probability(
         if not -1 <= sentiment_score <= 1:
             logger.warning(f"Sentiment score {sentiment_score} out of range, clamping")
             sentiment_score = max(-1, min(1, sentiment_score))
-        
+
         if not 0 <= confidence <= 1:
             logger.warning(f"Confidence {confidence} out of range, clamping")
             confidence = max(0, min(1, confidence))
-        
+
         # Sigmoid transformation
         # Maps sentiment to (0, 1) range with steepness controlled by strength
         try:
             sigmoid = 1 / (1 + math.exp(-sentiment_score * strength))
         except OverflowError:
             sigmoid = 1.0 if sentiment_score > 0 else 0.0
-        
+
         # Adjust from base probability with confidence weighting
         # High confidence = more deviation from base
         # Low confidence = stay closer to base
         adjustment = (sigmoid - 0.5) * confidence
         probability = base_prob + adjustment
-        
+
         # Bound between 0.01 and 0.99 (never fully certain)
         probability = max(0.01, min(0.99, probability))
-        
+
         logger.debug(
             f"Sentiment->Prob: score={sentiment_score:.2f}, conf={confidence:.2f}, "
             f"base={base_prob:.2f} -> prob={probability:.3f}"
         )
-        
+
         return probability
-    
+
     @staticmethod
     def combine_probabilities(
         sources: Dict[str, Dict[str, float]],
-        correlation_matrix: Optional[Dict[Tuple[str, str], float]] = None
+        correlation_matrix: Optional[Dict[Tuple[str, str], float]] = None,
     ) -> Dict[str, float]:
         """
         Combine multiple probability sources with confidence weighting.
-        
+
         Args:
             sources: Dictionary of source data:
                 {
@@ -93,26 +93,26 @@ def combine_probabilities(
                     "orderbook": {"prob": 0.58, "weight": 0.3, "confidence": 0.7}
                 }
             correlation_matrix: Correlation between sources (for adjustment)
-        
+
         Returns:
             Combined probability with aggregate confidence
         """
         if not sources:
             return {"probability": 0.5, "confidence": 0.0, "sources": {}}
-        
+
         # Normalize weights based on confidence
         weighted_sum = 0
         weight_total = 0
         confidence_values = []
-        
+
         for source_name, data in sources.items():
             prob = data.get("prob", 0.5)
             base_weight = data.get("weight", 1.0 / len(sources))
             confidence = data.get("confidence", 1.0)
-            
+
             # Adjust weight by confidence
             effective_weight = base_weight * confidence
-            
+
             # Apply correlation penalty if provided
             if correlation_matrix:
                 correlation_penalty = 0
@@ -121,43 +121,44 @@ def combine_probabilities(
                         corr_key = tuple(sorted([source_name, other_source]))
                         correlation = correlation_matrix.get(corr_key, 0)
                         correlation_penalty += abs(correlation) * 0.1
-                
-                effective_weight *= (1 - correlation_penalty)
-            
+
+                effective_weight *= 1 - correlation_penalty
+
             weighted_sum += prob * effective_weight
             weight_total += effective_weight
             confidence_values.append(confidence)
-        
+
         # Calculate combined probability
         combined_prob = weighted_sum / weight_total if weight_total > 0 else 0.5
-        
+
         # Calculate aggregate confidence
         # Use harmonic mean for conservative confidence estimate
         if confidence_values:
-            harmonic_mean = len(confidence_values) / sum(1/c if c > 0 else float('inf') for c in confidence_values)
+            harmonic_mean = len(confidence_values) / sum(
+                1 / c if c > 0 else float("inf") for c in confidence_values
+            )
             avg_confidence = harmonic_mean
         else:
             avg_confidence = 0
-        
+
         return {
             "probability": round(combined_prob, 3),
             "confidence": round(avg_confidence, 3),
             "weight_total": round(weight_total, 3),
-            "sources": sources
+            "sources": sources,
         }
-    
+
     @staticmethod
     def calculate_sentiment_momentum(
-        sentiment_history: List[Dict[str, float]],
-        window_minutes: int = 30
+        sentiment_history: List[Dict[str, float]], window_minutes: int = 30
     ) -> Dict[str, float]:
         """
         Calculate sentiment momentum and velocity from historical data.
-        
+
         Args:
             sentiment_history: List of {"timestamp": datetime, "sentiment": float}
             window_minutes: Time window for momentum calculation
-        
+
         Returns:
             Momentum metrics for dynamic probability adjustment
         """
@@ -166,171 +167,181 @@ def calculate_sentiment_momentum(
                 "momentum": 0.0,
                 "velocity": 0.0,
                 "acceleration": 0.0,
-                "trend_strength": 0.0
+                "trend_strength": 0.0,
             }
-        
+
         # Sort by timestamp
         sorted_history = sorted(sentiment_history, key=lambda x: x["timestamp"])
-        
+
         # Get recent window
         cutoff_time = datetime.now() - timedelta(minutes=window_minutes)
         recent = [h for h in sorted_history if h["timestamp"] > cutoff_time]
-        
+
         if len(recent) < 2:
-            recent = sorted_history[-min(10, len(sorted_history)):]
-        
+            recent = sorted_history[-min(10, len(sorted_history)) :]
+
         # Calculate momentum (current vs average)
         sentiments = [h["sentiment"] for h in recent]
         current = sentiments[-1]
         average = sum(sentiments) / len(sentiments)
         momentum = current - average
-        
+
         # Calculate velocity (rate of change)
         if len(recent) >= 2:
-            time_diff = (recent[-1]["timestamp"] - recent[0]["timestamp"]).total_seconds() / 60
+            time_diff = (
+                recent[-1]["timestamp"] - recent[0]["timestamp"]
+            ).total_seconds() / 60
             if time_diff > 0:
                 velocity = (sentiments[-1] - sentiments[0]) / time_diff
             else:
                 velocity = 0
         else:
             velocity = 0
-        
+
         # Calculate acceleration (change in velocity)
         if len(recent) >= 3:
             mid_point = len(recent) // 2
-            first_half_velocity = (sentiments[mid_point] - sentiments[0]) / max(1, mid_point)
-            second_half_velocity = (sentiments[-1] - sentiments[mid_point]) / max(1, len(recent) - mid_point)
+            first_half_velocity = (sentiments[mid_point] - sentiments[0]) / max(
+                1, mid_point
+            )
+            second_half_velocity = (sentiments[-1] - sentiments[mid_point]) / max(
+                1, len(recent) - mid_point
+            )
             acceleration = second_half_velocity - first_half_velocity
         else:
             acceleration = 0
-        
+
         # Calculate trend strength (consistency of direction)
         if len(recent) >= 3:
-            increases = sum(1 for i in range(1, len(sentiments)) if sentiments[i] > sentiments[i-1])
-            trend_strength = abs(increases / (len(sentiments) - 1) - 0.5) * 2  # 0 = random, 1 = consistent
+            increases = sum(
+                1
+                for i in range(1, len(sentiments))
+                if sentiments[i] > sentiments[i - 1]
+            )
+            trend_strength = (
+                abs(increases / (len(sentiments) - 1) - 0.5) * 2
+            )  # 0 = random, 1 = consistent
         else:
             trend_strength = 0
-        
+
         return {
             "momentum": round(momentum, 3),
             "velocity": round(velocity, 4),
             "acceleration": round(acceleration, 4),
-            "trend_strength": round(trend_strength, 3)
+            "trend_strength": round(trend_strength, 3),
         }
-    
+
     @staticmethod
     def adjust_probability_for_momentum(
         base_probability: float,
         momentum_metrics: Dict[str, float],
-        max_adjustment: float = 0.1
+        max_adjustment: float = 0.1,
     ) -> float:
         """
         Adjust probability based on sentiment momentum.
-        
+
         Args:
             base_probability: Initial probability estimate
             momentum_metrics: Output from calculate_sentiment_momentum
             max_adjustment: Maximum probability adjustment
-        
+
         Returns:
             Momentum-adjusted probability
         """
         momentum = momentum_metrics.get("momentum", 0)
         velocity = momentum_metrics.get("velocity", 0)
         trend_strength = momentum_metrics.get("trend_strength", 0)
-        
+
         # Calculate adjustment based on momentum and trend
         # Strong, consistent momentum gets more weight
         adjustment = momentum * trend_strength * max_adjustment
-        
+
         # Boost adjustment if velocity confirms momentum direction
         if (momentum > 0 and velocity > 0) or (momentum < 0 and velocity < 0):
             adjustment *= 1.5
-        
+
         # Apply adjustment
         adjusted_prob = base_probability + adjustment
-        
+
         # Bound result
         adjusted_prob = max(0.01, min(0.99, adjusted_prob))
-        
+
         logger.debug(
             f"Momentum adjustment: base={base_probability:.3f}, "
             f"momentum={momentum:.3f}, adjustment={adjustment:.3f}, "
             f"final={adjusted_prob:.3f}"
         )
-        
+
         return adjusted_prob
-    
+
     @staticmethod
     def calculate_edge_confidence(
         probability: float,
         market_price: float,
         confidence: float,
-        min_edge: float = 0.05
+        min_edge: float = 0.05,
     ) -> Dict[str, float]:
         """
         Calculate trading edge and adjusted confidence.
-        
+
         Args:
             probability: Our estimated probability
             market_price: Current market price
             confidence: Confidence in our estimate
             min_edge: Minimum required edge
-        
+
         Returns:
             Edge metrics and trading viability
         """
         # Calculate raw edge
         edge = probability - market_price
-        
+
         # Adjust edge by confidence
         confidence_adjusted_edge = edge * confidence
-        
+
         # Calculate edge quality (how much over minimum)
         if abs(edge) > min_edge:
             edge_quality = (abs(edge) - min_edge) / min_edge
         else:
             edge_quality = 0
-        
+
         # Trading confidence (combines edge size and estimate confidence)
         trading_confidence = confidence * min(1.0, edge_quality)
-        
+
         # Determine if tradeable
         is_tradeable = abs(confidence_adjusted_edge) > min_edge
-        
+
         return {
             "raw_edge": round(edge, 3),
             "confidence_adjusted_edge": round(confidence_adjusted_edge, 3),
             "edge_quality": round(edge_quality, 3),
             "trading_confidence": round(trading_confidence, 3),
             "is_tradeable": is_tradeable,
-            "direction": "BUY_YES" if edge > 0 else "BUY_NO" if edge < 0 else "HOLD"
+            "direction": "BUY_YES" if edge > 0 else "BUY_NO" if edge < 0 else "HOLD",
         }
-    
+
     @staticmethod
     def sports_specific_adjustments(
-        base_probability: float,
-        sport: str,
-        context: Dict[str, any]
+        base_probability: float, sport: str, context: Dict[str, any]
     ) -> float:
         """
         Apply sport-specific probability adjustments.
-        
+
         Args:
             base_probability: Initial probability
             sport: Sport type (NFL, NBA, etc.)
             context: Game context (home/away, injuries, weather, etc.)
-        
+
         Returns:
             Adjusted probability with sport-specific factors
         """
         adjusted_prob = base_probability
-        
+
         if sport.upper() == "NFL":
             # Home field advantage in NFL (~2.5 points = ~7% probability)
             if context.get("is_home"):
                 adjusted_prob += 0.035
-            
+
             # Weather impact (affects passing games)
             weather = context.get("weather", {})
             if weather.get("wind_mph", 0) > 20:
@@ -339,29 +350,29 @@ def sports_specific_adjustments(
                     adjusted_prob += 0.05
                 elif context.get("team_style") == "passing":
                     adjusted_prob -= 0.05
-            
+
             # Injury adjustments
             if context.get("key_injuries", {}).get("quarterback"):
                 adjusted_prob -= 0.15  # QB injury is huge
             if context.get("key_injuries", {}).get("star_player"):
                 adjusted_prob -= 0.05  # Other key player
-        
+
         elif sport.upper() == "NBA":
             # Home court advantage in NBA (~3 points = ~10% probability)
             if context.get("is_home"):
                 adjusted_prob += 0.05
-            
+
             # Back-to-back games
             if context.get("back_to_back"):
                 adjusted_prob -= 0.08  # Fatigue factor
-            
+
             # Rest advantage
             rest_diff = context.get("rest_days_difference", 0)
             adjusted_prob += rest_diff * 0.03  # 3% per day of rest advantage
-        
+
         # Bound probability
         adjusted_prob = max(0.01, min(0.99, adjusted_prob))
-        
+
         return adjusted_prob
 
 
@@ -369,86 +380,84 @@ class MarketMaker:
     """
     Determine fair market prices based on probability estimates.
     """
-    
+
     @staticmethod
     def probability_to_market_spread(
         probability: float,
         confidence: float,
         base_spread: float = 0.02,
         min_spread: float = 0.01,
-        max_spread: float = 0.10
+        max_spread: float = 0.10,
     ) -> Tuple[float, float]:
         """
         Convert probability to bid/ask spread for market making.
-        
+
         Args:
             probability: Fair probability estimate
             confidence: Confidence in estimate (affects spread width)
             base_spread: Base spread width
             min_spread: Minimum spread
             max_spread: Maximum spread
-        
+
         Returns:
             Tuple of (bid_price, ask_price)
         """
         # Wider spread for lower confidence
         spread_multiplier = 2 - confidence  # 1x at conf=1, 2x at conf=0
         spread = base_spread * spread_multiplier
-        
+
         # Adjust spread for extreme probabilities (less liquid)
         extremeness = abs(probability - 0.5) * 2  # 0 at 50%, 1 at 0% or 100%
         spread += extremeness * 0.02
-        
+
         # Apply bounds
         spread = max(min_spread, min(max_spread, spread))
-        
+
         # Calculate bid/ask
         bid = probability - spread / 2
         ask = probability + spread / 2
-        
+
         # Ensure valid prices
         bid = max(0.01, bid)
         ask = min(0.99, ask)
-        
+
         # Ensure spread is maintained
         if ask - bid < min_spread:
             mid = (ask + bid) / 2
             bid = mid - min_spread / 2
             ask = mid + min_spread / 2
-        
+
         return (round(bid, 3), round(ask, 3))
 
 
 # Example usage
 if __name__ == "__main__":
     converter = SentimentProbabilityConverter()
-    
+
     # Example 1: Convert sentiment to probability
     sentiment_prob = converter.sentiment_to_probability(
-        sentiment_score=0.3,  # Mildly positive
-        confidence=0.8,
-        base_prob=0.5
+        sentiment_score=0.3, confidence=0.8, base_prob=0.5  # Mildly positive
     )
     print(f"Sentiment probability: {sentiment_prob:.3f}")
-    
+
     # Example 2: Combine multiple sources
     sources = {
         "sentiment": {"prob": 0.65, "weight": 0.4, "confidence": 0.8},
         "espn": {"prob": 0.60, "weight": 0.3, "confidence": 0.9},
-        "orderbook": {"prob": 0.58, "weight": 0.3, "confidence": 0.7}
+        "orderbook": {"prob": 0.58, "weight": 0.3, "confidence": 0.7},
     }
-    
+
     combined = converter.combine_probabilities(sources)
     print(f"Combined probability: {combined['probability']:.3f}")
     print(f"Aggregate confidence: {combined['confidence']:.3f}")
-    
+
     # Example 3: Calculate edge
     edge_metrics = converter.calculate_edge_confidence(
-        probability=combined['probability'],
+        probability=combined["probability"],
         market_price=0.55,
-        confidence=combined['confidence'],
-        min_edge=0.05
+        confidence=combined["confidence"],
+        min_edge=0.05,
     )
     print(f"Trading edge: {edge_metrics['raw_edge']:.3f}")
     print(f"Is tradeable: {edge_metrics['is_tradeable']}")
-    print(f"Direction: {edge_metrics['direction']}")
\ No newline at end of file
+    print(f"Direction: {edge_metrics['direction']}")
diff --git a/src/trading/stop_loss.py b/neural_sdk/trading/stop_loss.py
similarity index 83%
rename from src/trading/stop_loss.py
rename to neural_sdk/trading/stop_loss.py
index 070de992..d8b6e505 100644
--- a/src/trading/stop_loss.py
+++ b/neural_sdk/trading/stop_loss.py
@@ -3,10 +3,10 @@
 Adjusts stop-loss levels based on market conditions and sentiment momentum.
 """
 
-from typing import Dict, List, Optional, Tuple
-from datetime import datetime, timedelta
-import math
 import logging
+import math
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
 
 logger = logging.getLogger(__name__)
 
@@ -14,14 +14,14 @@
 class DynamicStopLoss:
     """
     Calculate and manage dynamic stop-losses based on market conditions.
-    
+
     Adjusts stop-loss levels based on:
     - Sentiment momentum (tighten if turning negative)
     - Market volatility (widen in volatile markets)
     - Time decay (tighten as event approaches)
     - Profit level (trailing stops for winners)
     """
-    
+
     @staticmethod
     def calculate_stop_loss(
         entry_price: float,
@@ -30,30 +30,32 @@ def calculate_stop_loss(
         volatility: float,
         time_to_event_hours: Optional[float] = None,
         base_stop_pct: float = 0.10,
-        position_type: str = "YES"
+        position_type: str = "YES",
     ) -> Dict[str, float]:
         """
         Calculate dynamic stop-loss based on market conditions.
-        
+
         Args:
-            entry_price: Entry price of position (0-1 for Kalshi)
+            entry_price: Entry price of position (0-1 for Neural)
             current_price: Current market price (0-1)
             sentiment_momentum: Rate of sentiment change (-1 to 1)
             volatility: Market volatility (0 to 1, where 0.5 is normal)
             time_to_event_hours: Hours until event resolution
             base_stop_pct: Base stop-loss percentage (0.10 = 10%)
             position_type: "YES" or "NO" position
-        
+
         Returns:
             Dictionary with stop price and related metrics
         """
         # Validate inputs
         if not 0 < entry_price < 1:
             raise ValueError(f"Entry price must be between 0 and 1, got {entry_price}")
-        
+
         if not 0 < current_price < 1:
-            raise ValueError(f"Current price must be between 0 and 1, got {current_price}")
-        
+            raise ValueError(
+                f"Current price must be between 0 and 1, got {current_price}"
+            )
+
         # Calculate base stop distance
         if position_type == "YES":
             # For YES positions, stop is below entry
@@ -61,31 +63,39 @@ def calculate_stop_loss(
         else:
             # For NO positions, stop is above entry (remember: profit when price goes DOWN)
             base_stop_distance = (1 - entry_price) * base_stop_pct
-        
+
         # Adjust for sentiment momentum
         sentiment_multiplier = DynamicStopLoss._calculate_sentiment_multiplier(
             sentiment_momentum, position_type
         )
-        
+
         # Adjust for volatility
-        volatility_multiplier = DynamicStopLoss._calculate_volatility_multiplier(volatility)
-        
+        volatility_multiplier = DynamicStopLoss._calculate_volatility_multiplier(
+            volatility
+        )
+
         # Adjust for time decay (tighten stops as event approaches)
-        time_multiplier = DynamicStopLoss._calculate_time_multiplier(time_to_event_hours)
-        
+        time_multiplier = DynamicStopLoss._calculate_time_multiplier(
+            time_to_event_hours
+        )
+
         # Calculate adjusted stop distance
         adjusted_stop_distance = (
-            base_stop_distance * 
-            sentiment_multiplier * 
-            volatility_multiplier * 
-            time_multiplier
+            base_stop_distance
+            * sentiment_multiplier
+            * volatility_multiplier
+            * time_multiplier
         )
-        
+
         # Apply bounds (5% minimum, 20% maximum)
-        min_stop = entry_price * 0.05 if position_type == "YES" else (1 - entry_price) * 0.05
-        max_stop = entry_price * 0.20 if position_type == "YES" else (1 - entry_price) * 0.20
+        min_stop = (
+            entry_price * 0.05 if position_type == "YES" else (1 - entry_price) * 0.05
+        )
+        max_stop = (
+            entry_price * 0.20 if position_type == "YES" else (1 - entry_price) * 0.20
+        )
         adjusted_stop_distance = max(min_stop, min(max_stop, adjusted_stop_distance))
-        
+
         # Calculate actual stop price
         if position_type == "YES":
             stop_price = entry_price - adjusted_stop_distance
@@ -93,15 +103,19 @@ def calculate_stop_loss(
         else:
             stop_price = entry_price + adjusted_stop_distance
             stop_price = min(0.99, stop_price)  # Can't go above $0.99
-        
+
         # Calculate stop percentage
-        stop_pct = adjusted_stop_distance / entry_price if position_type == "YES" else adjusted_stop_distance / (1 - entry_price)
-        
+        stop_pct = (
+            adjusted_stop_distance / entry_price
+            if position_type == "YES"
+            else adjusted_stop_distance / (1 - entry_price)
+        )
+
         # Determine confidence in stop placement
         confidence = DynamicStopLoss._calculate_stop_confidence(
             sentiment_momentum, volatility, time_to_event_hours
         )
-        
+
         return {
             "stop_price": round(stop_price, 3),
             "stop_distance": round(adjusted_stop_distance, 3),
@@ -113,13 +127,13 @@ def calculate_stop_loss(
             "adjustments": {
                 "sentiment_multiplier": round(sentiment_multiplier, 2),
                 "volatility_multiplier": round(volatility_multiplier, 2),
-                "time_multiplier": round(time_multiplier, 2)
+                "time_multiplier": round(time_multiplier, 2),
             },
             "reasoning": DynamicStopLoss._generate_reasoning(
                 sentiment_momentum, volatility, time_to_event_hours
-            )
+            ),
         }
-    
+
     @staticmethod
     def calculate_trailing_stop(
         entry_price: float,
@@ -127,11 +141,11 @@ def calculate_trailing_stop(
         highest_price: float,
         position_type: str = "YES",
         trail_pct: float = 0.05,
-        breakeven_threshold: float = 0.02
+        breakeven_threshold: float = 0.02,
     ) -> Dict[str, float]:
         """
         Calculate trailing stop-loss for profitable positions.
-        
+
         Args:
             entry_price: Original entry price
             current_price: Current market price
@@ -139,7 +153,7 @@ def calculate_trailing_stop(
             position_type: "YES" or "NO" position
             trail_pct: Trailing percentage from peak
             breakeven_threshold: Min profit before activating trailing stop
-        
+
         Returns:
             Trailing stop configuration
         """
@@ -147,69 +161,71 @@ def calculate_trailing_stop(
             # Calculate profit
             unrealized_profit = current_price - entry_price
             peak_profit = highest_price - entry_price
-            
+
             # Only trail if we're above breakeven threshold
             if peak_profit > breakeven_threshold:
                 # Trail from the highest price
                 trailing_stop = highest_price * (1 - trail_pct)
-                
+
                 # Ensure stop is at least at breakeven
                 trailing_stop = max(trailing_stop, entry_price)
-                
+
                 # Can't be above current price
                 trailing_stop = min(trailing_stop, current_price - 0.01)
-                
+
                 is_active = True
             else:
                 # Not enough profit to trail yet
                 trailing_stop = entry_price * (1 - 0.10)  # Default stop
                 is_active = False
-        
+
         else:  # NO position
             # For NO positions, profit when price goes DOWN
             unrealized_profit = entry_price - current_price
-            peak_profit = entry_price - highest_price  # highest_price is actually lowest for NO
-            
+            peak_profit = (
+                entry_price - highest_price
+            )  # highest_price is actually lowest for NO
+
             if peak_profit > breakeven_threshold:
                 # Trail from the lowest price (stored as highest_price)
                 trailing_stop = highest_price * (1 + trail_pct)
-                
+
                 # Ensure stop is at least at breakeven
                 trailing_stop = min(trailing_stop, entry_price)
-                
+
                 # Can't be below current price
                 trailing_stop = max(trailing_stop, current_price + 0.01)
-                
+
                 is_active = True
             else:
                 trailing_stop = entry_price * (1 + 0.10)  # Default stop
                 is_active = False
-        
+
         return {
             "trailing_stop": round(trailing_stop, 3),
             "is_active": is_active,
             "unrealized_profit": round(unrealized_profit, 3),
             "peak_profit": round(peak_profit, 3),
             "trail_distance": round(abs(current_price - trailing_stop), 3),
-            "position_type": position_type
+            "position_type": position_type,
         }
-    
+
     @staticmethod
     def calculate_time_based_stop(
         entry_price: float,
         position_type: str,
         time_to_event_hours: float,
-        urgency_factor: float = 1.0
+        urgency_factor: float = 1.0,
     ) -> Dict[str, float]:
         """
         Calculate time-based stop that tightens as event approaches.
-        
+
         Args:
             entry_price: Entry price of position
             position_type: "YES" or "NO"
             time_to_event_hours: Hours until event resolution
             urgency_factor: Multiplier for urgency (1.0 = normal, 2.0 = urgent)
-        
+
         Returns:
             Time-based stop configuration
         """
@@ -218,9 +234,9 @@ def calculate_time_based_stop(
             return {
                 "stop_price": entry_price,
                 "urgency": "IMMEDIATE",
-                "reason": "Event has concluded"
+                "reason": "Event has concluded",
             }
-        
+
         # Calculate time-based stop percentage
         # Tighter stops as we approach the event
         if time_to_event_hours > 48:
@@ -243,10 +259,10 @@ def calculate_time_based_stop(
             # Less than 1 hour: minimal stop
             stop_pct = 0.03
             urgency = "CRITICAL"
-        
+
         # Apply urgency factor
-        stop_pct *= (1 / urgency_factor)
-        
+        stop_pct *= 1 / urgency_factor
+
         # Calculate stop price
         if position_type == "YES":
             stop_price = entry_price * (1 - stop_pct)
@@ -254,38 +270,38 @@ def calculate_time_based_stop(
         else:
             stop_price = entry_price * (1 + stop_pct)
             stop_price = min(0.99, stop_price)
-        
+
         return {
             "stop_price": round(stop_price, 3),
             "stop_pct": round(stop_pct, 3),
             "time_to_event_hours": time_to_event_hours,
             "urgency": urgency,
-            "urgency_factor": urgency_factor
+            "urgency_factor": urgency_factor,
         }
-    
+
     @staticmethod
     def calculate_correlated_stops(
         positions: List[Dict[str, float]],
         correlation_matrix: Dict[Tuple[str, str], float],
-        base_stop_pct: float = 0.10
+        base_stop_pct: float = 0.10,
     ) -> Dict[str, Dict[str, float]]:
         """
         Calculate stop-losses for correlated positions.
         Tighter stops for highly correlated positions to limit cascade losses.
-        
+
         Args:
             positions: List of position dictionaries
             correlation_matrix: Correlation between markets
             base_stop_pct: Base stop percentage
-        
+
         Returns:
             Stop configuration for each position
         """
         stops = {}
-        
+
         for i, pos in enumerate(positions):
             market = pos["market_ticker"]
-            
+
             # Calculate correlation penalty
             max_correlation = 0
             for j, other_pos in enumerate(positions):
@@ -294,33 +310,35 @@ def calculate_correlated_stops(
                     corr_key = tuple(sorted([market, other_market]))
                     correlation = abs(correlation_matrix.get(corr_key, 0))
                     max_correlation = max(max_correlation, correlation)
-            
+
             # Tighten stop for correlated positions
             # High correlation = tighter stop to prevent cascade
             correlation_multiplier = 1 - (max_correlation * 0.3)  # Up to 30% tighter
-            
+
             adjusted_stop_pct = base_stop_pct * correlation_multiplier
-            
+
             # Calculate stop price
             entry_price = pos["entry_price"]
             position_type = pos["position_type"]
-            
+
             if position_type == "YES":
                 stop_price = entry_price * (1 - adjusted_stop_pct)
             else:
                 stop_price = entry_price * (1 + adjusted_stop_pct)
-            
+
             stops[market] = {
                 "stop_price": round(stop_price, 3),
                 "stop_pct": round(adjusted_stop_pct, 3),
                 "correlation_penalty": round(1 - correlation_multiplier, 3),
-                "max_correlation": round(max_correlation, 3)
+                "max_correlation": round(max_correlation, 3),
             }
-        
+
         return stops
-    
+
     @staticmethod
-    def _calculate_sentiment_multiplier(sentiment_momentum: float, position_type: str) -> float:
+    def _calculate_sentiment_multiplier(
+        sentiment_momentum: float, position_type: str
+    ) -> float:
         """Calculate stop adjustment based on sentiment momentum."""
         if position_type == "YES":
             # For YES positions, negative momentum = tighter stop
@@ -342,15 +360,15 @@ def _calculate_sentiment_multiplier(sentiment_momentum: float, position_type: st
                 return 1.5  # 50% wider stop
             elif sentiment_momentum < -0.1:
                 return 1.25  # 25% wider
-        
+
         return 1.0  # No adjustment
-    
+
     @staticmethod
     def _calculate_volatility_multiplier(volatility: float) -> float:
         """Calculate stop adjustment based on volatility."""
         # Higher volatility = wider stops to avoid whipsaws
         # volatility: 0 = low, 0.5 = normal, 1.0 = high
-        
+
         if volatility < 0.3:
             return 0.8  # Low volatility: tighter stop
         elif volatility < 0.5:
@@ -359,13 +377,13 @@ def _calculate_volatility_multiplier(volatility: float) -> float:
             return 1.3  # High volatility: wider stop
         else:
             return 1.5  # Very high volatility: much wider stop
-    
+
     @staticmethod
     def _calculate_time_multiplier(time_to_event_hours: Optional[float]) -> float:
         """Calculate stop adjustment based on time to event."""
         if time_to_event_hours is None:
             return 1.0
-        
+
         if time_to_event_hours < 6:
             return 0.5  # Very close to event: tight stop
         elif time_to_event_hours < 24:
@@ -374,37 +392,37 @@ def _calculate_time_multiplier(time_to_event_hours: Optional[float]) -> float:
             return 1.0  # 1-3 days: normal
         else:
             return 1.25  # Far from event: wider stop
-    
+
     @staticmethod
     def _calculate_stop_confidence(
         sentiment_momentum: float,
         volatility: float,
-        time_to_event_hours: Optional[float]
+        time_to_event_hours: Optional[float],
     ) -> float:
         """Calculate confidence in stop placement."""
         confidence = 1.0
-        
+
         # Lower confidence in high volatility
         confidence -= volatility * 0.3
-        
+
         # Lower confidence with strong momentum (might break stop)
         confidence -= abs(sentiment_momentum) * 0.2
-        
+
         # Higher confidence closer to event (clearer outcome)
         if time_to_event_hours is not None and time_to_event_hours < 24:
             confidence += 0.1
-        
+
         return max(0.3, min(1.0, confidence))
-    
+
     @staticmethod
     def _generate_reasoning(
         sentiment_momentum: float,
         volatility: float,
-        time_to_event_hours: Optional[float]
+        time_to_event_hours: Optional[float],
     ) -> str:
         """Generate human-readable reasoning for stop placement."""
         reasons = []
-        
+
         # Sentiment reasoning
         if abs(sentiment_momentum) > 0.3:
             direction = "negative" if sentiment_momentum < 0 else "positive"
@@ -412,20 +430,20 @@ def _generate_reasoning(
         elif abs(sentiment_momentum) > 0.1:
             direction = "negative" if sentiment_momentum < 0 else "positive"
             reasons.append(f"Moderate {direction} sentiment")
-        
+
         # Volatility reasoning
         if volatility > 0.7:
             reasons.append("High volatility requires wider stop")
         elif volatility < 0.3:
             reasons.append("Low volatility allows tighter stop")
-        
+
         # Time reasoning
         if time_to_event_hours is not None:
             if time_to_event_hours < 6:
                 reasons.append("Very close to event - tight risk control")
             elif time_to_event_hours < 24:
                 reasons.append("Approaching event - moderate stop")
-        
+
         return "; ".join(reasons) if reasons else "Standard stop placement"
 
 
@@ -433,88 +451,90 @@ class StopLossManager:
     """
     Manage stop-losses across multiple positions.
     """
-    
+
     def __init__(self):
         """Initialize stop-loss manager."""
         self.active_stops: Dict[str, Dict[str, float]] = {}
         self.stop_history: List[Dict[str, any]] = []
-    
+
     def update_stop(
         self,
         market_ticker: str,
         stop_price: float,
         stop_type: str = "FIXED",
-        metadata: Optional[Dict] = None
+        metadata: Optional[Dict] = None,
     ):
         """Update stop-loss for a position."""
         self.active_stops[market_ticker] = {
             "stop_price": stop_price,
             "stop_type": stop_type,
             "updated_at": datetime.now(),
-            "metadata": metadata or {}
+            "metadata": metadata or {},
         }
-        
+
         # Log to history
-        self.stop_history.append({
-            "market_ticker": market_ticker,
-            "stop_price": stop_price,
-            "stop_type": stop_type,
-            "timestamp": datetime.now(),
-            "metadata": metadata
-        })
-    
-    def check_stops(
-        self,
-        current_prices: Dict[str, float]
-    ) -> List[Dict[str, any]]:
+        self.stop_history.append(
+            {
+                "market_ticker": market_ticker,
+                "stop_price": stop_price,
+                "stop_type": stop_type,
+                "timestamp": datetime.now(),
+                "metadata": metadata,
+            }
+        )
+
+    def check_stops(self, current_prices: Dict[str, float]) -> List[Dict[str, any]]:
         """
         Check if any stops have been triggered.
-        
+
         Args:
             current_prices: Current market prices
-        
+
         Returns:
             List of triggered stops
         """
         triggered = []
-        
+
         for market_ticker, stop_config in self.active_stops.items():
             if market_ticker not in current_prices:
                 continue
-            
+
             current_price = current_prices[market_ticker]
             stop_price = stop_config["stop_price"]
             position_type = stop_config.get("metadata", {}).get("position_type", "YES")
-            
+
             # Check if stop is triggered
             if position_type == "YES" and current_price <= stop_price:
-                triggered.append({
-                    "market_ticker": market_ticker,
-                    "stop_price": stop_price,
-                    "current_price": current_price,
-                    "position_type": position_type,
-                    "reason": "Stop-loss triggered (YES position)"
-                })
+                triggered.append(
+                    {
+                        "market_ticker": market_ticker,
+                        "stop_price": stop_price,
+                        "current_price": current_price,
+                        "position_type": position_type,
+                        "reason": "Stop-loss triggered (YES position)",
+                    }
+                )
             elif position_type == "NO" and current_price >= stop_price:
-                triggered.append({
-                    "market_ticker": market_ticker,
-                    "stop_price": stop_price,
-                    "current_price": current_price,
-                    "position_type": position_type,
-                    "reason": "Stop-loss triggered (NO position)"
-                })
-        
+                triggered.append(
+                    {
+                        "market_ticker": market_ticker,
+                        "stop_price": stop_price,
+                        "current_price": current_price,
+                        "position_type": position_type,
+                        "reason": "Stop-loss triggered (NO position)",
+                    }
+                )
+
         return triggered
-    
+
     def get_stop_summary(self) -> Dict[str, any]:
         """Get summary of all active stops."""
         return {
             "active_stops": len(self.active_stops),
             "stops": self.active_stops,
             "last_update": max(
-                (s["updated_at"] for s in self.active_stops.values()),
-                default=None
-            )
+                (s["updated_at"] for s in self.active_stops.values()), default=None
+            ),
         }
 
 
@@ -522,7 +542,7 @@ def get_stop_summary(self) -> Dict[str, any]:
 if __name__ == "__main__":
     # Example: Calculate dynamic stop for a position
     stop_calc = DynamicStopLoss()
-    
+
     # YES position with negative sentiment momentum
     stop_config = stop_calc.calculate_stop_loss(
         entry_price=0.45,
@@ -531,25 +551,22 @@ def get_stop_summary(self) -> Dict[str, any]:
         volatility=0.6,  # Moderate-high volatility
         time_to_event_hours=12,  # 12 hours to event
         base_stop_pct=0.10,
-        position_type="YES"
+        position_type="YES",
     )
-    
+
     print("Dynamic Stop Configuration:")
     print(f"Entry: ${stop_config['entry_price']:.2f}")
     print(f"Stop: ${stop_config['stop_price']:.2f}")
     print(f"Stop Distance: {stop_config['stop_pct']:.1%}")
     print(f"Confidence: {stop_config['confidence']:.1%}")
     print(f"Reasoning: {stop_config['reasoning']}")
-    
+
     # Example: Trailing stop for profitable position
     trailing = stop_calc.calculate_trailing_stop(
-        entry_price=0.40,
-        current_price=0.55,
-        highest_price=0.60,
-        position_type="YES"
+        entry_price=0.40, current_price=0.55, highest_price=0.60, position_type="YES"
     )
-    
+
     print("\nTrailing Stop:")
     print(f"Trailing Stop: ${trailing['trailing_stop']:.2f}")
     print(f"Active: {trailing['is_active']}")
-    print(f"Unrealized Profit: ${trailing['unrealized_profit']:.2f}")
\ No newline at end of file
+    print(f"Unrealized Profit: ${trailing['unrealized_profit']:.2f}")
diff --git a/neural_sdk/utils/__init__.py b/neural_sdk/utils/__init__.py
new file mode 100644
index 00000000..41f5a4f8
--- /dev/null
+++ b/neural_sdk/utils/__init__.py
@@ -0,0 +1,52 @@
+"""
+Utilities Module
+
+Common utility functions and helpers for the Neural SDK.
+"""
+
+import json
+import logging
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+def setup_logging(level: str = "INFO") -> None:
+    """Set up standardized logging configuration."""
+    logging.basicConfig(
+        level=getattr(logging, level.upper()),
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+
+def safe_get(data: Dict[str, Any], key: str, default: Any = None) -> Any:
+    """Safely get a value from a dictionary with nested key support."""
+    try:
+        keys = key.split(".")
+        value = data
+        for k in keys:
+            value = value[k]
+        return value
+    except (KeyError, TypeError):
+        return default
+
+
+def format_price(price: float, precision: int = 2) -> str:
+    """Format price with proper precision."""
+    return f"${price:.{precision}f}"
+
+
+def timestamp_to_string(
+    timestamp: datetime, format_str: str = "%Y-%m-%d %H:%M:%S"
+) -> str:
+    """Convert timestamp to formatted string."""
+    return timestamp.strftime(format_str)
+
+
+def validate_config(config: Dict[str, Any], required_keys: list) -> bool:
+    """Validate that all required keys are present in config."""
+    missing_keys = [key for key in required_keys if key not in config]
+    if missing_keys:
+        logging.error(f"Missing required configuration keys: {missing_keys}")
+        return False
+    return True
diff --git a/pyproject.toml b/pyproject.toml
index daf3499f..bafbc93d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,10 +1,27 @@
 [project]
-name = "kalshi-agentic-agent"
-version = "0.1.0"
-description = "Autonomous Agent for Trading Sport Event Contracts on the Kalshi Platform"
+name = "neural-sdk"
+version = "1.0.0"
+description = "Neural - Open-source SDK for algorithmic prediction market trading"
+authors = [
+    {name = "Neural SDK Team", email = "sdk@neural.dev"}
+]
+license = {text = "MIT"}
 requires-python = ">=3.10, <3.13"
+keywords = ["trading", "neural", "prediction-markets", "algorithmic", "sdk", "backtesting", "ai"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Office/Business :: Financial :: Investment",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Distributed Computing",
+]
 dependencies = [
-    "agentuity>=0.0.103",
     "kalshi-python>=2.0.0",
     "websockets>=11.0",
     "websocket-client>=1.6.0",
@@ -20,15 +37,137 @@ dependencies = [
     "pyyaml>=6.0.1",
     "pytz>=2023.3",
     "python-dateutil>=2.8.2",
-    "nest-asyncio>=1.5.8",
-    "cryptography>=41.0.0",
-    "e2b>=0.17.0",
-    "psutil>=5.9.0",
     "redis[asyncio]>=4.6.0",
+    "structlog>=23.1.0",
+    "typer>=0.9.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.0.0",
+    "black>=23.0.0",
+    "isort>=5.12.0",
+    "mypy>=1.0.0",
+    "types-PyYAML",
+    "types-colorama",
+    "pandas-stubs",
+    "pre-commit>=3.0.0",
+    "sphinx>=5.0.0",
+    "sphinx-rtd-theme>=1.2.0",
+]
+docs = [
+    "sphinx>=5.0.0",
+    "sphinx-rtd-theme>=1.2.0",
+    "myst-parser>=0.18.0",
+]
+llm = [
+    "agno>=0.1.0",  # Optional LLM integration
+]
+s3 = [
+    "boto3>=1.26.0",  # S3 data provider
+]
+database = [
+    "sqlalchemy>=2.0.0",  # Database data provider
+    "psycopg2-binary>=2.9.0",  # PostgreSQL support
+]
+parquet = [
+    "pyarrow>=10.0.0",  # High-performance parquet support
+]
+plotting = [
+    "matplotlib>=3.5.0",  # Plotting support
+    "seaborn>=0.11.0",    # Enhanced plotting
+]
+all = [
+    "boto3>=1.26.0",
+    "sqlalchemy>=2.0.0", 
+    "psycopg2-binary>=2.9.0",
+    "pyarrow>=10.0.0",
+    "matplotlib>=3.5.0",
+    "seaborn>=0.11.0",
 ]
 
+[project.urls]
+Homepage = "https://github.com/neural/neural-sdk"
+Documentation = "https://neural-sdk.readthedocs.io/"
+Repository = "https://github.com/neural/neural-sdk"
+Issues = "https://github.com/neural/neural-sdk/issues"
+Changelog = "https://github.com/neural/neural-sdk/blob/main/CHANGELOG.md"
+
+[project.scripts]
+neural-sdk = "neural_sdk.cli:main"
+
 [tool.setuptools]
-packages = ["agents", "agentuity_agents", "tools", "kalshi_web_infra"]
+packages = {"find" = {}}
 
 [tool.setuptools.package-data]
-"*" = ["*.py"]
+"*" = ["*.py", "*.yaml", "*.json"]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 88
+target-version = ['py310', 'py311', 'py312']
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # directories
+  \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 88
+known_first_party = ["neural_sdk"]
+known_third_party = ["pydantic", "redis", "aiohttp"]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+strict_equality = true
+show_error_codes = true
+
+[[tool.mypy.overrides]]
+module = "neural_sdk.*"
+disallow_untyped_defs = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "--strict-markers",
+    "--strict-config",
+    "--cov=neural_sdk",
+    "--cov-report=term-missing",
+    "--cov-report=html:htmlcov",
+    "--cov-fail-under=80"
+]
+markers = [
+    "unit: Unit tests",
+    "integration: Integration tests",
+    "slow: Slow running tests"
+]
diff --git a/scripts/demo_investor.py b/scripts/demo_investor.py
deleted file mode 100644
index abc2ffac..00000000
--- a/scripts/demo_investor.py
+++ /dev/null
@@ -1,341 +0,0 @@
-#!/usr/bin/env python3
-"""
-Investor Demo Script - Kalshi Trading Agent Platform
-Interactive demonstration of the system's capabilities
-"""
-
-import asyncio
-import time
-import random
-from datetime import datetime, timedelta
-from typing import Dict, Any, List
-from rich.console import Console
-from rich.table import Table
-from rich.live import Live
-from rich.layout import Layout
-from rich.panel import Panel
-from rich.progress import Progress, SpinnerColumn, TextColumn
-from rich.syntax import Syntax
-from rich import box
-import json
-
-console = Console()
-
-class InvestorDemo:
-    """Interactive demonstration of the Kalshi Trading Platform"""
-    
-    def __init__(self):
-        self.console = console
-        self.markets = [
-            {"ticker": "NFL-KC-BUF", "event": "Chiefs vs Bills", "yes": 0.65, "no": 0.35},
-            {"ticker": "NBA-LAL-BOS", "event": "Lakers vs Celtics", "yes": 0.48, "no": 0.52},
-            {"ticker": "MLB-NYY-HOU", "event": "Yankees vs Astros", "yes": 0.71, "no": 0.29},
-        ]
-        self.pnl = 0
-        self.trades = []
-        self.win_rate = 0.67
-        
-    def display_header(self):
-        """Display platform header"""
-        header = Panel.fit(
-            "[bold cyan]KALSHI TRADING AGENT PLATFORM[/bold cyan]\n"
-            "[yellow]AI-Powered Sports Prediction Market Trading[/yellow]",
-            box=box.DOUBLE
-        )
-        self.console.print(header)
-        
-    def show_system_architecture(self):
-        """Display system architecture"""
-        self.console.print("\n[bold]System Architecture:[/bold]")
-        
-        architecture = """
-┌─────────────────────────────────────────────┐
-│          DATA INGESTION LAYER               │
-│   Kalshi WebSocket │ ESPN │ Twitter         │
-├─────────────────────────────────────────────┤
-│         UNIFIED STREAM MANAGER              │
-│   Event Correlation & Synchronization       │
-├─────────────────────────────────────────────┤
-│           REDIS PUB/SUB HUB                 │
-│   10K msg/sec │ Channel Routing             │
-├─────────────────────────────────────────────┤
-│          AI AGENT LAYER                     │
-│   Data Coord │ Strategy │ Risk │ Executor   │
-├─────────────────────────────────────────────┤
-│          KALSHI TRADING API                 │
-│   Orders │ Positions │ Settlement           │
-└─────────────────────────────────────────────┘
-        """
-        
-        self.console.print(Panel(architecture, title="[bold]Platform Architecture[/bold]"))
-        
-    async def simulate_live_trading(self):
-        """Simulate live trading activity"""
-        self.console.print("\n[bold green]Starting Live Trading Simulation...[/bold green]\n")
-        
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=self.console
-        ) as progress:
-            
-            # Initialize components
-            tasks = [
-                "Connecting to Kalshi WebSocket",
-                "Initializing ESPN GameCast stream", 
-                "Starting Twitter sentiment analyzer",
-                "Loading AI agent models",
-                "Activating risk management system"
-            ]
-            
-            for task_desc in tasks:
-                task = progress.add_task(task_desc, total=None)
-                await asyncio.sleep(0.5)
-                progress.update(task, completed=True)
-                self.console.print(f"✓ {task_desc}", style="green")
-        
-        self.console.print("\n[bold]System Ready - Monitoring 3 Markets[/bold]\n")
-        
-    async def show_live_data_flow(self):
-        """Display live data flow"""
-        self.console.print("[bold]Live Data Flow:[/bold]\n")
-        
-        events = [
-            {
-                "time": datetime.now(),
-                "source": "ESPN",
-                "event": "Touchdown Chiefs! Mahomes 45-yard pass",
-                "impact": "HIGH"
-            },
-            {
-                "time": datetime.now() + timedelta(seconds=1),
-                "source": "Twitter", 
-                "event": "Sentiment spike detected: +2,341 mentions/min",
-                "impact": "MEDIUM"
-            },
-            {
-                "time": datetime.now() + timedelta(seconds=2),
-                "source": "Kalshi",
-                "event": "Price movement detected: $0.62 → $0.65",
-                "impact": "HIGH"
-            },
-            {
-                "time": datetime.now() + timedelta(seconds=3),
-                "source": "System",
-                "event": "OPPORTUNITY: Market lagging game event",
-                "impact": "SIGNAL"
-            }
-        ]
-        
-        for event in events:
-            await asyncio.sleep(0.8)
-            
-            style = "yellow"
-            if event["impact"] == "HIGH":
-                style = "red"
-            elif event["impact"] == "SIGNAL":
-                style = "bold green"
-                
-            self.console.print(
-                f"[{style}][{event['time'].strftime('%H:%M:%S')}] "
-                f"{event['source']}: {event['event']}[/{style}]"
-            )
-        
-    async def execute_demo_trade(self):
-        """Execute a demonstration trade"""
-        self.console.print("\n[bold cyan]Executing Trade:[/bold cyan]\n")
-        
-        trade = {
-            "market": "NFL-KC-BUF",
-            "side": "YES",
-            "price": 0.65,
-            "size": 100,
-            "edge": 0.083,
-            "confidence": 0.78
-        }
-        
-        # Show trade analysis
-        analysis_table = Table(title="Trade Analysis", box=box.ROUNDED)
-        analysis_table.add_column("Metric", style="cyan")
-        analysis_table.add_column("Value", style="green")
-        
-        analysis_table.add_row("Market", trade["market"])
-        analysis_table.add_row("Signal Strength", f"{trade['confidence']:.1%}")
-        analysis_table.add_row("Expected Edge", f"{trade['edge']:.1%}")
-        analysis_table.add_row("Kelly Position", f"${trade['size'] * trade['price']:.2f}")
-        analysis_table.add_row("Risk/Reward", "1:2.8")
-        
-        self.console.print(analysis_table)
-        
-        # Simulate order execution
-        await asyncio.sleep(1)
-        self.console.print("\n[green]✓ Order FILLED @ $0.65[/green]")
-        
-        # Show price movement
-        await asyncio.sleep(1.5)
-        self.console.print("[yellow]Market moved: $0.65 → $0.69 (+6.2%)[/yellow]")
-        
-        profit = trade["size"] * (0.69 - 0.65)
-        self.pnl += profit
-        self.console.print(f"[bold green]Profit: +${profit:.2f}[/bold green]")
-        
-    def show_performance_metrics(self):
-        """Display performance metrics"""
-        self.console.print("\n[bold]Performance Metrics:[/bold]\n")
-        
-        metrics_table = Table(title="Historical Performance (2024)", box=box.HEAVY)
-        metrics_table.add_column("Metric", style="cyan", width=20)
-        metrics_table.add_column("Value", style="green", width=15)
-        metrics_table.add_column("Benchmark", style="yellow", width=15)
-        
-        metrics = [
-            ("Sharpe Ratio", "2.87", "1.5"),
-            ("Win Rate", "67.3%", "52%"),
-            ("Avg Win/Loss", "1.82", "1.0"),
-            ("Max Drawdown", "-12.4%", "-25%"),
-            ("Annual Return", "+187%", "+35%"),
-            ("Profit Factor", "2.41", "1.3"),
-        ]
-        
-        for metric, value, benchmark in metrics:
-            metrics_table.add_row(metric, value, benchmark)
-        
-        self.console.print(metrics_table)
-        
-    def show_risk_management(self):
-        """Display risk management system"""
-        self.console.print("\n[bold]Risk Management System:[/bold]\n")
-        
-        risk_panel = Panel(
-            "[cyan]Multi-Layer Risk Control:[/cyan]\n\n"
-            "Level 1: [green]Pre-Trade Checks[/green]\n"
-            "  • Liquidity verification ✓\n"
-            "  • Correlation analysis ✓\n"
-            "  • Kelly position sizing ✓\n\n"
-            "Level 2: [yellow]Real-Time Monitoring[/yellow]\n"
-            "  • Stop-loss triggers\n"
-            "  • Drawdown breakers\n"
-            "  • Volatility adjustment\n\n"
-            "Level 3: [red]System Protection[/red]\n"
-            "  • Rate limiting\n"
-            "  • Connection redundancy\n"
-            "  • Emergency shutdown",
-            title="[bold]Risk Control Framework[/bold]",
-            box=box.DOUBLE
-        )
-        
-        self.console.print(risk_panel)
-        
-    def show_market_opportunity(self):
-        """Display market opportunity"""
-        self.console.print("\n[bold]Market Opportunity:[/bold]\n")
-        
-        opp_table = Table(box=box.SIMPLE)
-        opp_table.add_column("Market Size", style="cyan")
-        opp_table.add_column("Current", style="yellow")
-        opp_table.add_column("2025 Projection", style="green")
-        
-        opp_table.add_row("Kalshi Volume", "$2M/day", "$10M/day")
-        opp_table.add_row("Total Prediction Markets", "$10B", "$50B")
-        opp_table.add_row("Sports Betting", "$150B", "$250B")
-        
-        self.console.print(opp_table)
-        
-        self.console.print("\n[bold]Revenue Model:[/bold]")
-        self.console.print("• Performance Fee: 20% of profits")
-        self.console.print("• Management Fee: 2% AUM")
-        self.console.print("• License Revenue: White-label to funds")
-        
-    def show_live_dashboard(self):
-        """Display live trading dashboard"""
-        self.console.print("\n[bold]Live Trading Dashboard:[/bold]\n")
-        
-        dashboard = f"""
-╔══════════════════════════════════════════════╗
-║         KALSHI TRADING PLATFORM              ║
-╠══════════════════════════════════════════════╣
-║                                              ║
-║  Status: [green]● ACTIVE[/green]                            ║
-║  Markets: 3 │ Agents: 5 │ Latency: 23ms     ║
-║                                              ║
-║  Today's Performance                         ║
-║  P&L: [green]+$1,247.83[/green] │ Trades: 18 │ Win: 72%   ║
-║                                              ║
-║  Active Positions                            ║
-║  • NFL-KC-BUF    [green]+$125[/green]  ▲ 6.2%           ║
-║  • NBA-LAL-BOS   [green]+$87[/green]   ▲ 3.1%           ║
-║  • MLB-NYY-HOU   [yellow]-$23[/yellow]   ▼ 1.2%           ║
-║                                              ║
-║  System Health                               ║
-║  CPU: ▓▓▓░░░░░░░ 28%                       ║
-║  MEM: ▓▓▓▓▓░░░░░ 52%                       ║
-║  API: ▓▓░░░░░░░░ 234/1000 calls            ║
-║                                              ║
-╚══════════════════════════════════════════════╝
-        """
-        
-        self.console.print(Panel(dashboard, box=box.HEAVY))
-        
-    async def run_full_demo(self):
-        """Run complete investor demonstration"""
-        self.display_header()
-        
-        # System Overview
-        self.console.print("\n[bold magenta]═══ SYSTEM OVERVIEW ═══[/bold magenta]\n")
-        self.show_system_architecture()
-        input("\n[dim]Press Enter to continue...[/dim]")
-        
-        # Live Trading Demo
-        self.console.print("\n[bold magenta]═══ LIVE TRADING DEMONSTRATION ═══[/bold magenta]\n")
-        await self.simulate_live_trading()
-        await self.show_live_data_flow()
-        await self.execute_demo_trade()
-        input("\n[dim]Press Enter to continue...[/dim]")
-        
-        # Performance & Risk
-        self.console.print("\n[bold magenta]═══ PERFORMANCE & RISK ═══[/bold magenta]\n")
-        self.show_performance_metrics()
-        self.show_risk_management()
-        input("\n[dim]Press Enter to continue...[/dim]")
-        
-        # Market Opportunity
-        self.console.print("\n[bold magenta]═══ INVESTMENT OPPORTUNITY ═══[/bold magenta]\n")
-        self.show_market_opportunity()
-        
-        # Live Dashboard
-        self.console.print("\n[bold magenta]═══ LIVE DASHBOARD ═══[/bold magenta]\n")
-        self.show_live_dashboard()
-        
-        # Closing
-        self.console.print("\n[bold green]═══ DEMO COMPLETE ═══[/bold green]\n")
-        self.console.print(
-            Panel(
-                "[bold]Thank you for watching the Kalshi Trading Agent Platform demo![/bold]\n\n"
-                "This system represents the future of algorithmic trading in\n"
-                "prediction markets - combining speed, intelligence, and scale\n"
-                "to capture opportunities invisible to human traders.\n\n"
-                "[cyan]For investment inquiries or technical deep-dive:[/cyan]\n"
-                "• View full documentation: /docs\n"
-                "• Run backtesting suite: python scripts/run_backtest.py\n"
-                "• Start paper trading: python scripts/run_agents.py --paper",
-                title="[bold]Next Steps[/bold]",
-                box=box.DOUBLE
-            )
-        )
-
-
-async def main():
-    """Run the investor demo"""
-    demo = InvestorDemo()
-    
-    try:
-        await demo.run_full_demo()
-    except KeyboardInterrupt:
-        console.print("\n[yellow]Demo interrupted by user[/yellow]")
-    except Exception as e:
-        console.print(f"\n[red]Error during demo: {e}[/red]")
-
-
-if __name__ == "__main__":
-    console.print("[bold]Starting Kalshi Trading Platform Investor Demo...[/bold]\n")
-    asyncio.run(main())
\ No newline at end of file
diff --git a/scripts/demo_sdk.py b/scripts/demo_sdk.py
deleted file mode 100644
index 627a948c..00000000
--- a/scripts/demo_sdk.py
+++ /dev/null
@@ -1,305 +0,0 @@
-#!/usr/bin/env python3
-"""
-SDK Demo - Shows how to use the Data Source SDK
-"""
-
-import asyncio
-import logging
-from typing import Dict, Any
-from datetime import datetime
-import sys
-import os
-
-# Add src to path
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from src.sdk import SDKManager, StandardizedEvent, EventType
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-
-class EventProcessor:
-    """Process events from data sources"""
-    
-    def __init__(self):
-        self.event_counts = {}
-        self.high_impact_events = []
-        
-    async def process_event(self, event: StandardizedEvent):
-        """
-        Process a standardized event
-        
-        Args:
-            event: Event from a data source
-        """
-        # Track event counts
-        source = event.source
-        self.event_counts[source] = self.event_counts.get(source, 0) + 1
-        
-        # Log high-impact events
-        if event.impact in ["high", "critical"]:
-            self.high_impact_events.append(event)
-            logger.info(
-                f"🔴 HIGH IMPACT: {event.source} - {event.event_type.value}\n"
-                f"   Confidence: {event.confidence:.2f}\n"
-                f"   Data: {event.data}"
-            )
-        
-        # Process by event type
-        if event.event_type == EventType.ODDS_CHANGE:
-            await self.handle_odds_change(event)
-        elif event.event_type == EventType.SENTIMENT_SHIFT:
-            await self.handle_sentiment_shift(event)
-        elif event.event_type == EventType.WEATHER_UPDATE:
-            await self.handle_weather_update(event)
-    
-    async def handle_odds_change(self, event: StandardizedEvent):
-        """Handle odds change event from sportsbook"""
-        data = event.data
-        logger.info(
-            f"📊 Odds Change: {data.get('event_name')}\n"
-            f"   Market: {data.get('market_type')}\n"
-            f"   Change: {data.get('previous_odds'):.3f} → {data.get('current_odds'):.3f}\n"
-            f"   Direction: {data.get('direction')}"
-        )
-        
-        # Check for arbitrage opportunity
-        if event.confidence > 0.8:
-            logger.warning("⚡ Potential arbitrage opportunity detected!")
-    
-    async def handle_sentiment_shift(self, event: StandardizedEvent):
-        """Handle sentiment shift from Reddit"""
-        data = event.data
-        logger.info(
-            f"💬 Sentiment Shift: {data.get('thread_title', 'Unknown')}\n"
-            f"   Shift: {data.get('shift'):.3f} ({data.get('direction')})\n"
-            f"   Sample: {data.get('comment_sample', [''])[0][:50]}..."
-        )
-    
-    async def handle_weather_update(self, event: StandardizedEvent):
-        """Handle weather update"""
-        data = event.data
-        logger.info(
-            f"🌤️ Weather Alert: {data.get('stadium')}\n"
-            f"   Condition: {data.get('condition')}\n"
-            f"   Impact: {event.metadata.get('affects', [])}"
-        )
-    
-    def print_summary(self):
-        """Print processing summary"""
-        print("\n" + "="*50)
-        print("EVENT PROCESSING SUMMARY")
-        print("="*50)
-        
-        print("\nEvent Counts by Source:")
-        for source, count in self.event_counts.items():
-            print(f"  {source}: {count} events")
-        
-        print(f"\nHigh Impact Events: {len(self.high_impact_events)}")
-        for event in self.high_impact_events[-5:]:  # Last 5
-            print(f"  - {event.source}: {event.event_type.value}")
-        
-        print("="*50)
-
-
-async def demo_basic_usage():
-    """Demonstrate basic SDK usage"""
-    print("\n" + "="*50)
-    print("NEURAL TRADING PLATFORM - DATA SOURCE SDK DEMO")
-    print("="*50)
-    
-    # Initialize SDK Manager
-    sdk = SDKManager(config_path="config/data_sources.yaml")
-    processor = EventProcessor()
-    
-    try:
-        # Initialize adapters
-        print("\n📡 Initializing data sources...")
-        await sdk.initialize()
-        
-        # Show loaded adapters
-        print(f"\n✅ Loaded {len(sdk.adapters)} adapters:")
-        for name, adapter in sdk.adapters.items():
-            metadata = adapter.metadata
-            print(f"  • {metadata.name} v{metadata.version}")
-            print(f"    Type: {metadata.source_type}")
-            print(f"    Latency: {metadata.latency_ms}ms")
-            print(f"    Reliability: {metadata.reliability:.1%}")
-        
-        # Start streaming
-        print("\n🚀 Starting data streams...")
-        await sdk.start()
-        
-        # Process events for demo duration
-        print("\n📊 Processing events (30 seconds)...")
-        print("-" * 50)
-        
-        start_time = asyncio.get_event_loop().time()
-        duration = 30  # seconds
-        
-        async for event in sdk.get_events():
-            await processor.process_event(event)
-            
-            # Check if demo duration exceeded
-            if asyncio.get_event_loop().time() - start_time > duration:
-                break
-        
-        # Print summary
-        processor.print_summary()
-        
-        # Health check
-        print("\n🏥 Health Check:")
-        health = await sdk.health_check()
-        for adapter_name, status in health['adapters'].items():
-            print(f"  {adapter_name}: {'✅' if status['healthy'] else '❌'} "
-                  f"({status['event_count']} events)")
-        
-    except KeyboardInterrupt:
-        print("\n\n⚠️ Demo interrupted by user")
-    except Exception as e:
-        logger.error(f"Demo error: {e}")
-    finally:
-        # Cleanup
-        print("\n🛑 Stopping SDK...")
-        await sdk.stop()
-        print("✅ SDK stopped cleanly")
-
-
-async def demo_custom_adapter():
-    """Demonstrate creating a custom adapter"""
-    print("\n" + "="*50)
-    print("CUSTOM ADAPTER DEMO")
-    print("="*50)
-    
-    from src.sdk import DataSourceAdapter, DataSourceMetadata, StandardizedEvent, EventType
-    
-    class CustomNewsAdapter(DataSourceAdapter):
-        """Example custom adapter for news feeds"""
-        
-        def get_metadata(self) -> DataSourceMetadata:
-            return DataSourceMetadata(
-                name="CustomNews",
-                version="1.0.0",
-                author="Demo",
-                description="Custom news feed adapter",
-                source_type="news",
-                latency_ms=1000,
-                reliability=0.95,
-                requires_auth=False
-            )
-        
-        async def connect(self) -> bool:
-            logger.info("Custom adapter connected!")
-            return True
-        
-        async def disconnect(self) -> None:
-            logger.info("Custom adapter disconnected")
-        
-        async def validate_connection(self) -> bool:
-            return True
-        
-        async def stream(self):
-            """Generate fake news events"""
-            for i in range(5):
-                yield StandardizedEvent(
-                    source="CustomNews",
-                    event_type=EventType.NEWS_ALERT,
-                    timestamp=datetime.now(),
-                    data={
-                        "headline": f"Breaking: Team makes major announcement #{i+1}",
-                        "impact": "medium"
-                    },
-                    confidence=0.75,
-                    impact="medium"
-                )
-                await asyncio.sleep(2)
-        
-        def transform(self, raw_data):
-            return None
-    
-    # Use the custom adapter
-    adapter = CustomNewsAdapter({})
-    await adapter.start()
-    
-    print("\n📰 Streaming from custom adapter...")
-    async for event in adapter.stream():
-        print(f"  Received: {event.data['headline']}")
-    
-    await adapter.stop()
-    print("✅ Custom adapter demo complete")
-
-
-async def demo_testing():
-    """Demonstrate adapter testing"""
-    print("\n" + "="*50)
-    print("ADAPTER TESTING DEMO")
-    print("="*50)
-    
-    sdk = SDKManager(config_path="config/data_sources.yaml")
-    await sdk.initialize()
-    
-    # Test DraftKings adapter if available
-    if "draftkings" in sdk.adapters:
-        print("\n🧪 Testing DraftKings adapter...")
-        results = await sdk.test_adapter("draftkings", duration=10)
-        
-        print(f"\nTest Results:")
-        print(f"  Events received: {results['events_received']}")
-        print(f"  Events/second: {results['events_per_second']:.2f}")
-        print(f"  Errors: {results['errors']}")
-        
-        if results.get('avg_latency_ms'):
-            print(f"  Avg latency: {results['avg_latency_ms']:.0f}ms")
-        
-        if results.get('event_types'):
-            print(f"  Event types: {list(results['event_types'].keys())}")
-    
-    await sdk.stop()
-    print("✅ Testing complete")
-
-
-async def main():
-    """Run all demos"""
-    
-    # Basic usage
-    await demo_basic_usage()
-    
-    # Custom adapter
-    print("\n" + "="*50)
-    input("Press Enter to continue to custom adapter demo...")
-    await demo_custom_adapter()
-    
-    # Testing
-    print("\n" + "="*50)
-    input("Press Enter to continue to testing demo...")
-    await demo_testing()
-    
-    print("\n" + "="*50)
-    print("🎉 SDK DEMO COMPLETE!")
-    print("="*50)
-    print("\nNext steps:")
-    print("1. Add your API credentials to config/data_sources.yaml")
-    print("2. Enable the adapters you want to use")
-    print("3. Create custom adapters for your data sources")
-    print("4. Integrate with the trading platform")
-
-
-if __name__ == "__main__":
-    print("""
-    ╔══════════════════════════════════════════════════════╗
-    ║     NEURAL TRADING PLATFORM - DATA SOURCE SDK       ║
-    ║                                                      ║
-    ║  This demo shows how to:                           ║
-    ║  • Use the SDK to stream from multiple sources     ║
-    ║  • Create custom data adapters                     ║
-    ║  • Process standardized events                     ║
-    ║  • Test adapter performance                        ║
-    ╚══════════════════════════════════════════════════════╝
-    """)
-    
-    asyncio.run(main())
\ No newline at end of file
diff --git a/scripts/quick_weather_demo.py b/scripts/quick_weather_demo.py
deleted file mode 100644
index 3d54bafc..00000000
--- a/scripts/quick_weather_demo.py
+++ /dev/null
@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick demo of weather monitoring for game venues
-"""
-
-import asyncio
-import os
-import sys
-from datetime import datetime
-
-# Add src to path
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from src.sdk.adapters.weather import WeatherAdapter, WeatherImpactAnalyzer
-
-
-async def main():
-    """Quick weather demo"""
-    
-    print("="*60)
-    print("🌤️  WEATHER MONITORING DEMO - GAME VENUES")
-    print("="*60)
-    
-    # NFL stadiums to monitor
-    stadiums = [
-        {"name": "Arrowhead Stadium", "team": "KC Chiefs", "lat": 39.0489, "lon": -94.4839, "outdoor": True},
-        {"name": "Highmark Stadium", "team": "Buffalo Bills", "lat": 42.7738, "lon": -78.7870, "outdoor": True},
-        {"name": "Lambeau Field", "team": "Green Bay", "lat": 44.5013, "lon": -88.0622, "outdoor": True},
-        {"name": "Mile High", "team": "Denver", "lat": 39.7439, "lon": -105.0201, "outdoor": True}
-    ]
-    
-    config = {
-        'api_key': '78596505b0f5fea89e98ebcbf3bd6e21',
-        'stadiums': stadiums
-    }
-    
-    adapter = WeatherAdapter(config)
-    analyzer = WeatherImpactAnalyzer()
-    
-    try:
-        # Connect
-        connected = await adapter.connect()
-        if not connected:
-            print("❌ Failed to connect")
-            return
-            
-        print("✅ Connected to OpenWeatherMap\n")
-        
-        # Check each stadium
-        for stadium in stadiums:
-            print(f"\n📍 {stadium['name']} ({stadium['team']})")
-            print("-" * 40)
-            
-            # Get weather
-            conditions = await adapter._fetch_weather(stadium)
-            
-            if conditions:
-                # Display conditions
-                print(f"🌡️  Temperature: {conditions['temperature']:.0f}°F (feels like {conditions['feels_like']:.0f}°F)")
-                print(f"💨 Wind: {conditions['wind_speed']:.0f} mph")
-                print(f"💧 Humidity: {conditions['humidity']}%")
-                print(f"🌧️  Precipitation: {conditions['precipitation']:.2f} in/hr")
-                print(f"👁️  Visibility: {conditions['visibility']:.1f} miles")
-                print(f"☁️  Conditions: {conditions['weather']} - {conditions['description']}")
-                
-                # Analyze impact for NFL
-                impact = analyzer.calculate_total_impact(conditions, "NFL")
-                
-                print(f"\n⚡ Game Impact Analysis:")
-                print(f"   Overall: {impact['overall_impact'].upper()}")
-                print(f"   Score: {impact['impact_score']:.1f}/10")
-                print(f"   💰 Betting: {impact['betting_recommendation']}")
-                
-                # Check for significant conditions
-                if conditions['wind_speed'] > 15:
-                    print(f"   ⚠️  HIGH WIND: Affects passing game & field goals")
-                if conditions['precipitation'] > 0.1:
-                    print(f"   ⚠️  PRECIPITATION: Affects ball handling & footing")
-                if conditions['visibility'] < 5:
-                    print(f"   ⚠️  LOW VISIBILITY: Affects deep passes")
-                    
-            await asyncio.sleep(0.5)  # Small delay between API calls
-            
-        # Disconnect
-        await adapter.disconnect()
-        print("\n" + "="*60)
-        print("✅ Demo complete! Weather monitoring is working.")
-        print("\nThis data updates every 5 minutes during games to detect:")
-        print("• Wind changes that affect passing/kicking")
-        print("• Precipitation that impacts scoring")
-        print("• Temperature swings affecting player performance")
-        print("• Visibility issues from fog/snow")
-        
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        await adapter.disconnect()
-
-
-if __name__ == "__main__":
-    print("""
-    This demo shows real-time weather monitoring at NFL stadiums.
-    The system detects conditions that impact game outcomes and
-    generates trading signals when weather creates betting edges.
-    """)
-    
-    asyncio.run(main())
\ No newline at end of file
diff --git a/scripts/test_weather_adapter.py b/scripts/test_weather_adapter.py
deleted file mode 100644
index 9e7e17a5..00000000
--- a/scripts/test_weather_adapter.py
+++ /dev/null
@@ -1,405 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test Weather Adapter with OpenWeatherMap API
-Tests the weather adapter implementation with real API calls
-"""
-
-import asyncio
-import logging
-import os
-import sys
-from datetime import datetime
-from typing import Dict, Any
-
-# Add src to path
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from src.sdk.adapters.weather import WeatherAdapter, WeatherImpactAnalyzer
-from src.sdk.core.base_adapter import EventType
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-
-def print_weather_event(event):
-    """Pretty print a weather event"""
-    print("\n" + "="*60)
-    print(f"🌤️  WEATHER EVENT DETECTED")
-    print("="*60)
-    
-    data = event.data
-    metadata = event.metadata if hasattr(event, 'metadata') else {}
-    
-    print(f"📍 Stadium: {data.get('stadium', 'Unknown')}")
-    print(f"🏈 Team: {data.get('team', 'Unknown')}")
-    print(f"⚠️  Condition: {data.get('condition', 'Unknown')}")
-    print(f"📊 Impact Level: {event.impact}")
-    print(f"🎯 Confidence: {event.confidence:.1%}")
-    
-    # Condition-specific details
-    if data.get('condition') == 'high_wind':
-        print(f"\n💨 Wind Details:")
-        print(f"   Speed: {data.get('wind_speed', 0):.1f} mph")
-        print(f"   Gusts: {data.get('wind_gust', 0):.1f} mph")
-        print(f"   Direction: {data.get('wind_direction', 0)}°")
-        
-        impact = data.get('impact', {})
-        print(f"\n📉 Game Impact:")
-        print(f"   Passing: -{impact.get('passing_yards_reduction', 'N/A')}")
-        print(f"   Field Goals: -{impact.get('field_goal_accuracy_reduction', 'N/A')}")
-        print(f"   Punts: {impact.get('punt_distance_variance', 'N/A')}")
-        print(f"   Strategy: {impact.get('recommended_strategy', 'N/A')}")
-        
-    elif data.get('condition') == 'precipitation':
-        print(f"\n🌧️ Precipitation Details:")
-        print(f"   Rate: {data.get('rate', 0):.2f} inches/hour")
-        print(f"   Type: {data.get('type', 'Unknown')}")
-        print(f"   Description: {data.get('description', 'N/A')}")
-        
-    elif data.get('condition') == 'temperature_change':
-        print(f"\n🌡️ Temperature Change:")
-        print(f"   Current: {data.get('current_temp', 0):.1f}°F")
-        print(f"   Previous: {data.get('previous_temp', 0):.1f}°F")
-        print(f"   Change: {data.get('change', 0):.1f}°F")
-        
-    elif data.get('condition') == 'low_visibility':
-        print(f"\n🌫️ Visibility:")
-        print(f"   Distance: {data.get('visibility', 0):.1f} miles")
-        print(f"   Weather: {data.get('weather', 'Unknown')}")
-    
-    if metadata.get('affects'):
-        print(f"\n🎮 Affects: {', '.join(metadata['affects'])}")
-    if metadata.get('advantage'):
-        print(f"✅ Advantage: {metadata['advantage']}")
-    
-    print("="*60)
-
-
-async def test_basic_connection():
-    """Test basic API connection"""
-    print("\n" + "="*60)
-    print("TEST 1: Basic API Connection")
-    print("="*60)
-    
-    # Get API key from environment
-    api_key = os.getenv('OPENWEATHER_API_KEY')
-    if not api_key:
-        print("❌ ERROR: OPENWEATHER_API_KEY environment variable not set")
-        print("Please set: export OPENWEATHER_API_KEY=your_api_key_here")
-        return False
-    
-    config = {
-        'api_key': api_key,
-        'update_interval': 5  # Quick updates for testing
-    }
-    
-    adapter = WeatherAdapter(config)
-    
-    try:
-        # Test connection
-        connected = await adapter.connect()
-        if connected:
-            print("✅ Successfully connected to OpenWeatherMap API")
-            
-            # Validate connection
-            valid = await adapter.validate_connection()
-            print(f"✅ Connection validation: {'Passed' if valid else 'Failed'}")
-            
-            # Check metadata
-            metadata = adapter.get_metadata()
-            print(f"\n📋 Adapter Metadata:")
-            print(f"   Name: {metadata.name}")
-            print(f"   Version: {metadata.version}")
-            print(f"   Type: {metadata.source_type}")
-            print(f"   Latency: {metadata.latency_ms}ms")
-            print(f"   Reliability: {metadata.reliability:.1%}")
-            
-            await adapter.disconnect()
-            return True
-        else:
-            print("❌ Failed to connect to OpenWeatherMap API")
-            return False
-            
-    except Exception as e:
-        print(f"❌ Error during connection test: {e}")
-        return False
-
-
-async def test_single_stadium():
-    """Test fetching weather for a single stadium"""
-    print("\n" + "="*60)
-    print("TEST 2: Single Stadium Weather Check")
-    print("="*60)
-    
-    api_key = os.getenv('OPENWEATHER_API_KEY')
-    if not api_key:
-        return False
-    
-    # Test with Arrowhead Stadium (Kansas City)
-    config = {
-        'api_key': api_key,
-        'stadiums': [
-            {"name": "Arrowhead Stadium", "team": "KC", "lat": 39.0489, "lon": -94.4839, "outdoor": True}
-        ]
-    }
-    
-    adapter = WeatherAdapter(config)
-    
-    try:
-        await adapter.connect()
-        
-        # Fetch weather directly
-        stadium = config['stadiums'][0]
-        conditions = await adapter._fetch_weather(stadium)
-        
-        if conditions:
-            print(f"✅ Weather data received for {stadium['name']}")
-            print(f"\n🌡️ Current Conditions:")
-            print(f"   Temperature: {conditions['temperature']:.1f}°F")
-            print(f"   Feels Like: {conditions['feels_like']:.1f}°F")
-            print(f"   Humidity: {conditions['humidity']}%")
-            print(f"   Wind Speed: {conditions['wind_speed']:.1f} mph")
-            print(f"   Wind Direction: {conditions['wind_direction']}°")
-            print(f"   Precipitation: {conditions['precipitation']:.2f} in/hr")
-            print(f"   Visibility: {conditions['visibility']:.1f} miles")
-            print(f"   Weather: {conditions['weather']}")
-            print(f"   Description: {conditions['description']}")
-            
-            # Test impact analyzer
-            analyzer = WeatherImpactAnalyzer()
-            impact = analyzer.calculate_total_impact(conditions, "NFL")
-            
-            print(f"\n🎯 Impact Analysis:")
-            print(f"   Overall Impact: {impact['overall_impact']}")
-            print(f"   Impact Score: {impact['impact_score']:.1f}")
-            print(f"   Factors: {', '.join(impact['factors']) if impact['factors'] else 'None'}")
-            print(f"   Recommendation: {impact['betting_recommendation']}")
-            
-            await adapter.disconnect()
-            return True
-        else:
-            print("❌ Failed to fetch weather data")
-            await adapter.disconnect()
-            return False
-            
-    except Exception as e:
-        print(f"❌ Error during single stadium test: {e}")
-        return False
-
-
-async def test_event_generation():
-    """Test event generation with different weather conditions"""
-    print("\n" + "="*60)
-    print("TEST 3: Event Generation (30 seconds)")
-    print("="*60)
-    
-    api_key = os.getenv('OPENWEATHER_API_KEY')
-    if not api_key:
-        return False
-    
-    # Multiple stadiums for better chance of events
-    config = {
-        'api_key': api_key,
-        'update_interval': 10,  # Check every 10 seconds
-        'stadiums': [
-            {"name": "Arrowhead Stadium", "team": "KC", "lat": 39.0489, "lon": -94.4839, "outdoor": True},
-            {"name": "Highmark Stadium", "team": "BUF", "lat": 42.7738, "lon": -78.7870, "outdoor": True},
-            {"name": "Lambeau Field", "team": "GB", "lat": 44.5013, "lon": -88.0622, "outdoor": True},
-            {"name": "Mile High", "team": "DEN", "lat": 39.7439, "lon": -105.0201, "outdoor": True}
-        ],
-        'thresholds': {
-            'wind_speed': 10,  # Lower threshold for testing
-            'precipitation': 0.01,  # Lower threshold for testing
-            'temperature_change': 5,  # Lower threshold for testing
-            'visibility': 5  # Lower threshold for testing
-        }
-    }
-    
-    adapter = WeatherAdapter(config)
-    
-    try:
-        await adapter.connect()
-        await adapter.start()  # Start the adapter
-        
-        print("🔍 Monitoring weather conditions...")
-        print("   (Lower thresholds set for demonstration)")
-        print("   Checking 4 stadiums every 10 seconds...")
-        print("-" * 60)
-        
-        event_count = 0
-        start_time = asyncio.get_event_loop().time()
-        duration = 30  # seconds
-        
-        async for event in adapter.stream():
-            if event.event_type == EventType.WEATHER_UPDATE:
-                event_count += 1
-                print_weather_event(event)
-            
-            # Check if duration exceeded
-            if asyncio.get_event_loop().time() - start_time > duration:
-                break
-        
-        print(f"\n📊 Summary:")
-        print(f"   Events Generated: {event_count}")
-        print(f"   Duration: {duration} seconds")
-        
-        stats = adapter.statistics
-        print(f"   Total API Calls: {stats.get('event_count', 0) + stats.get('error_count', 0)}")
-        print(f"   Errors: {stats.get('error_count', 0)}")
-        
-        await adapter.stop()
-        return True
-        
-    except Exception as e:
-        print(f"❌ Error during event generation test: {e}")
-        return False
-
-
-async def test_extreme_weather():
-    """Simulate extreme weather conditions"""
-    print("\n" + "="*60)
-    print("TEST 4: Extreme Weather Simulation")
-    print("="*60)
-    
-    # Create analyzer
-    analyzer = WeatherImpactAnalyzer()
-    
-    # Test different extreme conditions
-    scenarios = [
-        {
-            "name": "Blizzard Conditions",
-            "conditions": {
-                "wind_speed": 35,
-                "precipitation": 0.5,
-                "temperature": 15,
-                "visibility": 0.25
-            },
-            "sport": "NFL"
-        },
-        {
-            "name": "Heavy Rain",
-            "conditions": {
-                "wind_speed": 10,
-                "precipitation": 0.3,
-                "temperature": 55,
-                "visibility": 2
-            },
-            "sport": "NFL"
-        },
-        {
-            "name": "Extreme Heat",
-            "conditions": {
-                "wind_speed": 5,
-                "precipitation": 0,
-                "temperature": 105,
-                "humidity": 85
-            },
-            "sport": "MLB"
-        },
-        {
-            "name": "High Winds",
-            "conditions": {
-                "wind_speed": 30,
-                "precipitation": 0,
-                "temperature": 65,
-                "visibility": 10
-            },
-            "sport": "NFL"
-        }
-    ]
-    
-    for scenario in scenarios:
-        print(f"\n🌪️ Scenario: {scenario['name']}")
-        print(f"   Sport: {scenario['sport']}")
-        print(f"   Conditions:")
-        for key, value in scenario['conditions'].items():
-            unit = "mph" if "wind" in key else "in/hr" if "precip" in key else "°F" if "temp" in key else "miles" if "vis" in key else "%"
-            print(f"     {key}: {value} {unit}")
-        
-        impact = analyzer.calculate_total_impact(scenario['conditions'], scenario['sport'])
-        
-        print(f"   📊 Impact Assessment:")
-        print(f"     Overall: {impact['overall_impact']}")
-        print(f"     Score: {impact['impact_score']:.1f}")
-        print(f"     Recommendation: {impact['betting_recommendation']}")
-    
-    return True
-
-
-async def main():
-    """Run all tests"""
-    print("\n" + "="*60)
-    print("🌤️  WEATHER ADAPTER TEST SUITE")
-    print("="*60)
-    print(f"Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    
-    # Check for API key
-    if not os.getenv('OPENWEATHER_API_KEY'):
-        print("\n⚠️  WARNING: No API key found!")
-        print("To test with real API:")
-        print("1. Sign up at https://openweathermap.org/api")
-        print("2. Get your free API key")
-        print("3. Set environment variable:")
-        print("   export OPENWEATHER_API_KEY=your_key_here")
-        print("\nRunning simulation tests only...")
-        
-        # Run only simulation tests
-        await test_extreme_weather()
-        return
-    
-    # Run all tests
-    tests = [
-        ("Basic Connection", test_basic_connection),
-        ("Single Stadium", test_single_stadium),
-        ("Event Generation", test_event_generation),
-        ("Extreme Weather", test_extreme_weather)
-    ]
-    
-    results = {}
-    for name, test_func in tests:
-        try:
-            print(f"\nRunning: {name}")
-            result = await test_func()
-            results[name] = "✅ PASSED" if result else "❌ FAILED"
-        except Exception as e:
-            results[name] = f"❌ ERROR: {e}"
-            logger.error(f"Test {name} failed with error: {e}")
-    
-    # Print summary
-    print("\n" + "="*60)
-    print("📊 TEST SUMMARY")
-    print("="*60)
-    for test_name, result in results.items():
-        print(f"{test_name}: {result}")
-    
-    passed = sum(1 for r in results.values() if "PASSED" in r)
-    total = len(results)
-    print(f"\nTotal: {passed}/{total} tests passed")
-    
-    if passed == total:
-        print("🎉 All tests passed!")
-    else:
-        print("⚠️  Some tests failed. Check the output above.")
-
-
-if __name__ == "__main__":
-    print("""
-    ╔══════════════════════════════════════════════════════╗
-    ║         WEATHER ADAPTER TEST - NEURAL TRADING        ║
-    ║                                                       ║
-    ║  This script tests the OpenWeatherMap integration    ║
-    ║  for monitoring weather conditions at game venues.   ║
-    ║                                                       ║
-    ║  Tests include:                                      ║
-    ║  • API connection and authentication                 ║
-    ║  • Weather data fetching                            ║
-    ║  • Event generation based on thresholds             ║
-    ║  • Impact analysis for trading decisions            ║
-    ╚══════════════════════════════════════════════════════╝
-    """)
-    
-    asyncio.run(main())
\ No newline at end of file
diff --git a/src/agents/__init__.py b/src/agents/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/agents/always_on/__init__.py b/src/agents/always_on/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/agents/always_on/data_coordinator.py b/src/agents/always_on/data_coordinator.py
deleted file mode 100644
index 1c004b99..00000000
--- a/src/agents/always_on/data_coordinator.py
+++ /dev/null
@@ -1,469 +0,0 @@
-"""
-Data Coordinator Agent - Simplified without Agno
-Orchestrates data flow from StreamManager without any database or Agno dependencies
-Now with Redis consumer for real-time data processing
-"""
-
-import os
-import asyncio
-import logging
-from typing import Dict, Any, List, Optional
-from datetime import datetime
-
-from src.data_pipeline.orchestration.unified_stream_manager import StreamManager, EventType, UnifiedEvent
-from src.trading.llm_client import get_llm_client
-from src.agents.base_consumer import BaseAgentRedisConsumer
-
-logger = logging.getLogger(__name__)
-
-
-class DataCoordinatorAgent:
-    """
-    Data Coordinator Agent - Orchestrates data flow from StreamManager
-    
-    Responsibilities:
-    - Consumes unified events from StreamManager
-    - Routes high-priority events to appropriate agents
-    - Maintains data quality and consistency
-    - Handles market subscriptions
-    
-    NO Agno dependencies - pure Python implementation
-    """
-    
-    def __init__(self):
-        """Initialize Data Coordinator Agent"""
-        # Initialize LLM client
-        self.llm_client = get_llm_client()
-        
-        # Initialize StreamManager
-        self.stream_manager = StreamManager()
-        
-        # Tracked markets
-        self.tracked_markets: Dict[str, Dict] = {}
-        
-        # Message handler (set by Agentuity)
-        self.message_handler = None
-        
-        # State
-        self.is_running = False
-        
-        # Statistics
-        self.events_received = 0
-        self.events_routed = 0
-    
-    async def start(self, agent_context=None):
-        """
-        Start the Data Coordinator
-        
-        Args:
-            agent_context: Agentuity context for agent communication
-        """
-        if self.is_running:
-            logger.warning("Data Coordinator already running")
-            return
-        
-        self.is_running = True
-        logger.info("Starting Data Coordinator Agent...")
-        
-        # Set agent context for StreamManager if provided
-        if agent_context:
-            self.stream_manager.agent_context = agent_context
-        
-        # Initialize and start StreamManager
-        await self.stream_manager.initialize()
-        await self.stream_manager.start()
-        
-        # Register event handlers
-        self._register_event_handlers()
-        
-        # Start Redis consumer
-        redis_url = os.getenv("REDIS_URL", "redis://localhost:6379")
-        self.redis_consumer = DataCoordinatorRedisConsumer(self, agent_context)
-        self.redis_consumer.redis_url = redis_url
-        
-        await self.redis_consumer.connect()
-        await self.redis_consumer.subscribe([
-            "kalshi:markets",
-            "kalshi:trades", 
-            "kalshi:signals",
-            "espn:games"
-        ])
-        
-        # Start consuming in background
-        asyncio.create_task(self.redis_consumer.start_consuming())
-        
-        logger.info("Data Coordinator Agent started successfully with Redis consumer")
-    
-    def _register_event_handlers(self):
-        """Register handlers for different event types"""
-        # High-priority events
-        self.stream_manager.register_handler(
-            EventType.DIVERGENCE_DETECTED,
-            self._handle_divergence
-        )
-        
-        self.stream_manager.register_handler(
-            EventType.INJURY_ALERT,
-            self._handle_injury
-        )
-        
-        self.stream_manager.register_handler(
-            EventType.SENTIMENT_SHIFT,
-            self._handle_sentiment_shift
-        )
-        
-        # Market updates
-        self.stream_manager.register_handler(
-            EventType.PRICE_UPDATE,
-            self._handle_price_update
-        )
-        
-        # Risk events
-        self.stream_manager.register_handler(
-            EventType.RISK_ALERT,
-            self._handle_risk_alert
-        )
-    
-    async def track_market(
-        self,
-        market_ticker: str,
-        game_id: Optional[str] = None,
-        home_team: Optional[str] = None,
-        away_team: Optional[str] = None,
-        sport: str = "nfl"
-    ):
-        """
-        Track a market via StreamManager
-        
-        Args:
-            market_ticker: Kalshi market ticker
-            game_id: ESPN game ID
-            home_team: Home team name
-            away_team: Away team name
-            sport: Sport type
-        """
-        logger.info(f"Tracking market: {market_ticker}")
-        
-        # Store configuration
-        self.tracked_markets[market_ticker] = {
-            "game_id": game_id,
-            "home_team": home_team,
-            "away_team": away_team,
-            "sport": sport,
-            "started_at": datetime.now()
-        }
-        
-        # Delegate to StreamManager
-        await self.stream_manager.track_market(
-            market_ticker=market_ticker,
-            game_id=game_id,
-            home_team=home_team,
-            away_team=away_team,
-            sport=sport
-        )
-        
-        # Use LLM to analyze the setup
-        analysis = await self.analyze_market_setup(
-            market_ticker, home_team, away_team, sport
-        )
-        logger.info(f"Market analysis: {analysis}")
-    
-    async def analyze_market_setup(
-        self,
-        market_ticker: str,
-        home_team: str,
-        away_team: str,
-        sport: str
-    ) -> str:
-        """Analyze market setup using LLM"""
-        prompt = f"""
-        Analyze this market tracking configuration:
-        - Market: {market_ticker}
-        - Game: {home_team} vs {away_team}
-        - Sport: {sport}
-        
-        Provide brief assessment of:
-        1. Key events to watch for
-        2. Potential volatility factors
-        3. Data quality requirements
-        
-        Keep response under 100 words.
-        """
-        
-        try:
-            return await self.llm_client.complete(prompt, temperature=0.1)
-        except Exception as e:
-            logger.error(f"LLM analysis failed: {e}")
-            return "Market tracking initiated"
-    
-    async def _handle_divergence(self, event: UnifiedEvent):
-        """Handle market divergence events"""
-        self.events_received += 1
-        
-        if event.impact_score > 0.7:
-            # High-impact divergence - route to Strategy Analyst
-            logger.info(f"High-impact divergence detected: {event.market_ticker}")
-            
-            if self.message_handler:
-                await self.message_handler("divergence_opportunity", {
-                    "market_ticker": event.market_ticker,
-                    "divergence_data": event.data,
-                    "impact_score": event.impact_score,
-                    "timestamp": event.timestamp.isoformat()
-                })
-                self.events_routed += 1
-    
-    async def _handle_injury(self, event: UnifiedEvent):
-        """Handle injury alerts"""
-        self.events_received += 1
-        
-        # Injuries always high priority
-        logger.warning(f"INJURY ALERT: {event.data.get('description')}")
-        
-        if self.message_handler:
-            await self.message_handler("injury_alert", {
-                "game_id": event.game_id,
-                "injury_data": event.data,
-                "impact_score": 0.9,  # Injuries are high impact
-                "timestamp": event.timestamp.isoformat()
-            })
-            self.events_routed += 1
-    
-    async def _handle_sentiment_shift(self, event: UnifiedEvent):
-        """Handle sentiment shift events"""
-        self.events_received += 1
-        
-        logger.info(f"Sentiment shift detected: {event.data}")
-        
-        if self.message_handler:
-            await self.message_handler("sentiment_shift", {
-                "shift_data": event.data,
-                "impact_score": event.impact_score,
-                "timestamp": event.timestamp.isoformat()
-            })
-            self.events_routed += 1
-    
-    async def _handle_price_update(self, event: UnifiedEvent):
-        """Handle price updates"""
-        self.events_received += 1
-        
-        # Only route significant price moves
-        if event.market_ticker in self.tracked_markets:
-            context = self.stream_manager.get_market_context(event.market_ticker)
-            
-            if context and context.opportunity_score > 0.5:
-                if self.message_handler:
-                    await self.message_handler("price_update", {
-                        "market_ticker": event.market_ticker,
-                        "price_data": event.data,
-                        "opportunity_score": context.opportunity_score,
-                        "timestamp": event.timestamp.isoformat()
-                    })
-                    self.events_routed += 1
-    
-    async def _handle_risk_alert(self, event: UnifiedEvent):
-        """Handle risk alerts"""
-        self.events_received += 1
-        
-        logger.error(f"RISK ALERT: {event.data}")
-        
-        if self.message_handler:
-            await self.message_handler("risk_alert", {
-                "alert_data": event.data,
-                "impact_score": event.impact_score,
-                "timestamp": event.timestamp.isoformat()
-            })
-            self.events_routed += 1
-    
-    async def get_market_summary(self, market_ticker: str) -> Dict[str, Any]:
-        """
-        Get comprehensive market summary
-        
-        Args:
-            market_ticker: Market to summarize
-            
-        Returns:
-            Market summary with all data sources
-        """
-        context = self.stream_manager.get_market_context(market_ticker)
-        
-        if not context:
-            return {"error": "Market not found"}
-        
-        return {
-            "market_ticker": market_ticker,
-            "price": {
-                "yes": context.yes_price,
-                "no": context.no_price,
-                "bid": context.yes_bid,
-                "ask": context.yes_ask,
-                "volume_24h": context.volume_24h
-            },
-            "game": {
-                "home_team": context.home_team,
-                "away_team": context.away_team,
-                "home_score": context.home_score,
-                "away_score": context.away_score,
-                "quarter": context.quarter,
-                "time": context.time_remaining,
-                "win_probability": context.win_probability
-            },
-            "sentiment": {
-                "score": context.sentiment_score,
-                "velocity": context.sentiment_velocity,
-                "volume": context.tweet_volume,
-                "high_impact_tweets": len(context.high_impact_tweets)
-            },
-            "analysis": {
-                "divergence": context.price_sentiment_divergence,
-                "opportunity_score": context.opportunity_score,
-                "risk_level": context.risk_level
-            },
-            "last_update": context.last_update.isoformat()
-        }
-    
-    async def get_status(self) -> Dict[str, Any]:
-        """Get agent status"""
-        stream_stats = self.stream_manager.get_statistics()
-        
-        return {
-            "is_running": self.is_running,
-            "tracked_markets": list(self.tracked_markets.keys()),
-            "events_received": self.events_received,
-            "events_routed": self.events_routed,
-            "routing_rate": f"{(self.events_routed / max(self.events_received, 1)) * 100:.1f}%",
-            "stream_manager": stream_stats
-        }
-    
-    async def stop(self):
-        """Stop the Data Coordinator"""
-        self.is_running = False
-        
-        # Stop StreamManager
-        await self.stream_manager.stop()
-        
-        # Stop Redis consumer if running
-        if hasattr(self, 'redis_consumer') and self.redis_consumer:
-            await self.redis_consumer.disconnect()
-        
-        logger.info(f"Data Coordinator stopped. Events: {self.events_received} received, {self.events_routed} routed")
-
-
-class DataCoordinatorRedisConsumer(BaseAgentRedisConsumer):
-    """
-    Redis consumer for DataCoordinator
-    Processes real-time market data and routes to appropriate agents
-    """
-    
-    def __init__(self, coordinator: DataCoordinatorAgent, agent_context=None):
-        super().__init__("DataCoordinator", agent_context=agent_context)
-        self.coordinator = coordinator
-        
-    async def process_message(self, channel: str, data: Dict[str, Any]):
-        """Process incoming Redis messages"""
-        
-        if channel == "kalshi:markets":
-            await self._handle_market_update(data)
-        elif channel == "kalshi:trades":
-            await self._handle_trade(data)
-        elif channel == "kalshi:signals":
-            await self._handle_signal(data)
-        elif channel == "espn:games":
-            await self._handle_espn_update(data)
-    
-    async def _handle_market_update(self, data: Dict[str, Any]):
-        """Handle market price updates"""
-        market_ticker = data.get('data', {}).get('market_ticker')
-        
-        if market_ticker in self.coordinator.tracked_markets:
-            # Update tracked market data
-            self.coordinator.tracked_markets[market_ticker]['last_update'] = datetime.now()
-            self.coordinator.tracked_markets[market_ticker]['latest_data'] = data.get('data', {})
-            
-            # Check for significant price movements
-            yes_price = data.get('data', {}).get('yes_price', 0)
-            if yes_price > 0.8 or yes_price < 0.2:
-                # Alert for extreme prices
-                await self.publish_signal({
-                    "action": "PRICE_EXTREME",
-                    "market_ticker": market_ticker,
-                    "yes_price": yes_price,
-                    "timestamp": datetime.utcnow().isoformat()
-                })
-    
-    async def _handle_trade(self, data: Dict[str, Any]):
-        """Handle trade executions"""
-        self.coordinator.events_received += 1
-        logger.info(f"Trade executed: {data}")
-        
-        # Could route to RiskManager for position tracking
-        
-    async def _handle_signal(self, data: Dict[str, Any]):
-        """Handle high-impact signals"""
-        self.coordinator.events_received += 1
-        
-        # Route high-confidence signals
-        confidence = data.get('data', {}).get('confidence', 0)
-        if confidence > 0.8:
-            logger.info(f"High confidence signal: {data}")
-            self.coordinator.events_routed += 1
-            
-    async def _handle_espn_update(self, data: Dict[str, Any]):
-        """Handle ESPN game updates"""
-        game_data = data.get('data', {})
-        
-        # Find associated market
-        for market_ticker, market_info in self.coordinator.tracked_markets.items():
-            if market_info.get('game_id') == game_data.get('game_id'):
-                # Correlate game data with market
-                logger.info(f"Game update for {market_ticker}: {game_data}")
-                break
-
-
-# Create singleton instance only when needed
-data_coordinator_agent = None
-
-def get_data_coordinator_agent():
-    """Get or create the data coordinator agent instance."""
-    global data_coordinator_agent
-    if data_coordinator_agent is None:
-        data_coordinator_agent = DataCoordinatorAgent()
-    return data_coordinator_agent
-
-
-# Example usage
-async def main():
-    """Example of running the Data Coordinator"""
-    
-    # Initialize agent
-    agent = DataCoordinatorAgent()
-    
-    # Start agent
-    await agent.start()
-    
-    # Track a market
-    await agent.track_market(
-        market_ticker="SUPERBOWL-2025",
-        game_id="401547435",
-        home_team="Chiefs",
-        away_team="Bills",
-        sport="nfl"
-    )
-    
-    # Run for a while
-    await asyncio.sleep(300)  # 5 minutes
-    
-    # Get status
-    status = await agent.get_status()
-    print(f"Agent status: {status}")
-    
-    # Get market summary
-    summary = await agent.get_market_summary("SUPERBOWL-2025")
-    print(f"Market summary: {summary}")
-    
-    # Stop agent
-    await agent.stop()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
\ No newline at end of file
diff --git a/src/agents/always_on/portfolio_monitor.py b/src/agents/always_on/portfolio_monitor.py
deleted file mode 100644
index 69a0b607..00000000
--- a/src/agents/always_on/portfolio_monitor.py
+++ /dev/null
@@ -1,593 +0,0 @@
-"""
-Portfolio Monitor Agent - Always-On Agent
-Continuously monitors positions and enforces risk limits
-"""
-
-import asyncio
-import json
-import logging
-from typing import Dict, Any, List, Optional
-from datetime import datetime, timedelta
-from dataclasses import dataclass, field
-import redis.asyncio as redis
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class Position:
-    """Represents a trading position"""
-    market_ticker: str
-    side: str  # 'yes' or 'no'
-    quantity: int
-    entry_price: float
-    current_price: float
-    timestamp: datetime
-    stop_loss: Optional[float] = None
-    take_profit: Optional[float] = None
-    
-    @property
-    def unrealized_pnl(self) -> float:
-        """Calculate unrealized P&L"""
-        price_diff = self.current_price - self.entry_price
-        return self.quantity * price_diff
-    
-    @property
-    def unrealized_pnl_pct(self) -> float:
-        """Calculate unrealized P&L percentage"""
-        if self.entry_price == 0:
-            return 0
-        return (self.current_price - self.entry_price) / self.entry_price
-    
-    @property
-    def cost_basis(self) -> float:
-        """Calculate position cost basis"""
-        return self.quantity * self.entry_price
-    
-    def should_stop_loss(self) -> bool:
-        """Check if stop-loss should trigger"""
-        if self.stop_loss is None:
-            return self.unrealized_pnl_pct <= -0.10  # Default 10% stop-loss
-        return self.current_price <= self.stop_loss
-    
-    def should_take_profit(self) -> bool:
-        """Check if take-profit should trigger"""
-        if self.take_profit is None:
-            return self.unrealized_pnl_pct >= 0.30  # Default 30% take-profit
-        return self.current_price >= self.take_profit
-
-
-@dataclass
-class Portfolio:
-    """Portfolio state and metrics"""
-    positions: List[Position] = field(default_factory=list)
-    cash_balance: float = 10000.0  # Starting balance
-    starting_balance: float = 10000.0
-    daily_pnl: float = 0.0
-    daily_trades: int = 0
-    max_drawdown: float = 0.0
-    
-    @property
-    def total_value(self) -> float:
-        """Calculate total portfolio value"""
-        position_value = sum(p.current_price * p.quantity for p in self.positions)
-        return self.cash_balance + position_value
-    
-    @property
-    def unrealized_pnl(self) -> float:
-        """Calculate total unrealized P&L"""
-        return sum(p.unrealized_pnl for p in self.positions)
-    
-    @property
-    def exposure(self) -> float:
-        """Calculate total market exposure"""
-        return sum(p.cost_basis for p in self.positions)
-    
-    @property
-    def exposure_pct(self) -> float:
-        """Calculate exposure as percentage of portfolio"""
-        if self.total_value == 0:
-            return 0
-        return self.exposure / self.total_value
-    
-    @property
-    def daily_return(self) -> float:
-        """Calculate daily return percentage"""
-        if self.starting_balance == 0:
-            return 0
-        return self.daily_pnl / self.starting_balance
-    
-    def update_drawdown(self):
-        """Update maximum drawdown"""
-        current_drawdown = (self.starting_balance - self.total_value) / self.starting_balance
-        self.max_drawdown = max(self.max_drawdown, current_drawdown)
-
-
-class PortfolioMonitorAgent:
-    """
-    Portfolio Monitor Agent - Always-On
-    
-    Responsibilities:
-    - Track all open positions
-    - Monitor P&L in real-time  
-    - Enforce position limits (max 5% per position)
-    - Trigger stop-losses (10% loss)
-    - Trigger take-profits (30% gain)
-    - Alert on margin requirements
-    - Calculate portfolio Greeks
-    - Halt trading on daily loss limit (20%)
-    """
-    
-    # Risk parameters
-    MAX_POSITION_PCT = 0.05  # Max 5% per position
-    MAX_DAILY_LOSS_PCT = 0.20  # Max 20% daily loss
-    DEFAULT_STOP_LOSS_PCT = 0.10  # 10% stop-loss
-    DEFAULT_TAKE_PROFIT_PCT = 0.30  # 30% take-profit
-    MAX_CORRELATION = 0.7  # Max correlation between positions
-    MARGIN_REQUIREMENT = 2.0  # 2x Kelly fraction
-    
-    def __init__(self, redis_url: str = "redis://localhost:6379"):
-        self.redis_url = redis_url
-        self.redis_client = None
-        self.pubsub = None
-        self.is_running = False
-        self.trading_halted = False
-        
-        # Portfolio state
-        self.portfolio = Portfolio()
-        self.positions_by_market: Dict[str, Position] = {}
-        
-        # Price cache for position updates
-        self.price_cache: Dict[str, float] = {}
-        
-        # Statistics
-        self.stops_triggered = 0
-        self.profits_taken = 0
-        self.risk_alerts = 0
-    
-    async def connect(self):
-        """Connect to Redis"""
-        self.redis_client = redis.from_url(self.redis_url)
-        self.pubsub = self.redis_client.pubsub()
-        
-        # Subscribe to relevant channels
-        await self.pubsub.subscribe(
-            "kalshi:markets",  # Price updates
-            "trades:executed",  # New positions
-            "trades:closed",    # Closed positions
-            "risk:override"     # Risk overrides
-        )
-        
-        logger.info("Portfolio Monitor connected to Redis")
-    
-    async def start(self):
-        """Start portfolio monitoring"""
-        if self.is_running:
-            logger.warning("Portfolio Monitor already running")
-            return
-        
-        self.is_running = True
-        self.trading_halted = False
-        
-        logger.info("Portfolio Monitor started")
-        
-        # Start monitoring tasks
-        asyncio.create_task(self._monitor_positions())
-        asyncio.create_task(self._process_messages())
-        asyncio.create_task(self._periodic_risk_check())
-    
-    async def _process_messages(self):
-        """Process Redis messages"""
-        async for message in self.pubsub.listen():
-            if not self.is_running:
-                break
-            
-            if message['type'] == 'message':
-                try:
-                    channel = message['channel'].decode('utf-8')
-                    data = json.loads(message['data'])
-                    
-                    if channel == "kalshi:markets":
-                        await self._handle_price_update(data)
-                    elif channel == "trades:executed":
-                        await self._handle_new_position(data)
-                    elif channel == "trades:closed":
-                        await self._handle_closed_position(data)
-                    elif channel == "risk:override":
-                        await self._handle_risk_override(data)
-                        
-                except Exception as e:
-                    logger.error(f"Error processing message: {e}")
-    
-    async def _monitor_positions(self):
-        """Monitor positions every 10 seconds"""
-        while self.is_running:
-            try:
-                # Update position prices
-                await self._update_position_prices()
-                
-                # Check each position
-                for market_ticker, position in self.positions_by_market.items():
-                    # Check stop-loss
-                    if position.should_stop_loss():
-                        await self._execute_stop_loss(position)
-                    
-                    # Check take-profit
-                    elif position.should_take_profit():
-                        await self._execute_take_profit(position)
-                
-                # Check portfolio-level limits
-                await self._check_portfolio_limits()
-                
-            except Exception as e:
-                logger.error(f"Error monitoring positions: {e}")
-            
-            await asyncio.sleep(10)
-    
-    async def _periodic_risk_check(self):
-        """Perform periodic risk checks every minute"""
-        while self.is_running:
-            try:
-                # Calculate portfolio metrics
-                self.portfolio.update_drawdown()
-                
-                # Check correlation between positions
-                if len(self.portfolio.positions) > 1:
-                    await self._check_correlation()
-                
-                # Check margin requirements
-                await self._check_margin_requirements()
-                
-                # Publish portfolio status
-                await self._publish_portfolio_status()
-                
-            except Exception as e:
-                logger.error(f"Error in risk check: {e}")
-            
-            await asyncio.sleep(60)
-    
-    async def _handle_price_update(self, data: Dict[str, Any]):
-        """Handle market price updates"""
-        market_data = data.get('data', {})
-        market_ticker = market_data.get('market_ticker')
-        yes_price = market_data.get('yes_price')
-        
-        if market_ticker and yes_price:
-            # Update price cache
-            self.price_cache[market_ticker] = yes_price
-            
-            # Update position if we have one
-            if market_ticker in self.positions_by_market:
-                self.positions_by_market[market_ticker].current_price = yes_price
-    
-    async def _handle_new_position(self, data: Dict[str, Any]):
-        """Handle new position opened"""
-        position_data = data.get('data', {})
-        
-        position = Position(
-            market_ticker=position_data['market_ticker'],
-            side=position_data['side'],
-            quantity=position_data['quantity'],
-            entry_price=position_data['price'],
-            current_price=position_data['price'],
-            timestamp=datetime.fromisoformat(position_data['timestamp']),
-            stop_loss=position_data.get('stop_loss'),
-            take_profit=position_data.get('take_profit')
-        )
-        
-        # Add to portfolio
-        self.portfolio.positions.append(position)
-        self.positions_by_market[position.market_ticker] = position
-        
-        # Update cash balance
-        self.portfolio.cash_balance -= position.cost_basis
-        
-        # Update daily trades
-        self.portfolio.daily_trades += 1
-        
-        logger.info(f"New position added: {position.market_ticker} {position.side} x{position.quantity}")
-    
-    async def _handle_closed_position(self, data: Dict[str, Any]):
-        """Handle position closed"""
-        close_data = data.get('data', {})
-        market_ticker = close_data['market_ticker']
-        
-        if market_ticker in self.positions_by_market:
-            position = self.positions_by_market[market_ticker]
-            
-            # Calculate realized P&L
-            realized_pnl = position.unrealized_pnl
-            
-            # Update portfolio
-            self.portfolio.cash_balance += position.current_price * position.quantity
-            self.portfolio.daily_pnl += realized_pnl
-            self.portfolio.positions.remove(position)
-            del self.positions_by_market[market_ticker]
-            
-            logger.info(f"Position closed: {market_ticker}, P&L: ${realized_pnl:.2f}")
-    
-    async def _handle_risk_override(self, data: Dict[str, Any]):
-        """Handle risk override commands"""
-        command = data.get('command')
-        
-        if command == 'halt_trading':
-            self.trading_halted = True
-            logger.warning("Trading halted by risk override")
-        elif command == 'resume_trading':
-            self.trading_halted = False
-            logger.info("Trading resumed")
-        elif command == 'close_all':
-            await self._close_all_positions()
-    
-    async def _update_position_prices(self):
-        """Update current prices for all positions"""
-        for position in self.portfolio.positions:
-            if position.market_ticker in self.price_cache:
-                position.current_price = self.price_cache[position.market_ticker]
-    
-    async def _execute_stop_loss(self, position: Position):
-        """Execute stop-loss for position"""
-        logger.warning(f"STOP-LOSS triggered for {position.market_ticker}")
-        
-        # Publish stop-loss order
-        stop_order = {
-            "action": "STOP_LOSS",
-            "market_ticker": position.market_ticker,
-            "side": "sell" if position.side == "yes" else "buy",
-            "quantity": position.quantity,
-            "reason": f"Stop-loss at {position.unrealized_pnl_pct:.1%}",
-            "timestamp": datetime.utcnow().isoformat()
-        }
-        
-        await self.redis_client.publish("trades:orders", json.dumps(stop_order))
-        
-        # Publish risk alert
-        await self._publish_risk_alert(
-            f"Stop-loss executed: {position.market_ticker}",
-            {"position": position.__dict__, "loss_pct": position.unrealized_pnl_pct}
-        )
-        
-        self.stops_triggered += 1
-    
-    async def _execute_take_profit(self, position: Position):
-        """Execute take-profit for position"""
-        logger.info(f"TAKE-PROFIT triggered for {position.market_ticker}")
-        
-        # Publish take-profit order
-        profit_order = {
-            "action": "TAKE_PROFIT",
-            "market_ticker": position.market_ticker,
-            "side": "sell" if position.side == "yes" else "buy",
-            "quantity": position.quantity,
-            "reason": f"Take-profit at {position.unrealized_pnl_pct:.1%}",
-            "timestamp": datetime.utcnow().isoformat()
-        }
-        
-        await self.redis_client.publish("trades:orders", json.dumps(profit_order))
-        
-        self.profits_taken += 1
-    
-    async def _check_portfolio_limits(self):
-        """Check portfolio-level risk limits"""
-        # Check daily loss limit
-        if self.portfolio.daily_return <= -self.MAX_DAILY_LOSS_PCT:
-            if not self.trading_halted:
-                await self._halt_trading(f"Daily loss limit reached: {self.portfolio.daily_return:.1%}")
-        
-        # Check position concentration
-        for position in self.portfolio.positions:
-            position_pct = position.cost_basis / self.portfolio.total_value
-            if position_pct > self.MAX_POSITION_PCT:
-                await self._publish_risk_alert(
-                    f"Position too large: {position.market_ticker}",
-                    {"position_pct": position_pct, "limit": self.MAX_POSITION_PCT}
-                )
-    
-    async def _check_correlation(self):
-        """Check correlation between positions"""
-        # Simplified correlation check - in production would use actual correlation matrix
-        similar_markets = {}
-        
-        for position in self.portfolio.positions:
-            # Group by similar market types (e.g., same game, same team)
-            market_type = position.market_ticker.split('-')[0]
-            if market_type not in similar_markets:
-                similar_markets[market_type] = []
-            similar_markets[market_type].append(position)
-        
-        # Alert if too many correlated positions
-        for market_type, positions in similar_markets.items():
-            if len(positions) > 2:
-                await self._publish_risk_alert(
-                    f"High correlation risk: {len(positions)} positions in {market_type}",
-                    {"market_type": market_type, "position_count": len(positions)}
-                )
-    
-    async def _check_margin_requirements(self):
-        """Check margin requirements"""
-        required_margin = self.portfolio.exposure * self.MARGIN_REQUIREMENT
-        available_margin = self.portfolio.cash_balance
-        
-        if available_margin < required_margin:
-            await self._publish_risk_alert(
-                "Insufficient margin",
-                {
-                    "required": required_margin,
-                    "available": available_margin,
-                    "shortfall": required_margin - available_margin
-                }
-            )
-    
-    async def _halt_trading(self, reason: str):
-        """Halt all trading"""
-        self.trading_halted = True
-        logger.critical(f"TRADING HALTED: {reason}")
-        
-        halt_message = {
-            "action": "HALT",
-            "reason": reason,
-            "portfolio_value": self.portfolio.total_value,
-            "daily_pnl": self.portfolio.daily_pnl,
-            "timestamp": datetime.utcnow().isoformat()
-        }
-        
-        await self.redis_client.publish("risk:halt", json.dumps(halt_message))
-        await self._publish_risk_alert(f"Trading halted: {reason}", halt_message)
-    
-    async def _close_all_positions(self):
-        """Close all open positions"""
-        logger.warning("Closing all positions")
-        
-        for position in self.portfolio.positions:
-            close_order = {
-                "action": "CLOSE_ALL",
-                "market_ticker": position.market_ticker,
-                "side": "sell" if position.side == "yes" else "buy",
-                "quantity": position.quantity,
-                "reason": "Risk management: close all",
-                "timestamp": datetime.utcnow().isoformat()
-            }
-            
-            await self.redis_client.publish("trades:orders", json.dumps(close_order))
-    
-    async def _publish_risk_alert(self, message: str, data: Dict[str, Any]):
-        """Publish risk alert"""
-        alert = {
-            "type": "RISK_ALERT",
-            "message": message,
-            "data": data,
-            "timestamp": datetime.utcnow().isoformat()
-        }
-        
-        await self.redis_client.publish("events:portfolio", json.dumps(alert))
-        self.risk_alerts += 1
-    
-    async def _publish_portfolio_status(self):
-        """Publish portfolio status update"""
-        status = {
-            "total_value": self.portfolio.total_value,
-            "cash_balance": self.portfolio.cash_balance,
-            "unrealized_pnl": self.portfolio.unrealized_pnl,
-            "daily_pnl": self.portfolio.daily_pnl,
-            "daily_return": self.portfolio.daily_return,
-            "exposure": self.portfolio.exposure,
-            "exposure_pct": self.portfolio.exposure_pct,
-            "position_count": len(self.portfolio.positions),
-            "daily_trades": self.portfolio.daily_trades,
-            "max_drawdown": self.portfolio.max_drawdown,
-            "trading_halted": self.trading_halted,
-            "timestamp": datetime.utcnow().isoformat()
-        }
-        
-        await self.redis_client.publish("portfolio:status", json.dumps(status))
-    
-    async def check_capacity(self, proposed_size: float) -> Dict[str, Any]:
-        """
-        Check if portfolio has capacity for new position
-        
-        Args:
-            proposed_size: Proposed position size in dollars
-            
-        Returns:
-            Approval status and details
-        """
-        # Check if trading is halted
-        if self.trading_halted:
-            return {
-                "approved": False,
-                "reason": "Trading is halted"
-            }
-        
-        # Check position size limit
-        position_pct = proposed_size / self.portfolio.total_value
-        if position_pct > self.MAX_POSITION_PCT:
-            return {
-                "approved": False,
-                "reason": f"Position too large: {position_pct:.1%} > {self.MAX_POSITION_PCT:.1%}"
-            }
-        
-        # Check daily loss limit
-        if self.portfolio.daily_return <= -self.MAX_DAILY_LOSS_PCT * 0.8:  # 80% of limit
-            return {
-                "approved": False,
-                "reason": f"Approaching daily loss limit: {self.portfolio.daily_return:.1%}"
-            }
-        
-        # Check available cash
-        if proposed_size > self.portfolio.cash_balance:
-            return {
-                "approved": False,
-                "reason": f"Insufficient cash: ${proposed_size:.2f} > ${self.portfolio.cash_balance:.2f}"
-            }
-        
-        return {
-            "approved": True,
-            "available_cash": self.portfolio.cash_balance,
-            "current_exposure": self.portfolio.exposure_pct,
-            "daily_return": self.portfolio.daily_return
-        }
-    
-    def get_statistics(self) -> Dict[str, Any]:
-        """Get portfolio monitor statistics"""
-        return {
-            "is_running": self.is_running,
-            "trading_halted": self.trading_halted,
-            "portfolio": {
-                "total_value": self.portfolio.total_value,
-                "positions": len(self.portfolio.positions),
-                "unrealized_pnl": self.portfolio.unrealized_pnl,
-                "daily_pnl": self.portfolio.daily_pnl,
-                "daily_return": f"{self.portfolio.daily_return:.1%}",
-                "max_drawdown": f"{self.portfolio.max_drawdown:.1%}"
-            },
-            "risk_events": {
-                "stops_triggered": self.stops_triggered,
-                "profits_taken": self.profits_taken,
-                "risk_alerts": self.risk_alerts
-            }
-        }
-    
-    async def stop(self):
-        """Stop portfolio monitoring"""
-        self.is_running = False
-        
-        # Close all positions if any remain
-        if self.portfolio.positions:
-            await self._close_all_positions()
-        
-        if self.pubsub:
-            await self.pubsub.unsubscribe()
-        
-        if self.redis_client:
-            await self.redis_client.close()
-        
-        logger.info(f"Portfolio Monitor stopped. Final stats: {self.get_statistics()}")
-
-
-# Example usage
-async def main():
-    """Example of running the Portfolio Monitor"""
-    monitor = PortfolioMonitorAgent()
-    await monitor.connect()
-    await monitor.start()
-    
-    # Simulate adding a position
-    await asyncio.sleep(2)
-    
-    # Check capacity for new position
-    capacity = await monitor.check_capacity(500.0)
-    print(f"Capacity check: {capacity}")
-    
-    # Get statistics
-    stats = monitor.get_statistics()
-    print(f"Portfolio stats: {json.dumps(stats, indent=2)}")
-    
-    # Run for a while
-    await asyncio.sleep(60)
-    
-    await monitor.stop()
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
\ No newline at end of file
diff --git a/src/agents/on_demand/__init__.py b/src/agents/on_demand/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/agents/on_demand/game_analyst.py b/src/agents/on_demand/game_analyst.py
deleted file mode 100644
index 9d1f81de..00000000
--- a/src/agents/on_demand/game_analyst.py
+++ /dev/null
@@ -1,515 +0,0 @@
-"""
-Game Analyst Agent - On-Demand Agent
-Deep analysis of specific games when triggered
-"""
-
-import asyncio
-import json
-import logging
-from typing import Dict, Any, List, Optional, Tuple
-from datetime import datetime, timedelta
-from dataclasses import dataclass
-import redis.asyncio as redis
-
-from src.trading.llm_client import get_llm_client
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class GameAnalysis:
-    """Comprehensive game analysis result"""
-    game_id: str
-    teams: Tuple[str, str]
-    recommended_position: Optional[str] = None  # 'yes', 'no', or None
-    confidence: float = 0.0
-    kelly_fraction: float = 0.0
-    key_factors: List[str] = None
-    risk_warnings: List[str] = None
-    analysis_timestamp: datetime = None
-    
-    def __post_init__(self):
-        if self.key_factors is None:
-            self.key_factors = []
-        if self.risk_warnings is None:
-            self.risk_warnings = []
-        if self.analysis_timestamp is None:
-            self.analysis_timestamp = datetime.utcnow()
-
-
-class GameAnalystAgent:
-    """
-    Game Analyst Agent - On-Demand
-    
-    Triggered by:
-    - User requests analysis of specific game
-    - Data Collection Agent detects high-opportunity game
-    - Pre-game analysis (1 hour before kickoff)
-    - Major game events (injuries, momentum shifts)
-    
-    Analysis includes:
-    - Historical performance
-    - Current form and injuries
-    - Market analysis
-    - Sentiment analysis
-    - Weather and venue factors
-    """
-    
-    def __init__(self, redis_url: str = "redis://localhost:6379"):
-        self.redis_url = redis_url
-        self.redis_client = None
-        self.pubsub = None
-        self.is_active = False
-        
-        # LLM client for analysis
-        self.llm_client = get_llm_client()
-        
-        # Cache for recent analyses
-        self.analysis_cache: Dict[str, GameAnalysis] = {}
-        self.cache_duration = timedelta(minutes=30)
-        
-        # Statistics
-        self.analyses_performed = 0
-        self.successful_predictions = 0
-    
-    async def connect(self):
-        """Connect to Redis"""
-        self.redis_client = redis.from_url(self.redis_url)
-        self.pubsub = self.redis_client.pubsub()
-        
-        # Subscribe to activation channel
-        await self.pubsub.subscribe("agent:activate:gameanalyst")
-        
-        logger.info("Game Analyst connected to Redis")
-    
-    async def start(self):
-        """Start listening for activation triggers"""
-        if self.is_active:
-            logger.warning("Game Analyst already active")
-            return
-        
-        self.is_active = True
-        logger.info("Game Analyst ready for activation")
-        
-        # Listen for activation requests
-        asyncio.create_task(self._listen_for_activation())
-    
-    async def _listen_for_activation(self):
-        """Listen for activation triggers from TriggerService"""
-        async for message in self.pubsub.listen():
-            if not self.is_active:
-                break
-            
-            if message['type'] == 'message':
-                try:
-                    activation_data = json.loads(message['data'])
-                    logger.info(f"Game Analyst activated: {activation_data['trigger']}")
-                    
-                    # Perform analysis
-                    await self._handle_activation(activation_data)
-                    
-                except Exception as e:
-                    logger.error(f"Error handling activation: {e}")
-    
-    async def _handle_activation(self, activation_data: Dict[str, Any]):
-        """Handle activation request"""
-        trigger = activation_data.get('trigger')
-        data = activation_data.get('data', {})
-        priority = activation_data.get('priority')
-        
-        # Extract game information
-        game_id = data.get('game_id')
-        teams = (data.get('home_team'), data.get('away_team'))
-        
-        if not game_id or not all(teams):
-            # Try to extract from market ticker
-            market_ticker = data.get('market_ticker', '')
-            if market_ticker:
-                # Parse market ticker for game info
-                game_id = self._extract_game_id(market_ticker)
-                teams = self._extract_teams(market_ticker)
-        
-        if game_id and all(teams):
-            # Perform analysis
-            analysis = await self.analyze_game(game_id, teams, trigger_context=data)
-            
-            # Publish results
-            await self._publish_analysis(analysis, priority)
-    
-    async def analyze_game(
-        self, 
-        game_id: str, 
-        teams: Tuple[str, str],
-        trigger_context: Dict[str, Any] = None
-    ) -> GameAnalysis:
-        """
-        Perform comprehensive game analysis
-        
-        Args:
-            game_id: Game identifier
-            teams: (home_team, away_team)
-            trigger_context: Context data from trigger
-            
-        Returns:
-            GameAnalysis with recommendations
-        """
-        # Check cache first
-        cache_key = f"{game_id}:{teams[0]}:{teams[1]}"
-        if cache_key in self.analysis_cache:
-            cached = self.analysis_cache[cache_key]
-            if datetime.utcnow() - cached.analysis_timestamp < self.cache_duration:
-                logger.info(f"Returning cached analysis for {cache_key}")
-                return cached
-        
-        logger.info(f"Analyzing game: {teams[0]} vs {teams[1]} (ID: {game_id})")
-        
-        # Gather all data sources
-        historical = await self._get_historical_data(teams)
-        current_form = await self._get_current_form(teams)
-        injuries = await self._get_injury_report(teams)
-        market_data = await self._get_market_data(game_id)
-        sentiment = await self._get_sentiment_data(teams)
-        weather = await self._get_weather_conditions(game_id)
-        
-        # Use LLM for comprehensive analysis
-        analysis = await self._llm_analyze(
-            game_id=game_id,
-            teams=teams,
-            historical=historical,
-            form=current_form,
-            injuries=injuries,
-            market=market_data,
-            sentiment=sentiment,
-            weather=weather,
-            trigger_context=trigger_context
-        )
-        
-        # Cache the analysis
-        self.analysis_cache[cache_key] = analysis
-        self.analyses_performed += 1
-        
-        return analysis
-    
-    async def _get_historical_data(self, teams: Tuple[str, str]) -> Dict[str, Any]:
-        """Get historical performance data"""
-        # Query historical data from Redis or database
-        historical_key = f"historical:{teams[0]}:{teams[1]}"
-        data = await self.redis_client.get(historical_key)
-        
-        if data:
-            return json.loads(data)
-        
-        # Default historical data
-        return {
-            "h2h_record": {"home_wins": 0, "away_wins": 0, "draws": 0},
-            "home_recent_form": "WWLWL",  # Last 5 games
-            "away_recent_form": "LWWLL",
-            "avg_total_points": 45.5
-        }
-    
-    async def _get_current_form(self, teams: Tuple[str, str]) -> Dict[str, Any]:
-        """Get current form and recent performance"""
-        form_data = {}
-        
-        for team in teams:
-            form_key = f"form:{team}"
-            data = await self.redis_client.get(form_key)
-            
-            if data:
-                form_data[team] = json.loads(data)
-            else:
-                form_data[team] = {
-                    "last_5_games": "WWLWL",
-                    "points_for_avg": 27.5,
-                    "points_against_avg": 21.3,
-                    "home_away_split": {"home": "3-1", "away": "2-2"}
-                }
-        
-        return form_data
-    
-    async def _get_injury_report(self, teams: Tuple[str, str]) -> Dict[str, Any]:
-        """Get injury reports for both teams"""
-        injuries = {}
-        
-        for team in teams:
-            injury_key = f"injuries:{team}"
-            data = await self.redis_client.get(injury_key)
-            
-            if data:
-                injuries[team] = json.loads(data)
-            else:
-                injuries[team] = []
-        
-        return injuries
-    
-    async def _get_market_data(self, game_id: str) -> Dict[str, Any]:
-        """Get current market data from Kalshi"""
-        market_key = f"market:{game_id}"
-        data = await self.redis_client.get(market_key)
-        
-        if data:
-            return json.loads(data)
-        
-        return {
-            "yes_price": 0.50,
-            "no_price": 0.50,
-            "volume": 0,
-            "open_interest": 0,
-            "implied_probability": 0.50
-        }
-    
-    async def _get_sentiment_data(self, teams: Tuple[str, str]) -> Dict[str, Any]:
-        """Get sentiment analysis from Twitter/social media"""
-        sentiment = {}
-        
-        for team in teams:
-            sentiment_key = f"sentiment:{team}"
-            data = await self.redis_client.get(sentiment_key)
-            
-            if data:
-                sentiment[team] = json.loads(data)
-            else:
-                sentiment[team] = {
-                    "score": 0.0,  # -1 to 1
-                    "volume": 0,
-                    "trending": False
-                }
-        
-        return sentiment
-    
-    async def _get_weather_conditions(self, game_id: str) -> Dict[str, Any]:
-        """Get weather conditions for outdoor games"""
-        weather_key = f"weather:{game_id}"
-        data = await self.redis_client.get(weather_key)
-        
-        if data:
-            return json.loads(data)
-        
-        return {
-            "temperature": 72,
-            "wind_speed": 5,
-            "precipitation": 0,
-            "indoor": True
-        }
-    
-    async def _llm_analyze(
-        self,
-        game_id: str,
-        teams: Tuple[str, str],
-        historical: Dict[str, Any],
-        form: Dict[str, Any],
-        injuries: Dict[str, Any],
-        market: Dict[str, Any],
-        sentiment: Dict[str, Any],
-        weather: Dict[str, Any],
-        trigger_context: Dict[str, Any] = None
-    ) -> GameAnalysis:
-        """Use LLM to analyze all data and generate recommendations"""
-        
-        prompt = f"""
-        Analyze this game and provide trading recommendations:
-        
-        Game: {teams[0]} (home) vs {teams[1]} (away)
-        Game ID: {game_id}
-        
-        Historical Data:
-        - H2H Record: {historical['h2h_record']}
-        - Home Recent Form: {historical['home_recent_form']}
-        - Away Recent Form: {historical['away_recent_form']}
-        
-        Current Form:
-        - {teams[0]}: {form.get(teams[0], {})}
-        - {teams[1]}: {form.get(teams[1], {})}
-        
-        Injuries:
-        - {teams[0]}: {len(injuries.get(teams[0], []))} players injured
-        - {teams[1]}: {len(injuries.get(teams[1], []))} players injured
-        
-        Market Data:
-        - Current Odds: Yes {market['yes_price']:.2f} / No {market['no_price']:.2f}
-        - Volume: {market['volume']}
-        - Implied Probability: {market['implied_probability']:.2%}
-        
-        Sentiment:
-        - {teams[0]}: Score {sentiment.get(teams[0], {}).get('score', 0):.2f}
-        - {teams[1]}: Score {sentiment.get(teams[1], {}).get('score', 0):.2f}
-        
-        Weather:
-        - Temperature: {weather['temperature']}°F
-        - Wind: {weather['wind_speed']} mph
-        - Indoor: {weather['indoor']}
-        
-        Trigger Context: {trigger_context}
-        
-        Provide:
-        1. Recommended position (yes/no/none)
-        2. Confidence level (0-1)
-        3. Kelly fraction recommendation (0-0.25)
-        4. Key factors (list 3-5)
-        5. Risk warnings (list any concerns)
-        
-        Format as JSON.
-        """
-        
-        try:
-            response = await self.llm_client.complete(prompt, temperature=0.2)
-            
-            # Parse LLM response
-            # In production, would use structured output
-            analysis_data = self._parse_llm_response(response)
-            
-            return GameAnalysis(
-                game_id=game_id,
-                teams=teams,
-                recommended_position=analysis_data.get('position'),
-                confidence=analysis_data.get('confidence', 0.5),
-                kelly_fraction=analysis_data.get('kelly', 0.05),
-                key_factors=analysis_data.get('factors', []),
-                risk_warnings=analysis_data.get('risks', [])
-            )
-            
-        except Exception as e:
-            logger.error(f"LLM analysis failed: {e}")
-            
-            # Fallback to simple analysis
-            return GameAnalysis(
-                game_id=game_id,
-                teams=teams,
-                recommended_position=None,
-                confidence=0.0,
-                kelly_fraction=0.0,
-                key_factors=["Analysis failed"],
-                risk_warnings=["Unable to complete analysis"]
-            )
-    
-    def _parse_llm_response(self, response: str) -> Dict[str, Any]:
-        """Parse LLM response into structured data"""
-        try:
-            # Try to parse as JSON
-            if '{' in response and '}' in response:
-                json_str = response[response.find('{'):response.rfind('}')+1]
-                return json.loads(json_str)
-        except:
-            pass
-        
-        # Fallback parsing
-        result = {
-            'position': None,
-            'confidence': 0.5,
-            'kelly': 0.05,
-            'factors': [],
-            'risks': []
-        }
-        
-        # Simple keyword extraction
-        if 'yes' in response.lower() and 'recommend' in response.lower():
-            result['position'] = 'yes'
-        elif 'no' in response.lower() and 'recommend' in response.lower():
-            result['position'] = 'no'
-        
-        return result
-    
-    async def _publish_analysis(self, analysis: GameAnalysis, priority: str):
-        """Publish analysis results"""
-        result = {
-            "type": "GAME_ANALYSIS",
-            "game_id": analysis.game_id,
-            "teams": analysis.teams,
-            "recommendation": {
-                "position": analysis.recommended_position,
-                "confidence": analysis.confidence,
-                "kelly_fraction": analysis.kelly_fraction
-            },
-            "factors": analysis.key_factors,
-            "risks": analysis.risk_warnings,
-            "priority": priority,
-            "timestamp": analysis.analysis_timestamp.isoformat()
-        }
-        
-        # Publish to analysis channel
-        await self.redis_client.publish("analysis:game", json.dumps(result))
-        
-        # If high confidence, publish as signal
-        if analysis.confidence > 0.7 and analysis.recommended_position:
-            signal = {
-                "action": "TRADE_SIGNAL",
-                "source": "GameAnalyst",
-                "market_ticker": f"{analysis.teams[0]}-{analysis.teams[1]}",
-                "side": analysis.recommended_position,
-                "confidence": analysis.confidence,
-                "kelly_fraction": analysis.kelly_fraction,
-                "timestamp": datetime.utcnow().isoformat()
-            }
-            
-            await self.redis_client.publish("kalshi:signals", json.dumps(signal))
-            logger.info(f"Published trade signal: {signal}")
-    
-    def _extract_game_id(self, market_ticker: str) -> Optional[str]:
-        """Extract game ID from market ticker"""
-        # Implementation depends on market ticker format
-        # Example: "NFL-CHIEFS-BILLS-20240115" -> "20240115"
-        parts = market_ticker.split('-')
-        if len(parts) >= 4:
-            return parts[-1]
-        return None
-    
-    def _extract_teams(self, market_ticker: str) -> Tuple[Optional[str], Optional[str]]:
-        """Extract teams from market ticker"""
-        # Example: "NFL-CHIEFS-BILLS-20240115" -> ("CHIEFS", "BILLS")
-        parts = market_ticker.split('-')
-        if len(parts) >= 3:
-            return (parts[1], parts[2])
-        return (None, None)
-    
-    def get_statistics(self) -> Dict[str, Any]:
-        """Get agent statistics"""
-        return {
-            "is_active": self.is_active,
-            "analyses_performed": self.analyses_performed,
-            "cache_size": len(self.analysis_cache),
-            "successful_predictions": self.successful_predictions
-        }
-    
-    async def stop(self):
-        """Stop the agent"""
-        self.is_active = False
-        
-        if self.pubsub:
-            await self.pubsub.unsubscribe()
-        
-        if self.redis_client:
-            await self.redis_client.close()
-        
-        logger.info(f"Game Analyst stopped. Stats: {self.get_statistics()}")
-
-
-# Example usage
-async def main():
-    """Example of running the Game Analyst"""
-    analyst = GameAnalystAgent()
-    await analyst.connect()
-    await analyst.start()
-    
-    # Simulate manual analysis
-    await asyncio.sleep(2)
-    
-    analysis = await analyst.analyze_game(
-        game_id="401547435",
-        teams=("Chiefs", "Bills")
-    )
-    
-    print(f"Analysis: {analysis}")
-    
-    # Get statistics
-    stats = analyst.get_statistics()
-    print(f"Stats: {json.dumps(stats, indent=2)}")
-    
-    # Run for a while
-    await asyncio.sleep(60)
-    
-    await analyst.stop()
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
\ No newline at end of file
diff --git a/src/agents/trigger_service.py b/src/agents/trigger_service.py
deleted file mode 100644
index f967a37d..00000000
--- a/src/agents/trigger_service.py
+++ /dev/null
@@ -1,459 +0,0 @@
-"""
-Trigger Service - Coordinates between always-on and on-demand agents
-Evaluates conditions and activates appropriate agents based on events
-"""
-
-import asyncio
-import json
-import logging
-from typing import Dict, Any, Callable, Optional, List
-from datetime import datetime, time
-from enum import Enum
-import redis.asyncio as redis
-
-logger = logging.getLogger(__name__)
-
-
-class Priority(Enum):
-    """Priority levels for agent activation"""
-    CRITICAL = 1
-    HIGH = 2
-    MEDIUM = 3
-    LOW = 4
-
-
-class TriggerCondition:
-    """Represents a trigger condition for agent activation"""
-    
-    def __init__(
-        self,
-        name: str,
-        condition: Callable[[Dict[str, Any]], bool],
-        agent: str,
-        priority: Priority,
-        cooldown_seconds: int = 60
-    ):
-        self.name = name
-        self.condition = condition
-        self.agent = agent
-        self.priority = priority
-        self.cooldown_seconds = cooldown_seconds
-        self.last_triggered: Optional[datetime] = None
-    
-    def can_trigger(self) -> bool:
-        """Check if trigger is off cooldown"""
-        if self.last_triggered is None:
-            return True
-        
-        elapsed = (datetime.now() - self.last_triggered).total_seconds()
-        return elapsed >= self.cooldown_seconds
-    
-    def evaluate(self, data: Dict[str, Any]) -> bool:
-        """Evaluate if condition is met"""
-        if not self.can_trigger():
-            return False
-        
-        try:
-            return self.condition(data)
-        except Exception as e:
-            logger.error(f"Error evaluating trigger {self.name}: {e}")
-            return False
-    
-    def mark_triggered(self):
-        """Mark this trigger as having fired"""
-        self.last_triggered = datetime.now()
-
-
-class TriggerService:
-    """
-    Coordinates between always-on and on-demand agents
-    Evaluates trigger conditions and activates appropriate agents
-    """
-    
-    def __init__(self, redis_url: str = "redis://localhost:6379"):
-        self.redis_url = redis_url
-        self.redis_client = None
-        self.pubsub = None
-        self.is_running = False
-        
-        # Active agent instances (for on-demand agents)
-        self.active_agents: Dict[str, Any] = {}
-        
-        # Define trigger conditions
-        self.triggers = self._initialize_triggers()
-        
-        # Track activation statistics
-        self.activation_stats: Dict[str, int] = {}
-    
-    def _initialize_triggers(self) -> List[TriggerCondition]:
-        """Initialize all trigger conditions"""
-        return [
-            # Market-based triggers
-            TriggerCondition(
-                name="price_spike",
-                condition=lambda d: abs(d.get('price_change', 0)) > 0.05,
-                agent="ArbitrageHunter",
-                priority=Priority.HIGH,
-                cooldown_seconds=30
-            ),
-            
-            TriggerCondition(
-                name="volume_surge",
-                condition=lambda d: d.get('volume_ratio', 0) > 3.0,
-                agent="GameAnalyst",
-                priority=Priority.HIGH,
-                cooldown_seconds=60
-            ),
-            
-            TriggerCondition(
-                name="arbitrage_opportunity",
-                condition=lambda d: (
-                    d.get('yes_price', 0) + d.get('no_price', 0) < 0.98
-                    and d.get('yes_price', 0) > 0
-                    and d.get('no_price', 0) > 0
-                ),
-                agent="ArbitrageHunter",
-                priority=Priority.CRITICAL,
-                cooldown_seconds=10
-            ),
-            
-            # Game-based triggers
-            TriggerCondition(
-                name="game_starting_soon",
-                condition=lambda d: 0 < d.get('time_to_game', float('inf')) < 3600,
-                agent="GameAnalyst",
-                priority=Priority.MEDIUM,
-                cooldown_seconds=300
-            ),
-            
-            TriggerCondition(
-                name="major_game_event",
-                condition=lambda d: d.get('event_type') in ['touchdown', 'field_goal', 'interception', 'fumble'],
-                agent="GameAnalyst",
-                priority=Priority.HIGH,
-                cooldown_seconds=30
-            ),
-            
-            TriggerCondition(
-                name="injury_reported",
-                condition=lambda d: d.get('event_type') == 'injury' and d.get('player_importance', 0) > 0.7,
-                agent="GameAnalyst",
-                priority=Priority.CRITICAL,
-                cooldown_seconds=60
-            ),
-            
-            # Sentiment-based triggers
-            TriggerCondition(
-                name="sentiment_shift",
-                condition=lambda d: abs(d.get('sentiment_change', 0)) > 0.3,
-                agent="MarketEngineer",
-                priority=Priority.HIGH,
-                cooldown_seconds=120
-            ),
-            
-            TriggerCondition(
-                name="viral_tweet",
-                condition=lambda d: d.get('tweet_engagement', 0) > 10000,
-                agent="MarketEngineer",
-                priority=Priority.MEDIUM,
-                cooldown_seconds=180
-            ),
-            
-            # Portfolio/Risk triggers
-            TriggerCondition(
-                name="position_stop_loss",
-                condition=lambda d: d.get('position_pnl', 0) < -0.10,
-                agent="RiskManager",
-                priority=Priority.CRITICAL,
-                cooldown_seconds=0  # No cooldown for stop-loss
-            ),
-            
-            TriggerCondition(
-                name="portfolio_drawdown",
-                condition=lambda d: d.get('portfolio_drawdown', 0) > 0.15,
-                agent="RiskManager",
-                priority=Priority.CRITICAL,
-                cooldown_seconds=60
-            ),
-            
-            # Scheduled triggers
-            TriggerCondition(
-                name="daily_optimization",
-                condition=lambda d: (
-                    d.get('event_type') == 'scheduled' 
-                    and d.get('schedule_name') == 'daily_review'
-                ),
-                agent="StrategyOptimizer",
-                priority=Priority.LOW,
-                cooldown_seconds=86400  # Once per day
-            ),
-            
-            TriggerCondition(
-                name="performance_review",
-                condition=lambda d: d.get('trades_completed', 0) >= 20,
-                agent="StrategyOptimizer",
-                priority=Priority.MEDIUM,
-                cooldown_seconds=3600
-            ),
-            
-            # Cross-market opportunities
-            TriggerCondition(
-                name="correlated_divergence",
-                condition=lambda d: (
-                    d.get('correlation_break', False) 
-                    and d.get('divergence_magnitude', 0) > 0.1
-                ),
-                agent="ArbitrageHunter",
-                priority=Priority.HIGH,
-                cooldown_seconds=120
-            ),
-            
-            # User-initiated triggers
-            TriggerCondition(
-                name="user_analysis_request",
-                condition=lambda d: d.get('event_type') == 'user_request',
-                agent="GameAnalyst",  # Default to GameAnalyst, can be overridden
-                priority=Priority.HIGH,
-                cooldown_seconds=0  # No cooldown for user requests
-            )
-        ]
-    
-    async def connect(self):
-        """Connect to Redis"""
-        self.redis_client = redis.from_url(self.redis_url)
-        self.pubsub = self.redis_client.pubsub()
-        logger.info("Trigger Service connected to Redis")
-    
-    async def start(self):
-        """Start the trigger service"""
-        if self.is_running:
-            logger.warning("Trigger Service already running")
-            return
-        
-        self.is_running = True
-        
-        # Subscribe to event channels
-        await self.pubsub.subscribe(
-            "events:market",
-            "events:game",
-            "events:sentiment",
-            "events:portfolio",
-            "events:user"
-        )
-        
-        logger.info("Trigger Service started")
-        
-        # Start evaluation loop
-        asyncio.create_task(self._evaluation_loop())
-        
-        # Start scheduled triggers
-        asyncio.create_task(self._scheduled_triggers())
-    
-    async def _evaluation_loop(self):
-        """Main loop for evaluating trigger conditions"""
-        async for message in self.pubsub.listen():
-            if not self.is_running:
-                break
-            
-            if message['type'] == 'message':
-                try:
-                    channel = message['channel'].decode('utf-8')
-                    data = json.loads(message['data'])
-                    
-                    # Evaluate triggers
-                    await self.evaluate_triggers(data, channel)
-                    
-                except Exception as e:
-                    logger.error(f"Error processing message: {e}")
-    
-    async def evaluate_triggers(self, event_data: Dict[str, Any], source_channel: str):
-        """
-        Evaluate all triggers against incoming event
-        
-        Args:
-            event_data: Event data to evaluate
-            source_channel: Source channel of the event
-        """
-        triggered = []
-        
-        for trigger in self.triggers:
-            if trigger.evaluate(event_data):
-                triggered.append(trigger)
-                trigger.mark_triggered()
-                logger.info(f"Trigger '{trigger.name}' activated for agent '{trigger.agent}'")
-        
-        # Sort by priority
-        triggered.sort(key=lambda t: t.priority.value)
-        
-        # Activate agents
-        for trigger in triggered:
-            await self.activate_agent(
-                agent_name=trigger.agent,
-                trigger_name=trigger.name,
-                event_data=event_data,
-                priority=trigger.priority
-            )
-    
-    async def activate_agent(
-        self,
-        agent_name: str,
-        trigger_name: str,
-        event_data: Dict[str, Any],
-        priority: Priority
-    ):
-        """
-        Activate an on-demand agent
-        
-        Args:
-            agent_name: Name of agent to activate
-            trigger_name: Name of trigger that fired
-            event_data: Event data that triggered activation
-            priority: Priority level
-        """
-        activation_data = {
-            "agent": agent_name,
-            "trigger": trigger_name,
-            "priority": priority.name,
-            "data": event_data,
-            "timestamp": datetime.utcnow().isoformat()
-        }
-        
-        # Publish activation request
-        channel = f"agent:activate:{agent_name.lower()}"
-        await self.redis_client.publish(channel, json.dumps(activation_data))
-        
-        # Update statistics
-        self.activation_stats[agent_name] = self.activation_stats.get(agent_name, 0) + 1
-        
-        logger.info(
-            f"Activated {agent_name} via trigger '{trigger_name}' "
-            f"with priority {priority.name}"
-        )
-        
-        # For critical priority, also send alert
-        if priority == Priority.CRITICAL:
-            await self._send_critical_alert(agent_name, trigger_name, event_data)
-    
-    async def _send_critical_alert(
-        self,
-        agent_name: str,
-        trigger_name: str,
-        event_data: Dict[str, Any]
-    ):
-        """Send alert for critical triggers"""
-        alert = {
-            "type": "CRITICAL_TRIGGER",
-            "agent": agent_name,
-            "trigger": trigger_name,
-            "summary": f"Critical trigger '{trigger_name}' activated {agent_name}",
-            "data": event_data,
-            "timestamp": datetime.utcnow().isoformat()
-        }
-        
-        await self.redis_client.publish("alerts:critical", json.dumps(alert))
-        logger.critical(f"CRITICAL: {alert['summary']}")
-    
-    async def _scheduled_triggers(self):
-        """Handle scheduled triggers (daily reviews, etc.)"""
-        while self.is_running:
-            now = datetime.now()
-            
-            # Daily review at 11 PM
-            if now.hour == 23 and now.minute == 0:
-                await self.evaluate_triggers(
-                    {
-                        "event_type": "scheduled",
-                        "schedule_name": "daily_review",
-                        "timestamp": now.isoformat()
-                    },
-                    "scheduled"
-                )
-                
-                # Wait to avoid duplicate triggers
-                await asyncio.sleep(60)
-            
-            # Check every minute
-            await asyncio.sleep(60)
-    
-    async def manual_trigger(
-        self,
-        agent_name: str,
-        data: Dict[str, Any],
-        reason: str = "manual"
-    ):
-        """
-        Manually trigger an agent activation
-        
-        Args:
-            agent_name: Agent to activate
-            data: Data to pass to agent
-            reason: Reason for manual trigger
-        """
-        await self.activate_agent(
-            agent_name=agent_name,
-            trigger_name=f"manual:{reason}",
-            event_data=data,
-            priority=Priority.HIGH
-        )
-    
-    def get_statistics(self) -> Dict[str, Any]:
-        """Get trigger service statistics"""
-        return {
-            "is_running": self.is_running,
-            "triggers_configured": len(self.triggers),
-            "activation_stats": self.activation_stats,
-            "trigger_status": [
-                {
-                    "name": t.name,
-                    "agent": t.agent,
-                    "priority": t.priority.name,
-                    "last_triggered": t.last_triggered.isoformat() if t.last_triggered else None,
-                    "on_cooldown": not t.can_trigger()
-                }
-                for t in self.triggers
-            ]
-        }
-    
-    async def stop(self):
-        """Stop the trigger service"""
-        self.is_running = False
-        
-        if self.pubsub:
-            await self.pubsub.unsubscribe()
-        
-        if self.redis_client:
-            await self.redis_client.close()
-        
-        logger.info(f"Trigger Service stopped. Activations: {self.activation_stats}")
-
-
-# Example usage
-async def main():
-    """Example of running the trigger service"""
-    service = TriggerService()
-    await service.connect()
-    await service.start()
-    
-    # Simulate some events
-    await asyncio.sleep(2)
-    
-    # Manual trigger example
-    await service.manual_trigger(
-        "GameAnalyst",
-        {"game_id": "12345", "teams": ["Chiefs", "Bills"]},
-        reason="user_request"
-    )
-    
-    # Get statistics
-    stats = service.get_statistics()
-    print(f"Trigger Service Stats: {json.dumps(stats, indent=2)}")
-    
-    # Run for a while
-    await asyncio.sleep(60)
-    
-    await service.stop()
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
\ No newline at end of file
diff --git a/src/backtesting/__init__.py b/src/backtesting/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/backtesting/backtest_engine.py b/src/backtesting/backtest_engine.py
deleted file mode 100644
index 778caf45..00000000
--- a/src/backtesting/backtest_engine.py
+++ /dev/null
@@ -1,566 +0,0 @@
-"""
-Backtesting Engine for Kalshi Trading System
-Allows testing strategies with historical data and parameter optimization
-"""
-
-import asyncio
-import json
-import logging
-from typing import Dict, Any, List, Optional, Tuple
-from datetime import datetime, timedelta
-from dataclasses import dataclass, field
-from enum import Enum
-import pandas as pd
-import numpy as np
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-
-class TradeSide(Enum):
-    YES = "yes"
-    NO = "no"
-
-
-@dataclass
-class BacktestTrade:
-    """Represents a trade in backtesting"""
-    timestamp: datetime
-    market_ticker: str
-    side: TradeSide
-    entry_price: float
-    exit_price: Optional[float] = None
-    exit_timestamp: Optional[datetime] = None
-    quantity: int = 100
-    confidence: float = 0.5
-    kelly_fraction: float = 0.05
-    pnl: float = 0.0
-    pnl_pct: float = 0.0
-    trigger_reason: str = ""
-    exit_reason: str = ""
-    
-    def calculate_pnl(self):
-        """Calculate P&L for the trade"""
-        if self.exit_price is not None:
-            if self.side == TradeSide.YES:
-                self.pnl = (self.exit_price - self.entry_price) * self.quantity
-            else:
-                self.pnl = (self.entry_price - self.exit_price) * self.quantity
-            
-            self.pnl_pct = self.pnl / (self.entry_price * self.quantity)
-
-
-@dataclass
-class StrategyParameters:
-    """Adjustable strategy parameters for backtesting"""
-    # Position sizing
-    kelly_multiplier: float = 0.25  # Fraction of Kelly to use
-    max_position_pct: float = 0.05  # Max 5% per position
-    min_position_size: int = 10
-    max_position_size: int = 100
-    
-    # Entry triggers
-    price_spike_threshold: float = 0.05  # 5% price change
-    volume_surge_multiplier: float = 3.0  # 3x average volume
-    sentiment_shift_threshold: float = 0.3  # 30% sentiment change
-    arbitrage_min_profit: float = 0.02  # 2% minimum arbitrage
-    
-    # Exit rules
-    stop_loss_pct: float = 0.10  # 10% stop loss
-    take_profit_pct: float = 0.30  # 30% take profit
-    time_based_exit_hours: int = 24  # Exit after 24 hours
-    
-    # Risk management
-    max_daily_loss_pct: float = 0.20  # 20% daily loss limit
-    max_correlation: float = 0.7  # Max correlation between positions
-    max_concurrent_positions: int = 5
-    
-    # Market filters
-    min_liquidity: float = 1000  # Minimum volume
-    max_spread: float = 0.10  # Maximum bid-ask spread
-    min_confidence: float = 0.60  # Minimum confidence to trade
-    
-    # Time filters
-    avoid_first_minutes: int = 5  # Avoid first 5 min after game start
-    avoid_last_minutes: int = 5  # Avoid last 5 min before game end
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert parameters to dictionary"""
-        return {
-            'kelly_multiplier': self.kelly_multiplier,
-            'max_position_pct': self.max_position_pct,
-            'min_position_size': self.min_position_size,
-            'max_position_size': self.max_position_size,
-            'price_spike_threshold': self.price_spike_threshold,
-            'volume_surge_multiplier': self.volume_surge_multiplier,
-            'sentiment_shift_threshold': self.sentiment_shift_threshold,
-            'arbitrage_min_profit': self.arbitrage_min_profit,
-            'stop_loss_pct': self.stop_loss_pct,
-            'take_profit_pct': self.take_profit_pct,
-            'time_based_exit_hours': self.time_based_exit_hours,
-            'max_daily_loss_pct': self.max_daily_loss_pct,
-            'max_correlation': self.max_correlation,
-            'max_concurrent_positions': self.max_concurrent_positions,
-            'min_liquidity': self.min_liquidity,
-            'max_spread': self.max_spread,
-            'min_confidence': self.min_confidence,
-            'avoid_first_minutes': self.avoid_first_minutes,
-            'avoid_last_minutes': self.avoid_last_minutes
-        }
-
-
-@dataclass
-class BacktestResults:
-    """Results from a backtest run"""
-    start_date: datetime
-    end_date: datetime
-    initial_capital: float
-    final_capital: float
-    total_trades: int
-    winning_trades: int
-    losing_trades: int
-    total_pnl: float
-    total_return: float
-    sharpe_ratio: float
-    max_drawdown: float
-    win_rate: float
-    avg_win: float
-    avg_loss: float
-    profit_factor: float
-    trades: List[BacktestTrade] = field(default_factory=list)
-    daily_returns: List[float] = field(default_factory=list)
-    equity_curve: List[float] = field(default_factory=list)
-    parameters: Dict[str, Any] = field(default_factory=dict)
-    
-    def calculate_metrics(self):
-        """Calculate performance metrics"""
-        if not self.trades:
-            return
-        
-        # Win rate
-        self.winning_trades = sum(1 for t in self.trades if t.pnl > 0)
-        self.losing_trades = sum(1 for t in self.trades if t.pnl < 0)
-        self.win_rate = self.winning_trades / max(self.total_trades, 1)
-        
-        # Average win/loss
-        wins = [t.pnl for t in self.trades if t.pnl > 0]
-        losses = [t.pnl for t in self.trades if t.pnl < 0]
-        
-        self.avg_win = np.mean(wins) if wins else 0
-        self.avg_loss = np.mean(losses) if losses else 0
-        
-        # Profit factor
-        total_wins = sum(wins) if wins else 0
-        total_losses = abs(sum(losses)) if losses else 1
-        self.profit_factor = total_wins / total_losses if total_losses > 0 else 0
-        
-        # Sharpe ratio (assuming 0% risk-free rate)
-        if self.daily_returns:
-            returns_array = np.array(self.daily_returns)
-            if len(returns_array) > 1:
-                self.sharpe_ratio = np.mean(returns_array) / np.std(returns_array) * np.sqrt(252)
-            else:
-                self.sharpe_ratio = 0
-        
-        # Max drawdown
-        if self.equity_curve:
-            peak = self.equity_curve[0]
-            max_dd = 0
-            for value in self.equity_curve:
-                if value > peak:
-                    peak = value
-                dd = (peak - value) / peak
-                if dd > max_dd:
-                    max_dd = dd
-            self.max_drawdown = max_dd
-
-
-class BacktestEngine:
-    """
-    Main backtesting engine for strategy evaluation
-    """
-    
-    def __init__(
-        self,
-        initial_capital: float = 10000,
-        data_path: str = "backtesting/historical_data"
-    ):
-        self.initial_capital = initial_capital
-        self.data_path = Path(data_path)
-        self.historical_data: Dict[str, pd.DataFrame] = {}
-        self.current_positions: Dict[str, BacktestTrade] = {}
-        self.completed_trades: List[BacktestTrade] = []
-        self.equity_curve: List[float] = []
-        self.daily_returns: List[float] = []
-        
-    async def load_historical_data(
-        self,
-        start_date: datetime,
-        end_date: datetime,
-        markets: List[str]
-    ):
-        """
-        Load historical data for backtesting
-        
-        Args:
-            start_date: Start of backtest period
-            end_date: End of backtest period
-            markets: List of market tickers to load
-        """
-        for market in markets:
-            file_path = self.data_path / f"{market}_historical.csv"
-            
-            if file_path.exists():
-                df = pd.read_csv(file_path, parse_dates=['timestamp'])
-                # Filter by date range
-                df = df[(df['timestamp'] >= start_date) & (df['timestamp'] <= end_date)]
-                self.historical_data[market] = df
-                logger.info(f"Loaded {len(df)} records for {market}")
-            else:
-                logger.warning(f"No historical data found for {market}")
-    
-    async def run_backtest(
-        self,
-        strategy_params: StrategyParameters,
-        start_date: datetime,
-        end_date: datetime,
-        markets: List[str]
-    ) -> BacktestResults:
-        """
-        Run backtest with given parameters
-        
-        Args:
-            strategy_params: Strategy parameters to test
-            start_date: Start of backtest period
-            end_date: End of backtest period
-            markets: Markets to trade
-            
-        Returns:
-            BacktestResults with performance metrics
-        """
-        logger.info(f"Starting backtest from {start_date} to {end_date}")
-        
-        # Reset state
-        self.current_positions = {}
-        self.completed_trades = []
-        self.equity_curve = [self.initial_capital]
-        self.daily_returns = []
-        
-        # Load data if not already loaded
-        if not self.historical_data:
-            await self.load_historical_data(start_date, end_date, markets)
-        
-        # Initialize portfolio
-        current_capital = self.initial_capital
-        current_date = start_date
-        
-        # Main backtest loop
-        while current_date <= end_date:
-            daily_pnl = 0
-            
-            # Process each market
-            for market in markets:
-                if market not in self.historical_data:
-                    continue
-                
-                df = self.historical_data[market]
-                
-                # Get data for current timestamp
-                current_data = df[
-                    (df['timestamp'] >= current_date) & 
-                    (df['timestamp'] < current_date + timedelta(days=1))
-                ]
-                
-                if current_data.empty:
-                    continue
-                
-                for _, row in current_data.iterrows():
-                    # Check exit conditions for open positions
-                    if market in self.current_positions:
-                        position = self.current_positions[market]
-                        should_exit, exit_reason = self._check_exit_conditions(
-                            position, row, strategy_params
-                        )
-                        
-                        if should_exit:
-                            # Close position
-                            position.exit_price = row['yes_price']
-                            position.exit_timestamp = row['timestamp']
-                            position.exit_reason = exit_reason
-                            position.calculate_pnl()
-                            
-                            daily_pnl += position.pnl
-                            current_capital += position.pnl
-                            
-                            self.completed_trades.append(position)
-                            del self.current_positions[market]
-                            
-                            logger.info(
-                                f"Closed {market}: {exit_reason}, "
-                                f"P&L: ${position.pnl:.2f} ({position.pnl_pct:.1%})"
-                            )
-                    
-                    # Check entry conditions
-                    elif len(self.current_positions) < strategy_params.max_concurrent_positions:
-                        should_enter, entry_reason, confidence = self._check_entry_conditions(
-                            row, strategy_params
-                        )
-                        
-                        if should_enter and confidence >= strategy_params.min_confidence:
-                            # Calculate position size
-                            position_size = self._calculate_position_size(
-                                current_capital, confidence, strategy_params
-                            )
-                            
-                            # Open position
-                            side = self._determine_side(row, entry_reason)
-                            
-                            position = BacktestTrade(
-                                timestamp=row['timestamp'],
-                                market_ticker=market,
-                                side=side,
-                                entry_price=row['yes_price'] if side == TradeSide.YES else row['no_price'],
-                                quantity=position_size,
-                                confidence=confidence,
-                                trigger_reason=entry_reason
-                            )
-                            
-                            self.current_positions[market] = position
-                            current_capital -= position.entry_price * position.quantity
-                            
-                            logger.info(
-                                f"Opened {market}: {side.value} @ {position.entry_price:.2f}, "
-                                f"Size: {position_size}, Reason: {entry_reason}"
-                            )
-            
-            # Update equity curve
-            total_value = current_capital + sum(
-                p.quantity * p.entry_price for p in self.current_positions.values()
-            )
-            self.equity_curve.append(total_value)
-            
-            # Calculate daily return
-            if len(self.equity_curve) > 1:
-                daily_return = (self.equity_curve[-1] - self.equity_curve[-2]) / self.equity_curve[-2]
-                self.daily_returns.append(daily_return)
-            
-            # Check daily loss limit
-            daily_loss = (total_value - self.initial_capital) / self.initial_capital
-            if daily_loss < -strategy_params.max_daily_loss_pct:
-                logger.warning(f"Daily loss limit reached: {daily_loss:.1%}")
-                # Close all positions
-                for market, position in list(self.current_positions.items()):
-                    position.exit_price = position.entry_price * 0.95  # Assume 5% slippage
-                    position.exit_timestamp = current_date
-                    position.exit_reason = "Daily loss limit"
-                    position.calculate_pnl()
-                    self.completed_trades.append(position)
-                    del self.current_positions[market]
-            
-            # Move to next day
-            current_date += timedelta(days=1)
-        
-        # Close any remaining positions
-        for market, position in self.current_positions.items():
-            position.exit_price = position.entry_price  # Exit at current price
-            position.exit_timestamp = end_date
-            position.exit_reason = "Backtest end"
-            position.calculate_pnl()
-            self.completed_trades.append(position)
-        
-        # Calculate final metrics
-        final_capital = current_capital + sum(
-            t.pnl for t in self.completed_trades
-        )
-        
-        results = BacktestResults(
-            start_date=start_date,
-            end_date=end_date,
-            initial_capital=self.initial_capital,
-            final_capital=final_capital,
-            total_trades=len(self.completed_trades),
-            winning_trades=0,
-            losing_trades=0,
-            total_pnl=final_capital - self.initial_capital,
-            total_return=(final_capital - self.initial_capital) / self.initial_capital,
-            sharpe_ratio=0,
-            max_drawdown=0,
-            win_rate=0,
-            avg_win=0,
-            avg_loss=0,
-            profit_factor=0,
-            trades=self.completed_trades,
-            daily_returns=self.daily_returns,
-            equity_curve=self.equity_curve,
-            parameters=strategy_params.to_dict()
-        )
-        
-        results.calculate_metrics()
-        
-        return results
-    
-    def _check_entry_conditions(
-        self,
-        data: pd.Series,
-        params: StrategyParameters
-    ) -> Tuple[bool, str, float]:
-        """
-        Check if entry conditions are met
-        
-        Returns:
-            (should_enter, reason, confidence)
-        """
-        # Check liquidity
-        if data.get('volume', 0) < params.min_liquidity:
-            return False, "", 0.0
-        
-        # Check spread
-        spread = abs(data.get('yes_price', 0) + data.get('no_price', 0) - 1.0)
-        if spread > params.max_spread:
-            return False, "", 0.0
-        
-        # Price spike detection
-        if 'price_change' in data and abs(data['price_change']) > params.price_spike_threshold:
-            confidence = min(0.5 + abs(data['price_change']), 0.9)
-            return True, "price_spike", confidence
-        
-        # Volume surge detection
-        if 'volume_ratio' in data and data['volume_ratio'] > params.volume_surge_multiplier:
-            confidence = min(0.5 + data['volume_ratio'] / 10, 0.85)
-            return True, "volume_surge", confidence
-        
-        # Arbitrage opportunity
-        yes_price = data.get('yes_price', 0)
-        no_price = data.get('no_price', 0)
-        if yes_price > 0 and no_price > 0:
-            total = yes_price + no_price
-            if total < (1.0 - params.arbitrage_min_profit):
-                confidence = min(0.7 + (1.0 - total), 0.95)
-                return True, "arbitrage", confidence
-        
-        # Sentiment shift
-        if 'sentiment_change' in data and abs(data['sentiment_change']) > params.sentiment_shift_threshold:
-            confidence = min(0.6 + abs(data['sentiment_change']), 0.85)
-            return True, "sentiment_shift", confidence
-        
-        return False, "", 0.0
-    
-    def _check_exit_conditions(
-        self,
-        position: BacktestTrade,
-        data: pd.Series,
-        params: StrategyParameters
-    ) -> Tuple[bool, str]:
-        """
-        Check if exit conditions are met
-        
-        Returns:
-            (should_exit, reason)
-        """
-        current_price = data['yes_price'] if position.side == TradeSide.YES else data['no_price']
-        
-        # Calculate current P&L
-        if position.side == TradeSide.YES:
-            pnl_pct = (current_price - position.entry_price) / position.entry_price
-        else:
-            pnl_pct = (position.entry_price - current_price) / position.entry_price
-        
-        # Stop loss
-        if pnl_pct <= -params.stop_loss_pct:
-            return True, f"Stop loss ({pnl_pct:.1%})"
-        
-        # Take profit
-        if pnl_pct >= params.take_profit_pct:
-            return True, f"Take profit ({pnl_pct:.1%})"
-        
-        # Time-based exit
-        time_held = data['timestamp'] - position.timestamp
-        if time_held.total_seconds() / 3600 > params.time_based_exit_hours:
-            return True, f"Time exit ({time_held.total_seconds()/3600:.1f} hours)"
-        
-        # Game ended (if we have that data)
-        if data.get('game_ended', False):
-            return True, "Game ended"
-        
-        return False, ""
-    
-    def _determine_side(self, data: pd.Series, entry_reason: str) -> TradeSide:
-        """Determine which side to trade"""
-        if entry_reason == "arbitrage":
-            # For arbitrage, buy both but we'll simplify to YES
-            return TradeSide.YES
-        
-        # For other signals, trade in direction of signal
-        if 'sentiment_change' in data and data['sentiment_change'] > 0:
-            return TradeSide.YES
-        elif 'price_change' in data and data['price_change'] > 0:
-            return TradeSide.YES
-        
-        return TradeSide.NO
-    
-    def _calculate_position_size(
-        self,
-        capital: float,
-        confidence: float,
-        params: StrategyParameters
-    ) -> int:
-        """Calculate position size using Kelly Criterion"""
-        # Kelly fraction
-        kelly = confidence - (1 - confidence)
-        kelly = max(0, kelly)  # Ensure non-negative
-        
-        # Apply multiplier
-        adjusted_kelly = kelly * params.kelly_multiplier
-        
-        # Calculate dollar amount
-        position_value = capital * adjusted_kelly
-        
-        # Apply position limits
-        max_position_value = capital * params.max_position_pct
-        position_value = min(position_value, max_position_value)
-        
-        # Convert to quantity (assuming $1 per contract)
-        quantity = int(position_value)
-        
-        # Apply min/max limits
-        quantity = max(params.min_position_size, quantity)
-        quantity = min(params.max_position_size, quantity)
-        
-        return quantity
-
-
-# Example usage
-async def main():
-    """Example backtest run"""
-    
-    # Initialize engine
-    engine = BacktestEngine(initial_capital=10000)
-    
-    # Define strategy parameters
-    params = StrategyParameters(
-        kelly_multiplier=0.25,
-        stop_loss_pct=0.10,
-        take_profit_pct=0.30,
-        price_spike_threshold=0.05,
-        min_confidence=0.65
-    )
-    
-    # Run backtest
-    results = await engine.run_backtest(
-        strategy_params=params,
-        start_date=datetime(2024, 1, 1),
-        end_date=datetime(2024, 12, 31),
-        markets=["NFL-CHIEFS-WIN", "NFL-BILLS-WIN"]
-    )
-    
-    # Display results
-    print(f"Total Return: {results.total_return:.1%}")
-    print(f"Win Rate: {results.win_rate:.1%}")
-    print(f"Sharpe Ratio: {results.sharpe_ratio:.2f}")
-    print(f"Max Drawdown: {results.max_drawdown:.1%}")
-    print(f"Profit Factor: {results.profit_factor:.2f}")
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
\ No newline at end of file
diff --git a/src/backtesting/historical_data_collector.py b/src/backtesting/historical_data_collector.py
deleted file mode 100644
index e62c03d7..00000000
--- a/src/backtesting/historical_data_collector.py
+++ /dev/null
@@ -1,469 +0,0 @@
-"""
-Historical Data Collector for Backtesting
-Collects and stores historical data from Kalshi, ESPN, and Twitter
-"""
-
-import asyncio
-import json
-import logging
-from typing import Dict, Any, List, Optional
-from datetime import datetime, timedelta
-import pandas as pd
-from pathlib import Path
-import aiohttp
-import os
-
-from src.data_pipeline.data_sources.kalshi.client import KalshiClient as KalshiAPIClient
-from src.data_pipeline.data_sources.espn.client import ESPNClient as ESPNDataAPI
-from src.data_pipeline.data_sources.twitter.search import TwitterSearchClient as TwitterSearchAPI
-
-logger = logging.getLogger(__name__)
-
-
-class HistoricalDataCollector:
-    """
-    Collects historical data for backtesting
-    
-    Data sources:
-    - Kalshi: Market prices, volumes, trades
-    - ESPN: Game scores, events, statistics
-    - Twitter: Sentiment data, tweet volumes
-    """
-    
-    def __init__(self, output_dir: str = "backtesting/historical_data"):
-        self.output_dir = Path(output_dir)
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Initialize API clients
-        self.kalshi_client = KalshiAPIClient()
-        self.espn_client = ESPNDataAPI()
-        self.twitter_client = TwitterSearchAPI()
-        
-        # Data storage
-        self.market_data: Dict[str, List[Dict]] = {}
-        self.game_data: Dict[str, List[Dict]] = {}
-        self.sentiment_data: Dict[str, List[Dict]] = {}
-    
-    async def collect_historical_data(
-        self,
-        start_date: datetime,
-        end_date: datetime,
-        markets: List[str],
-        interval_minutes: int = 5
-    ):
-        """
-        Collect historical data for specified period and markets
-        
-        Args:
-            start_date: Start of collection period
-            end_date: End of collection period
-            markets: List of market tickers to collect
-            interval_minutes: Data collection interval
-        """
-        logger.info(f"Collecting data from {start_date} to {end_date}")
-        
-        # Collect data for each market
-        for market in markets:
-            logger.info(f"Processing market: {market}")
-            
-            # Collect Kalshi market data
-            await self._collect_kalshi_data(market, start_date, end_date, interval_minutes)
-            
-            # Extract game info from market ticker
-            game_info = self._extract_game_info(market)
-            if game_info:
-                # Collect ESPN game data
-                await self._collect_espn_data(
-                    game_info['game_id'],
-                    game_info['teams'],
-                    start_date,
-                    end_date
-                )
-                
-                # Collect Twitter sentiment
-                await self._collect_twitter_data(
-                    game_info['teams'],
-                    start_date,
-                    end_date,
-                    interval_minutes
-                )
-            
-            # Save collected data
-            await self._save_market_data(market)
-    
-    async def _collect_kalshi_data(
-        self,
-        market_ticker: str,
-        start_date: datetime,
-        end_date: datetime,
-        interval_minutes: int
-    ):
-        """Collect historical Kalshi market data"""
-        data_points = []
-        current_time = start_date
-        
-        while current_time <= end_date:
-            try:
-                # Get market snapshot
-                market_data = await self._get_kalshi_snapshot(market_ticker, current_time)
-                
-                if market_data:
-                    data_points.append({
-                        'timestamp': current_time,
-                        'market_ticker': market_ticker,
-                        'yes_price': market_data.get('yes_price', 0),
-                        'no_price': market_data.get('no_price', 0),
-                        'yes_bid': market_data.get('yes_bid', 0),
-                        'yes_ask': market_data.get('yes_ask', 0),
-                        'no_bid': market_data.get('no_bid', 0),
-                        'no_ask': market_data.get('no_ask', 0),
-                        'volume': market_data.get('volume', 0),
-                        'open_interest': market_data.get('open_interest', 0),
-                        'last_trade_time': market_data.get('last_trade_time'),
-                        'price_change': self._calculate_price_change(data_points, market_data),
-                        'volume_ratio': self._calculate_volume_ratio(data_points, market_data)
-                    })
-                
-            except Exception as e:
-                logger.error(f"Error collecting Kalshi data at {current_time}: {e}")
-            
-            current_time += timedelta(minutes=interval_minutes)
-        
-        self.market_data[market_ticker] = data_points
-        logger.info(f"Collected {len(data_points)} Kalshi data points for {market_ticker}")
-    
-    async def _get_kalshi_snapshot(
-        self,
-        market_ticker: str,
-        timestamp: datetime
-    ) -> Optional[Dict[str, Any]]:
-        """Get Kalshi market snapshot at specific time"""
-        # In production, this would query historical data API
-        # For now, simulate with mock data
-        
-        # Mock implementation
-        import random
-        
-        base_price = 0.5 + random.gauss(0, 0.1)
-        base_price = max(0.01, min(0.99, base_price))
-        
-        return {
-            'yes_price': base_price,
-            'no_price': 1 - base_price,
-            'yes_bid': base_price - 0.01,
-            'yes_ask': base_price + 0.01,
-            'no_bid': (1 - base_price) - 0.01,
-            'no_ask': (1 - base_price) + 0.01,
-            'volume': random.randint(1000, 50000),
-            'open_interest': random.randint(5000, 100000),
-            'last_trade_time': timestamp.isoformat()
-        }
-    
-    async def _collect_espn_data(
-        self,
-        game_id: str,
-        teams: tuple,
-        start_date: datetime,
-        end_date: datetime
-    ):
-        """Collect historical ESPN game data"""
-        data_points = []
-        
-        try:
-            # Get game events
-            game_events = await self._get_espn_game_events(game_id, start_date, end_date)
-            
-            for event in game_events:
-                data_points.append({
-                    'timestamp': event['timestamp'],
-                    'game_id': game_id,
-                    'home_team': teams[0],
-                    'away_team': teams[1],
-                    'home_score': event.get('home_score', 0),
-                    'away_score': event.get('away_score', 0),
-                    'quarter': event.get('quarter', 1),
-                    'time_remaining': event.get('time_remaining', '15:00'),
-                    'event_type': event.get('event_type'),
-                    'event_description': event.get('description'),
-                    'win_probability': event.get('win_probability', 0.5),
-                    'momentum': event.get('momentum', 0)
-                })
-                
-        except Exception as e:
-            logger.error(f"Error collecting ESPN data for game {game_id}: {e}")
-        
-        self.game_data[game_id] = data_points
-        logger.info(f"Collected {len(data_points)} ESPN data points for game {game_id}")
-    
-    async def _get_espn_game_events(
-        self,
-        game_id: str,
-        start_date: datetime,
-        end_date: datetime
-    ) -> List[Dict[str, Any]]:
-        """Get ESPN game events"""
-        # Mock implementation
-        events = []
-        
-        # Simulate game progression
-        game_time = start_date
-        quarter = 1
-        home_score = 0
-        away_score = 0
-        
-        while game_time <= end_date and quarter <= 4:
-            # Random scoring events
-            import random
-            
-            if random.random() < 0.1:  # 10% chance of scoring
-                if random.random() < 0.5:
-                    home_score += random.choice([3, 7])
-                    event_type = "touchdown" if home_score % 7 == 0 else "field_goal"
-                else:
-                    away_score += random.choice([3, 7])
-                    event_type = "touchdown" if away_score % 7 == 0 else "field_goal"
-            else:
-                event_type = "play"
-            
-            events.append({
-                'timestamp': game_time,
-                'home_score': home_score,
-                'away_score': away_score,
-                'quarter': quarter,
-                'time_remaining': f"{15 - (game_time - start_date).seconds // 60 % 15}:00",
-                'event_type': event_type,
-                'description': f"Q{quarter} - {event_type}",
-                'win_probability': 0.5 + (home_score - away_score) * 0.02,
-                'momentum': (home_score - away_score) / 10
-            })
-            
-            game_time += timedelta(minutes=5)
-            
-            # Advance quarter
-            if (game_time - start_date).seconds // 60 % 60 == 0:
-                quarter += 1
-        
-        return events
-    
-    async def _collect_twitter_data(
-        self,
-        teams: tuple,
-        start_date: datetime,
-        end_date: datetime,
-        interval_minutes: int
-    ):
-        """Collect historical Twitter sentiment data"""
-        data_points = []
-        current_time = start_date
-        
-        while current_time <= end_date:
-            try:
-                # Get sentiment for each team
-                for team in teams:
-                    sentiment = await self._get_twitter_sentiment(team, current_time)
-                    
-                    if sentiment:
-                        data_points.append({
-                            'timestamp': current_time,
-                            'team': team,
-                            'sentiment_score': sentiment['score'],
-                            'tweet_volume': sentiment['volume'],
-                            'positive_count': sentiment['positive'],
-                            'negative_count': sentiment['negative'],
-                            'neutral_count': sentiment['neutral'],
-                            'engagement_rate': sentiment['engagement'],
-                            'influencer_sentiment': sentiment['influencer_sentiment'],
-                            'sentiment_velocity': self._calculate_sentiment_velocity(
-                                data_points, team, sentiment
-                            )
-                        })
-                
-            except Exception as e:
-                logger.error(f"Error collecting Twitter data at {current_time}: {e}")
-            
-            current_time += timedelta(minutes=interval_minutes)
-        
-        teams_key = f"{teams[0]}_vs_{teams[1]}"
-        self.sentiment_data[teams_key] = data_points
-        logger.info(f"Collected {len(data_points)} Twitter data points for {teams_key}")
-    
-    async def _get_twitter_sentiment(
-        self,
-        team: str,
-        timestamp: datetime
-    ) -> Optional[Dict[str, Any]]:
-        """Get Twitter sentiment for team at specific time"""
-        # Mock implementation
-        import random
-        
-        base_sentiment = random.gauss(0, 0.3)
-        base_sentiment = max(-1, min(1, base_sentiment))
-        
-        volume = random.randint(100, 5000)
-        positive = int(volume * (0.5 + base_sentiment / 2))
-        negative = int(volume * (0.5 - base_sentiment / 2))
-        neutral = volume - positive - negative
-        
-        return {
-            'score': base_sentiment,
-            'volume': volume,
-            'positive': positive,
-            'negative': negative,
-            'neutral': neutral,
-            'engagement': random.uniform(0.01, 0.1),
-            'influencer_sentiment': base_sentiment * 1.2
-        }
-    
-    def _calculate_price_change(
-        self,
-        history: List[Dict],
-        current: Dict
-    ) -> float:
-        """Calculate price change from previous data point"""
-        if not history:
-            return 0.0
-        
-        prev_price = history[-1].get('yes_price', 0.5)
-        curr_price = current.get('yes_price', 0.5)
-        
-        if prev_price == 0:
-            return 0.0
-        
-        return (curr_price - prev_price) / prev_price
-    
-    def _calculate_volume_ratio(
-        self,
-        history: List[Dict],
-        current: Dict
-    ) -> float:
-        """Calculate volume ratio vs average"""
-        if len(history) < 10:
-            return 1.0
-        
-        # Get last 10 volumes
-        recent_volumes = [h.get('volume', 0) for h in history[-10:]]
-        avg_volume = sum(recent_volumes) / len(recent_volumes) if recent_volumes else 1
-        
-        if avg_volume == 0:
-            return 1.0
-        
-        return current.get('volume', 0) / avg_volume
-    
-    def _calculate_sentiment_velocity(
-        self,
-        history: List[Dict],
-        team: str,
-        current: Dict
-    ) -> float:
-        """Calculate rate of sentiment change"""
-        team_history = [h for h in history if h.get('team') == team]
-        
-        if not team_history:
-            return 0.0
-        
-        prev_sentiment = team_history[-1].get('sentiment_score', 0)
-        curr_sentiment = current.get('score', 0)
-        
-        return curr_sentiment - prev_sentiment
-    
-    def _extract_game_info(self, market_ticker: str) -> Optional[Dict[str, Any]]:
-        """Extract game information from market ticker"""
-        # Example: "NFL-CHIEFS-BILLS-20240115"
-        parts = market_ticker.split('-')
-        
-        if len(parts) >= 4:
-            return {
-                'sport': parts[0],
-                'teams': (parts[1], parts[2]),
-                'game_id': parts[3] if len(parts) > 3 else 'unknown'
-            }
-        
-        return None
-    
-    async def _save_market_data(self, market_ticker: str):
-        """Save collected data to CSV files"""
-        # Save market data
-        if market_ticker in self.market_data:
-            df = pd.DataFrame(self.market_data[market_ticker])
-            output_file = self.output_dir / f"{market_ticker}_historical.csv"
-            df.to_csv(output_file, index=False)
-            logger.info(f"Saved market data to {output_file}")
-        
-        # Save game data
-        game_info = self._extract_game_info(market_ticker)
-        if game_info and game_info['game_id'] in self.game_data:
-            df = pd.DataFrame(self.game_data[game_info['game_id']])
-            output_file = self.output_dir / f"{game_info['game_id']}_game.csv"
-            df.to_csv(output_file, index=False)
-            logger.info(f"Saved game data to {output_file}")
-        
-        # Save sentiment data
-        if game_info:
-            teams_key = f"{game_info['teams'][0]}_vs_{game_info['teams'][1]}"
-            if teams_key in self.sentiment_data:
-                df = pd.DataFrame(self.sentiment_data[teams_key])
-                output_file = self.output_dir / f"{teams_key}_sentiment.csv"
-                df.to_csv(output_file, index=False)
-                logger.info(f"Saved sentiment data to {output_file}")
-    
-    async def load_or_collect(
-        self,
-        market_ticker: str,
-        start_date: datetime,
-        end_date: datetime,
-        force_refresh: bool = False
-    ) -> pd.DataFrame:
-        """
-        Load existing data or collect new data
-        
-        Args:
-            market_ticker: Market to load/collect
-            start_date: Start date
-            end_date: End date
-            force_refresh: Force new collection even if data exists
-            
-        Returns:
-            DataFrame with historical data
-        """
-        output_file = self.output_dir / f"{market_ticker}_historical.csv"
-        
-        if output_file.exists() and not force_refresh:
-            logger.info(f"Loading existing data from {output_file}")
-            return pd.read_csv(output_file, parse_dates=['timestamp'])
-        
-        # Collect new data
-        await self.collect_historical_data(
-            start_date=start_date,
-            end_date=end_date,
-            markets=[market_ticker],
-            interval_minutes=5
-        )
-        
-        if output_file.exists():
-            return pd.read_csv(output_file, parse_dates=['timestamp'])
-        
-        return pd.DataFrame()
-
-
-# Example usage
-async def main():
-    """Example data collection"""
-    collector = HistoricalDataCollector()
-    
-    # Collect historical data
-    await collector.collect_historical_data(
-        start_date=datetime(2024, 1, 1),
-        end_date=datetime(2024, 1, 31),
-        markets=[
-            "NFL-CHIEFS-BILLS-20240115",
-            "NFL-RAVENS-TEXANS-20240120"
-        ],
-        interval_minutes=5
-    )
-    
-    logger.info("Historical data collection complete")
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
\ No newline at end of file
diff --git a/src/backtesting/parameter_optimizer.py b/src/backtesting/parameter_optimizer.py
deleted file mode 100644
index 38dce339..00000000
--- a/src/backtesting/parameter_optimizer.py
+++ /dev/null
@@ -1,603 +0,0 @@
-"""
-Parameter Optimizer for Strategy Optimization
-Uses grid search and genetic algorithms to find optimal parameters
-"""
-
-import asyncio
-import logging
-from typing import Dict, Any, List, Tuple, Optional
-from datetime import datetime
-import numpy as np
-import pandas as pd
-from dataclasses import dataclass
-import json
-import itertools
-from pathlib import Path
-
-from src.backtesting.backtest_engine import BacktestEngine, StrategyParameters, BacktestResults
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class OptimizationResult:
-    """Results from parameter optimization"""
-    best_params: StrategyParameters
-    best_performance: BacktestResults
-    all_results: List[Tuple[StrategyParameters, BacktestResults]]
-    optimization_time: float
-    parameter_importance: Dict[str, float]
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for saving"""
-        return {
-            'best_params': self.best_params.to_dict(),
-            'best_metrics': {
-                'total_return': self.best_performance.total_return,
-                'sharpe_ratio': self.best_performance.sharpe_ratio,
-                'win_rate': self.best_performance.win_rate,
-                'max_drawdown': self.best_performance.max_drawdown,
-                'profit_factor': self.best_performance.profit_factor
-            },
-            'optimization_time': self.optimization_time,
-            'parameter_importance': self.parameter_importance,
-            'total_combinations_tested': len(self.all_results)
-        }
-
-
-class ParameterOptimizer:
-    """
-    Optimizer for finding best strategy parameters
-    
-    Optimization methods:
-    - Grid search: Test all combinations
-    - Random search: Test random samples
-    - Genetic algorithm: Evolve parameters
-    - Bayesian optimization: Smart sampling
-    """
-    
-    def __init__(
-        self,
-        backtest_engine: BacktestEngine,
-        objective_metric: str = "sharpe_ratio"
-    ):
-        self.engine = backtest_engine
-        self.objective_metric = objective_metric
-        self.results_cache: Dict[str, BacktestResults] = {}
-    
-    async def grid_search(
-        self,
-        param_grid: Dict[str, List[Any]],
-        start_date: datetime,
-        end_date: datetime,
-        markets: List[str],
-        max_combinations: int = 100
-    ) -> OptimizationResult:
-        """
-        Grid search optimization
-        
-        Args:
-            param_grid: Dictionary of parameter names and values to test
-            start_date: Backtest start date
-            end_date: Backtest end date
-            markets: Markets to trade
-            max_combinations: Maximum combinations to test
-            
-        Returns:
-            OptimizationResult with best parameters
-        """
-        import time
-        start_time = time.time()
-        
-        logger.info("Starting grid search optimization")
-        
-        # Generate all parameter combinations
-        param_names = list(param_grid.keys())
-        param_values = list(param_grid.values())
-        combinations = list(itertools.product(*param_values))
-        
-        # Limit combinations if too many
-        if len(combinations) > max_combinations:
-            logger.warning(f"Limiting from {len(combinations)} to {max_combinations} combinations")
-            import random
-            combinations = random.sample(combinations, max_combinations)
-        
-        logger.info(f"Testing {len(combinations)} parameter combinations")
-        
-        # Test each combination
-        all_results = []
-        best_result = None
-        best_params = None
-        best_score = -float('inf')
-        
-        for i, combo in enumerate(combinations):
-            # Create parameter set
-            params_dict = dict(zip(param_names, combo))
-            params = self._create_params_from_dict(params_dict)
-            
-            # Run backtest
-            logger.info(f"Testing combination {i+1}/{len(combinations)}: {params_dict}")
-            
-            try:
-                result = await self.engine.run_backtest(
-                    strategy_params=params,
-                    start_date=start_date,
-                    end_date=end_date,
-                    markets=markets
-                )
-                
-                # Get objective score
-                score = self._get_objective_score(result)
-                
-                all_results.append((params, result))
-                
-                # Track best
-                if score > best_score:
-                    best_score = score
-                    best_params = params
-                    best_result = result
-                    logger.info(f"New best score: {score:.4f}")
-                
-            except Exception as e:
-                logger.error(f"Error testing combination {params_dict}: {e}")
-        
-        # Calculate parameter importance
-        parameter_importance = self._calculate_parameter_importance(
-            all_results, param_names
-        )
-        
-        optimization_time = time.time() - start_time
-        
-        return OptimizationResult(
-            best_params=best_params,
-            best_performance=best_result,
-            all_results=all_results,
-            optimization_time=optimization_time,
-            parameter_importance=parameter_importance
-        )
-    
-    async def random_search(
-        self,
-        param_distributions: Dict[str, Tuple[float, float]],
-        n_iterations: int = 50,
-        start_date: datetime = None,
-        end_date: datetime = None,
-        markets: List[str] = None
-    ) -> OptimizationResult:
-        """
-        Random search optimization
-        
-        Args:
-            param_distributions: Parameter ranges (min, max)
-            n_iterations: Number of random samples
-            start_date: Backtest start date
-            end_date: Backtest end date
-            markets: Markets to trade
-            
-        Returns:
-            OptimizationResult with best parameters
-        """
-        import time
-        start_time = time.time()
-        
-        logger.info(f"Starting random search with {n_iterations} iterations")
-        
-        all_results = []
-        best_result = None
-        best_params = None
-        best_score = -float('inf')
-        
-        for i in range(n_iterations):
-            # Sample random parameters
-            params_dict = {}
-            for param_name, (min_val, max_val) in param_distributions.items():
-                if isinstance(min_val, int):
-                    value = np.random.randint(min_val, max_val + 1)
-                else:
-                    value = np.random.uniform(min_val, max_val)
-                params_dict[param_name] = value
-            
-            params = self._create_params_from_dict(params_dict)
-            
-            logger.info(f"Iteration {i+1}/{n_iterations}: Testing {params_dict}")
-            
-            try:
-                result = await self.engine.run_backtest(
-                    strategy_params=params,
-                    start_date=start_date,
-                    end_date=end_date,
-                    markets=markets
-                )
-                
-                score = self._get_objective_score(result)
-                all_results.append((params, result))
-                
-                if score > best_score:
-                    best_score = score
-                    best_params = params
-                    best_result = result
-                    logger.info(f"New best score: {score:.4f}")
-                
-            except Exception as e:
-                logger.error(f"Error in iteration {i+1}: {e}")
-        
-        parameter_importance = self._calculate_parameter_importance(
-            all_results, list(param_distributions.keys())
-        )
-        
-        optimization_time = time.time() - start_time
-        
-        return OptimizationResult(
-            best_params=best_params,
-            best_performance=best_result,
-            all_results=all_results,
-            optimization_time=optimization_time,
-            parameter_importance=parameter_importance
-        )
-    
-    async def genetic_algorithm(
-        self,
-        param_ranges: Dict[str, Tuple[float, float]],
-        population_size: int = 20,
-        generations: int = 10,
-        mutation_rate: float = 0.1,
-        crossover_rate: float = 0.7,
-        start_date: datetime = None,
-        end_date: datetime = None,
-        markets: List[str] = None
-    ) -> OptimizationResult:
-        """
-        Genetic algorithm optimization
-        
-        Args:
-            param_ranges: Parameter ranges (min, max)
-            population_size: Size of each generation
-            generations: Number of generations to evolve
-            mutation_rate: Probability of mutation
-            crossover_rate: Probability of crossover
-            start_date: Backtest start date
-            end_date: Backtest end date
-            markets: Markets to trade
-            
-        Returns:
-            OptimizationResult with best parameters
-        """
-        import time
-        start_time = time.time()
-        
-        logger.info(f"Starting genetic algorithm: {generations} generations, population {population_size}")
-        
-        all_results = []
-        
-        # Initialize population
-        population = []
-        for _ in range(population_size):
-            params_dict = {}
-            for param_name, (min_val, max_val) in param_ranges.items():
-                if isinstance(min_val, int):
-                    value = np.random.randint(min_val, max_val + 1)
-                else:
-                    value = np.random.uniform(min_val, max_val)
-                params_dict[param_name] = value
-            population.append(params_dict)
-        
-        best_overall_params = None
-        best_overall_result = None
-        best_overall_score = -float('inf')
-        
-        # Evolution loop
-        for gen in range(generations):
-            logger.info(f"Generation {gen+1}/{generations}")
-            
-            # Evaluate fitness
-            fitness_scores = []
-            gen_results = []
-            
-            for individual in population:
-                params = self._create_params_from_dict(individual)
-                
-                try:
-                    result = await self.engine.run_backtest(
-                        strategy_params=params,
-                        start_date=start_date,
-                        end_date=end_date,
-                        markets=markets
-                    )
-                    
-                    score = self._get_objective_score(result)
-                    fitness_scores.append(score)
-                    gen_results.append((params, result))
-                    all_results.append((params, result))
-                    
-                    if score > best_overall_score:
-                        best_overall_score = score
-                        best_overall_params = params
-                        best_overall_result = result
-                        logger.info(f"New best in generation {gen+1}: {score:.4f}")
-                    
-                except Exception as e:
-                    logger.error(f"Error evaluating individual: {e}")
-                    fitness_scores.append(-float('inf'))
-            
-            # Selection (tournament selection)
-            new_population = []
-            for _ in range(population_size):
-                # Tournament of 3
-                tournament_indices = np.random.choice(len(population), 3, replace=False)
-                tournament_fitness = [fitness_scores[i] for i in tournament_indices]
-                winner_idx = tournament_indices[np.argmax(tournament_fitness)]
-                new_population.append(population[winner_idx].copy())
-            
-            # Crossover
-            for i in range(0, population_size - 1, 2):
-                if np.random.random() < crossover_rate:
-                    # Single-point crossover
-                    crossover_point = np.random.randint(1, len(param_ranges))
-                    param_names = list(param_ranges.keys())
-                    
-                    for j in range(crossover_point):
-                        param_name = param_names[j]
-                        temp = new_population[i][param_name]
-                        new_population[i][param_name] = new_population[i+1][param_name]
-                        new_population[i+1][param_name] = temp
-            
-            # Mutation
-            for individual in new_population:
-                for param_name, (min_val, max_val) in param_ranges.items():
-                    if np.random.random() < mutation_rate:
-                        if isinstance(min_val, int):
-                            individual[param_name] = np.random.randint(min_val, max_val + 1)
-                        else:
-                            # Gaussian mutation
-                            current = individual[param_name]
-                            mutation = np.random.normal(0, (max_val - min_val) * 0.1)
-                            individual[param_name] = np.clip(
-                                current + mutation, min_val, max_val
-                            )
-            
-            population = new_population
-        
-        parameter_importance = self._calculate_parameter_importance(
-            all_results, list(param_ranges.keys())
-        )
-        
-        optimization_time = time.time() - start_time
-        
-        return OptimizationResult(
-            best_params=best_overall_params,
-            best_performance=best_overall_result,
-            all_results=all_results,
-            optimization_time=optimization_time,
-            parameter_importance=parameter_importance
-        )
-    
-    def _create_params_from_dict(self, params_dict: Dict[str, Any]) -> StrategyParameters:
-        """Create StrategyParameters from dictionary"""
-        base_params = StrategyParameters()
-        
-        for key, value in params_dict.items():
-            if hasattr(base_params, key):
-                setattr(base_params, key, value)
-        
-        return base_params
-    
-    def _get_objective_score(self, result: BacktestResults) -> float:
-        """Get objective score from backtest result"""
-        if self.objective_metric == "sharpe_ratio":
-            return result.sharpe_ratio
-        elif self.objective_metric == "total_return":
-            return result.total_return
-        elif self.objective_metric == "profit_factor":
-            return result.profit_factor
-        elif self.objective_metric == "calmar_ratio":
-            # Return / Max Drawdown
-            if result.max_drawdown > 0:
-                return result.total_return / result.max_drawdown
-            return result.total_return
-        elif self.objective_metric == "sortino_ratio":
-            # Similar to Sharpe but only considers downside deviation
-            if result.daily_returns:
-                returns = np.array(result.daily_returns)
-                downside_returns = returns[returns < 0]
-                if len(downside_returns) > 0:
-                    downside_std = np.std(downside_returns)
-                    if downside_std > 0:
-                        return np.mean(returns) / downside_std * np.sqrt(252)
-            return 0
-        else:
-            return result.total_return
-    
-    def _calculate_parameter_importance(
-        self,
-        all_results: List[Tuple[StrategyParameters, BacktestResults]],
-        param_names: List[str]
-    ) -> Dict[str, float]:
-        """Calculate importance of each parameter"""
-        if len(all_results) < 10:
-            return {name: 0.0 for name in param_names}
-        
-        # Extract scores and parameter values
-        scores = []
-        param_values = {name: [] for name in param_names}
-        
-        for params, result in all_results:
-            scores.append(self._get_objective_score(result))
-            for name in param_names:
-                if hasattr(params, name):
-                    param_values[name].append(getattr(params, name))
-        
-        # Calculate correlation between each parameter and score
-        importance = {}
-        scores_array = np.array(scores)
-        
-        for name in param_names:
-            if name in param_values and param_values[name]:
-                values = np.array(param_values[name])
-                
-                # Handle categorical or constant values
-                if len(np.unique(values)) == 1:
-                    importance[name] = 0.0
-                else:
-                    # Calculate correlation
-                    correlation = np.corrcoef(values, scores_array)[0, 1]
-                    importance[name] = abs(correlation) if not np.isnan(correlation) else 0.0
-            else:
-                importance[name] = 0.0
-        
-        # Normalize importance scores
-        total_importance = sum(importance.values())
-        if total_importance > 0:
-            importance = {k: v / total_importance for k, v in importance.items()}
-        
-        return importance
-    
-    async def walk_forward_optimization(
-        self,
-        param_ranges: Dict[str, Tuple[float, float]],
-        start_date: datetime,
-        end_date: datetime,
-        markets: List[str],
-        window_months: int = 3,
-        step_months: int = 1
-    ) -> List[OptimizationResult]:
-        """
-        Walk-forward optimization for robust parameter selection
-        
-        Args:
-            param_ranges: Parameter ranges to optimize
-            start_date: Overall start date
-            end_date: Overall end date
-            markets: Markets to trade
-            window_months: Training window size
-            step_months: Step size for moving window
-            
-        Returns:
-            List of optimization results for each window
-        """
-        from dateutil.relativedelta import relativedelta
-        
-        results = []
-        current_start = start_date
-        
-        while current_start + relativedelta(months=window_months) <= end_date:
-            train_end = current_start + relativedelta(months=window_months)
-            test_start = train_end
-            test_end = min(test_start + relativedelta(months=step_months), end_date)
-            
-            logger.info(f"Walk-forward window: Train {current_start} to {train_end}, Test {test_start} to {test_end}")
-            
-            # Optimize on training period
-            opt_result = await self.random_search(
-                param_distributions=param_ranges,
-                n_iterations=20,
-                start_date=current_start,
-                end_date=train_end,
-                markets=markets
-            )
-            
-            # Test on out-of-sample period
-            test_result = await self.engine.run_backtest(
-                strategy_params=opt_result.best_params,
-                start_date=test_start,
-                end_date=test_end,
-                markets=markets
-            )
-            
-            logger.info(f"Out-of-sample return: {test_result.total_return:.1%}")
-            
-            results.append(opt_result)
-            current_start += relativedelta(months=step_months)
-        
-        return results
-    
-    def save_results(self, result: OptimizationResult, filename: str):
-        """Save optimization results to file"""
-        output_path = Path(f"backtesting/optimization_results/{filename}")
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        with open(output_path, 'w') as f:
-            json.dump(result.to_dict(), f, indent=2)
-        
-        logger.info(f"Saved optimization results to {output_path}")
-    
-    def analyze_sensitivity(
-        self,
-        base_params: StrategyParameters,
-        param_name: str,
-        param_range: Tuple[float, float],
-        n_points: int = 10
-    ) -> pd.DataFrame:
-        """
-        Analyze sensitivity of results to a single parameter
-        
-        Args:
-            base_params: Base parameters
-            param_name: Parameter to vary
-            param_range: Range to test
-            n_points: Number of points to test
-            
-        Returns:
-            DataFrame with sensitivity analysis
-        """
-        results = []
-        
-        min_val, max_val = param_range
-        if isinstance(min_val, int):
-            values = np.linspace(min_val, max_val, n_points, dtype=int)
-        else:
-            values = np.linspace(min_val, max_val, n_points)
-        
-        for value in values:
-            params = base_params
-            setattr(params, param_name, value)
-            
-            # Run backtest (would be async in practice)
-            # result = await self.engine.run_backtest(params, ...)
-            
-            results.append({
-                param_name: value,
-                # 'return': result.total_return,
-                # 'sharpe': result.sharpe_ratio,
-                # 'max_dd': result.max_drawdown
-            })
-        
-        return pd.DataFrame(results)
-
-
-# Example usage
-async def main():
-    """Example optimization run"""
-    
-    # Initialize components
-    engine = BacktestEngine(initial_capital=10000)
-    optimizer = ParameterOptimizer(engine, objective_metric="sharpe_ratio")
-    
-    # Define parameter grid
-    param_grid = {
-        'kelly_multiplier': [0.1, 0.25, 0.5],
-        'stop_loss_pct': [0.05, 0.10, 0.15],
-        'take_profit_pct': [0.20, 0.30, 0.40],
-        'min_confidence': [0.60, 0.70, 0.80]
-    }
-    
-    # Run grid search
-    result = await optimizer.grid_search(
-        param_grid=param_grid,
-        start_date=datetime(2024, 1, 1),
-        end_date=datetime(2024, 12, 31),
-        markets=["NFL-CHIEFS-WIN"],
-        max_combinations=50
-    )
-    
-    # Display results
-    print(f"Best parameters: {result.best_params.to_dict()}")
-    print(f"Best Sharpe ratio: {result.best_performance.sharpe_ratio:.2f}")
-    print(f"Parameter importance: {result.parameter_importance}")
-    
-    # Save results
-    optimizer.save_results(result, "optimization_2024.json")
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
\ No newline at end of file
diff --git a/src/backtesting/performance_analyzer.py b/src/backtesting/performance_analyzer.py
deleted file mode 100644
index a1ead8d2..00000000
--- a/src/backtesting/performance_analyzer.py
+++ /dev/null
@@ -1,621 +0,0 @@
-"""
-Performance Analyzer for Backtesting Results
-Provides detailed analytics and visualizations
-"""
-
-import logging
-from typing import Dict, Any, List, Optional, Tuple
-from datetime import datetime, timedelta
-import numpy as np
-import pandas as pd
-from dataclasses import dataclass
-import json
-from pathlib import Path
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-from src.backtesting.backtest_engine import BacktestResults, BacktestTrade
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class PerformanceMetrics:
-    """Comprehensive performance metrics"""
-    # Returns
-    total_return: float
-    annualized_return: float
-    monthly_returns: List[float]
-    
-    # Risk metrics
-    volatility: float
-    downside_deviation: float
-    max_drawdown: float
-    max_drawdown_duration: int
-    var_95: float  # Value at Risk 95%
-    cvar_95: float  # Conditional VaR 95%
-    
-    # Risk-adjusted returns
-    sharpe_ratio: float
-    sortino_ratio: float
-    calmar_ratio: float
-    information_ratio: float
-    
-    # Trade statistics
-    total_trades: int
-    winning_trades: int
-    losing_trades: int
-    win_rate: float
-    avg_win: float
-    avg_loss: float
-    avg_trade: float
-    profit_factor: float
-    expectancy: float
-    
-    # Trade distribution
-    largest_win: float
-    largest_loss: float
-    consecutive_wins: int
-    consecutive_losses: int
-    avg_holding_period: float
-    
-    # Kelly metrics
-    kelly_criterion: float
-    optimal_f: float
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary"""
-        return {
-            'returns': {
-                'total_return': f"{self.total_return:.2%}",
-                'annualized_return': f"{self.annualized_return:.2%}",
-                'monthly_avg': f"{np.mean(self.monthly_returns):.2%}"
-            },
-            'risk': {
-                'volatility': f"{self.volatility:.2%}",
-                'max_drawdown': f"{self.max_drawdown:.2%}",
-                'var_95': f"{self.var_95:.2%}",
-                'cvar_95': f"{self.cvar_95:.2%}"
-            },
-            'risk_adjusted': {
-                'sharpe_ratio': f"{self.sharpe_ratio:.2f}",
-                'sortino_ratio': f"{self.sortino_ratio:.2f}",
-                'calmar_ratio': f"{self.calmar_ratio:.2f}"
-            },
-            'trades': {
-                'total': self.total_trades,
-                'win_rate': f"{self.win_rate:.1%}",
-                'profit_factor': f"{self.profit_factor:.2f}",
-                'expectancy': f"${self.expectancy:.2f}",
-                'avg_holding_period': f"{self.avg_holding_period:.1f} hours"
-            }
-        }
-
-
-class PerformanceAnalyzer:
-    """
-    Analyzes backtest performance with detailed metrics
-    """
-    
-    def __init__(self, results_dir: str = "backtesting/results"):
-        self.results_dir = Path(results_dir)
-        self.results_dir.mkdir(parents=True, exist_ok=True)
-    
-    def analyze(self, backtest_results: BacktestResults) -> PerformanceMetrics:
-        """
-        Calculate comprehensive performance metrics
-        
-        Args:
-            backtest_results: Results from backtest
-            
-        Returns:
-            PerformanceMetrics with all calculations
-        """
-        # Calculate returns metrics
-        total_return = backtest_results.total_return
-        days = (backtest_results.end_date - backtest_results.start_date).days
-        annualized_return = (1 + total_return) ** (365 / max(days, 1)) - 1
-        
-        # Monthly returns
-        monthly_returns = self._calculate_monthly_returns(
-            backtest_results.equity_curve,
-            backtest_results.start_date
-        )
-        
-        # Risk metrics
-        daily_returns = np.array(backtest_results.daily_returns)
-        volatility = np.std(daily_returns) * np.sqrt(252) if len(daily_returns) > 1 else 0
-        
-        downside_returns = daily_returns[daily_returns < 0]
-        downside_deviation = np.std(downside_returns) * np.sqrt(252) if len(downside_returns) > 0 else 0
-        
-        max_dd, max_dd_duration = self._calculate_max_drawdown_details(
-            backtest_results.equity_curve
-        )
-        
-        var_95 = np.percentile(daily_returns, 5) if len(daily_returns) > 0 else 0
-        cvar_95 = np.mean(daily_returns[daily_returns <= var_95]) if len(daily_returns[daily_returns <= var_95]) > 0 else var_95
-        
-        # Risk-adjusted returns
-        risk_free_rate = 0  # Assuming 0% risk-free rate
-        excess_returns = daily_returns - risk_free_rate / 252
-        
-        sharpe = np.mean(excess_returns) / np.std(excess_returns) * np.sqrt(252) if np.std(excess_returns) > 0 else 0
-        
-        sortino = np.mean(excess_returns) / downside_deviation * np.sqrt(252) if downside_deviation > 0 else 0
-        
-        calmar = annualized_return / max_dd if max_dd > 0 else annualized_return
-        
-        information_ratio = sharpe  # Simplified (would need benchmark)
-        
-        # Trade statistics
-        trades = backtest_results.trades
-        winning_trades = [t for t in trades if t.pnl > 0]
-        losing_trades = [t for t in trades if t.pnl < 0]
-        
-        win_rate = len(winning_trades) / len(trades) if trades else 0
-        avg_win = np.mean([t.pnl for t in winning_trades]) if winning_trades else 0
-        avg_loss = np.mean([t.pnl for t in losing_trades]) if losing_trades else 0
-        avg_trade = np.mean([t.pnl for t in trades]) if trades else 0
-        
-        total_wins = sum(t.pnl for t in winning_trades)
-        total_losses = abs(sum(t.pnl for t in losing_trades))
-        profit_factor = total_wins / total_losses if total_losses > 0 else float('inf')
-        
-        expectancy = win_rate * avg_win + (1 - win_rate) * avg_loss
-        
-        # Trade distribution
-        largest_win = max([t.pnl for t in trades], default=0)
-        largest_loss = min([t.pnl for t in trades], default=0)
-        
-        consecutive_wins = self._max_consecutive(trades, True)
-        consecutive_losses = self._max_consecutive(trades, False)
-        
-        holding_periods = []
-        for trade in trades:
-            if trade.exit_timestamp:
-                period = (trade.exit_timestamp - trade.timestamp).total_seconds() / 3600
-                holding_periods.append(period)
-        
-        avg_holding_period = np.mean(holding_periods) if holding_periods else 0
-        
-        # Kelly metrics
-        if winning_trades and losing_trades:
-            avg_win_ratio = avg_win / abs(avg_loss)
-            kelly = (win_rate * avg_win_ratio - (1 - win_rate)) / avg_win_ratio
-            kelly = max(0, min(kelly, 1))  # Limit to [0, 1]
-        else:
-            kelly = 0
-        
-        optimal_f = kelly * 0.25  # Conservative Kelly
-        
-        return PerformanceMetrics(
-            total_return=total_return,
-            annualized_return=annualized_return,
-            monthly_returns=monthly_returns,
-            volatility=volatility,
-            downside_deviation=downside_deviation,
-            max_drawdown=max_dd,
-            max_drawdown_duration=max_dd_duration,
-            var_95=var_95,
-            cvar_95=cvar_95,
-            sharpe_ratio=sharpe,
-            sortino_ratio=sortino,
-            calmar_ratio=calmar,
-            information_ratio=information_ratio,
-            total_trades=len(trades),
-            winning_trades=len(winning_trades),
-            losing_trades=len(losing_trades),
-            win_rate=win_rate,
-            avg_win=avg_win,
-            avg_loss=avg_loss,
-            avg_trade=avg_trade,
-            profit_factor=profit_factor,
-            expectancy=expectancy,
-            largest_win=largest_win,
-            largest_loss=largest_loss,
-            consecutive_wins=consecutive_wins,
-            consecutive_losses=consecutive_losses,
-            avg_holding_period=avg_holding_period,
-            kelly_criterion=kelly,
-            optimal_f=optimal_f
-        )
-    
-    def _calculate_monthly_returns(
-        self,
-        equity_curve: List[float],
-        start_date: datetime
-    ) -> List[float]:
-        """Calculate monthly returns from equity curve"""
-        if len(equity_curve) < 30:
-            return []
-        
-        monthly_returns = []
-        month_start_value = equity_curve[0]
-        days_in_month = 0
-        current_month = start_date.month
-        
-        for i, value in enumerate(equity_curve):
-            date = start_date + timedelta(days=i)
-            
-            if date.month != current_month:
-                # Month ended
-                if days_in_month > 0:
-                    month_return = (value - month_start_value) / month_start_value
-                    monthly_returns.append(month_return)
-                
-                month_start_value = value
-                current_month = date.month
-                days_in_month = 0
-            else:
-                days_in_month += 1
-        
-        return monthly_returns
-    
-    def _calculate_max_drawdown_details(
-        self,
-        equity_curve: List[float]
-    ) -> Tuple[float, int]:
-        """Calculate maximum drawdown and duration"""
-        if not equity_curve:
-            return 0, 0
-        
-        peak = equity_curve[0]
-        max_dd = 0
-        max_dd_duration = 0
-        current_dd_start = 0
-        
-        for i, value in enumerate(equity_curve):
-            if value > peak:
-                peak = value
-                current_dd_start = i
-            
-            dd = (peak - value) / peak
-            if dd > max_dd:
-                max_dd = dd
-                max_dd_duration = i - current_dd_start
-        
-        return max_dd, max_dd_duration
-    
-    def _max_consecutive(self, trades: List[BacktestTrade], wins: bool) -> int:
-        """Calculate maximum consecutive wins or losses"""
-        if not trades:
-            return 0
-        
-        max_streak = 0
-        current_streak = 0
-        
-        for trade in trades:
-            if (wins and trade.pnl > 0) or (not wins and trade.pnl < 0):
-                current_streak += 1
-                max_streak = max(max_streak, current_streak)
-            else:
-                current_streak = 0
-        
-        return max_streak
-    
-    def create_report(
-        self,
-        backtest_results: BacktestResults,
-        metrics: PerformanceMetrics,
-        filename: str = "performance_report.html"
-    ):
-        """
-        Create HTML performance report
-        
-        Args:
-            backtest_results: Backtest results
-            metrics: Calculated metrics
-            filename: Output filename
-        """
-        html_content = f"""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>Backtest Performance Report</title>
-            <style>
-                body {{ font-family: Arial, sans-serif; margin: 20px; }}
-                h1 {{ color: #333; }}
-                .metric-grid {{ display: grid; grid-template-columns: repeat(3, 1fr); gap: 20px; }}
-                .metric-card {{ background: #f5f5f5; padding: 15px; border-radius: 5px; }}
-                .metric-title {{ font-weight: bold; color: #666; }}
-                .metric-value {{ font-size: 24px; color: #333; margin-top: 5px; }}
-                .positive {{ color: green; }}
-                .negative {{ color: red; }}
-                table {{ width: 100%; border-collapse: collapse; margin-top: 20px; }}
-                th, td {{ padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }}
-                th {{ background-color: #f2f2f2; }}
-            </style>
-        </head>
-        <body>
-            <h1>Backtest Performance Report</h1>
-            
-            <h2>Key Metrics</h2>
-            <div class="metric-grid">
-                <div class="metric-card">
-                    <div class="metric-title">Total Return</div>
-                    <div class="metric-value {'positive' if metrics.total_return > 0 else 'negative'}">
-                        {metrics.total_return:.2%}
-                    </div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-title">Sharpe Ratio</div>
-                    <div class="metric-value">{metrics.sharpe_ratio:.2f}</div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-title">Win Rate</div>
-                    <div class="metric-value">{metrics.win_rate:.1%}</div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-title">Max Drawdown</div>
-                    <div class="metric-value negative">{metrics.max_drawdown:.1%}</div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-title">Profit Factor</div>
-                    <div class="metric-value">{metrics.profit_factor:.2f}</div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-title">Total Trades</div>
-                    <div class="metric-value">{metrics.total_trades}</div>
-                </div>
-            </div>
-            
-            <h2>Detailed Statistics</h2>
-            <table>
-                <tr><th>Metric</th><th>Value</th></tr>
-                <tr><td>Annualized Return</td><td>{metrics.annualized_return:.2%}</td></tr>
-                <tr><td>Volatility</td><td>{metrics.volatility:.2%}</td></tr>
-                <tr><td>Sortino Ratio</td><td>{metrics.sortino_ratio:.2f}</td></tr>
-                <tr><td>Calmar Ratio</td><td>{metrics.calmar_ratio:.2f}</td></tr>
-                <tr><td>Average Win</td><td>${metrics.avg_win:.2f}</td></tr>
-                <tr><td>Average Loss</td><td>${metrics.avg_loss:.2f}</td></tr>
-                <tr><td>Expectancy</td><td>${metrics.expectancy:.2f}</td></tr>
-                <tr><td>Kelly Criterion</td><td>{metrics.kelly_criterion:.2%}</td></tr>
-                <tr><td>Avg Holding Period</td><td>{metrics.avg_holding_period:.1f} hours</td></tr>
-                <tr><td>Consecutive Wins</td><td>{metrics.consecutive_wins}</td></tr>
-                <tr><td>Consecutive Losses</td><td>{metrics.consecutive_losses}</td></tr>
-            </table>
-            
-            <h2>Trade Distribution</h2>
-            <table>
-                <tr>
-                    <th>Winning Trades</th>
-                    <th>Losing Trades</th>
-                    <th>Largest Win</th>
-                    <th>Largest Loss</th>
-                </tr>
-                <tr>
-                    <td>{metrics.winning_trades}</td>
-                    <td>{metrics.losing_trades}</td>
-                    <td class="positive">${metrics.largest_win:.2f}</td>
-                    <td class="negative">${metrics.largest_loss:.2f}</td>
-                </tr>
-            </table>
-            
-            <p><small>Report generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</small></p>
-        </body>
-        </html>
-        """
-        
-        output_path = self.results_dir / filename
-        with open(output_path, 'w') as f:
-            f.write(html_content)
-        
-        logger.info(f"Performance report saved to {output_path}")
-    
-    def plot_results(
-        self,
-        backtest_results: BacktestResults,
-        save_path: Optional[str] = None
-    ):
-        """
-        Create visualization plots
-        
-        Args:
-            backtest_results: Backtest results
-            save_path: Path to save plots
-        """
-        fig, axes = plt.subplots(2, 3, figsize=(15, 10))
-        
-        # Equity curve
-        ax = axes[0, 0]
-        ax.plot(backtest_results.equity_curve)
-        ax.set_title('Equity Curve')
-        ax.set_xlabel('Days')
-        ax.set_ylabel('Portfolio Value ($)')
-        ax.grid(True, alpha=0.3)
-        
-        # Daily returns distribution
-        ax = axes[0, 1]
-        if backtest_results.daily_returns:
-            ax.hist(backtest_results.daily_returns, bins=30, edgecolor='black')
-            ax.axvline(0, color='red', linestyle='--', alpha=0.5)
-        ax.set_title('Daily Returns Distribution')
-        ax.set_xlabel('Return')
-        ax.set_ylabel('Frequency')
-        ax.grid(True, alpha=0.3)
-        
-        # Drawdown
-        ax = axes[0, 2]
-        drawdowns = self._calculate_drawdowns(backtest_results.equity_curve)
-        ax.fill_between(range(len(drawdowns)), 0, drawdowns, color='red', alpha=0.3)
-        ax.set_title('Drawdown')
-        ax.set_xlabel('Days')
-        ax.set_ylabel('Drawdown %')
-        ax.grid(True, alpha=0.3)
-        
-        # Trade P&L distribution
-        ax = axes[1, 0]
-        if backtest_results.trades:
-            pnls = [t.pnl for t in backtest_results.trades]
-            ax.hist(pnls, bins=20, edgecolor='black')
-            ax.axvline(0, color='red', linestyle='--', alpha=0.5)
-        ax.set_title('Trade P&L Distribution')
-        ax.set_xlabel('P&L ($)')
-        ax.set_ylabel('Frequency')
-        ax.grid(True, alpha=0.3)
-        
-        # Win rate by month
-        ax = axes[1, 1]
-        monthly_win_rates = self._calculate_monthly_win_rates(backtest_results)
-        if monthly_win_rates:
-            ax.bar(range(len(monthly_win_rates)), monthly_win_rates)
-        ax.set_title('Monthly Win Rate')
-        ax.set_xlabel('Month')
-        ax.set_ylabel('Win Rate')
-        ax.set_ylim([0, 1])
-        ax.grid(True, alpha=0.3)
-        
-        # Rolling Sharpe ratio
-        ax = axes[1, 2]
-        if len(backtest_results.daily_returns) > 20:
-            rolling_sharpe = self._calculate_rolling_sharpe(
-                backtest_results.daily_returns, window=20
-            )
-            ax.plot(rolling_sharpe)
-            ax.axhline(0, color='red', linestyle='--', alpha=0.5)
-        ax.set_title('Rolling Sharpe Ratio (20-day)')
-        ax.set_xlabel('Days')
-        ax.set_ylabel('Sharpe Ratio')
-        ax.grid(True, alpha=0.3)
-        
-        plt.tight_layout()
-        
-        if save_path:
-            plt.savefig(save_path, dpi=100, bbox_inches='tight')
-            logger.info(f"Plots saved to {save_path}")
-        
-        plt.show()
-    
-    def _calculate_drawdowns(self, equity_curve: List[float]) -> List[float]:
-        """Calculate drawdown series"""
-        if not equity_curve:
-            return []
-        
-        drawdowns = []
-        peak = equity_curve[0]
-        
-        for value in equity_curve:
-            if value > peak:
-                peak = value
-            dd = (peak - value) / peak
-            drawdowns.append(-dd)  # Negative for display
-        
-        return drawdowns
-    
-    def _calculate_monthly_win_rates(
-        self,
-        backtest_results: BacktestResults
-    ) -> List[float]:
-        """Calculate win rate by month"""
-        if not backtest_results.trades:
-            return []
-        
-        monthly_trades = {}
-        
-        for trade in backtest_results.trades:
-            month_key = trade.timestamp.strftime('%Y-%m')
-            if month_key not in monthly_trades:
-                monthly_trades[month_key] = {'wins': 0, 'total': 0}
-            
-            monthly_trades[month_key]['total'] += 1
-            if trade.pnl > 0:
-                monthly_trades[month_key]['wins'] += 1
-        
-        win_rates = []
-        for month in sorted(monthly_trades.keys()):
-            stats = monthly_trades[month]
-            win_rate = stats['wins'] / stats['total'] if stats['total'] > 0 else 0
-            win_rates.append(win_rate)
-        
-        return win_rates
-    
-    def _calculate_rolling_sharpe(
-        self,
-        daily_returns: List[float],
-        window: int = 20
-    ) -> List[float]:
-        """Calculate rolling Sharpe ratio"""
-        returns = np.array(daily_returns)
-        rolling_sharpe = []
-        
-        for i in range(window, len(returns)):
-            window_returns = returns[i-window:i]
-            if np.std(window_returns) > 0:
-                sharpe = np.mean(window_returns) / np.std(window_returns) * np.sqrt(252)
-            else:
-                sharpe = 0
-            rolling_sharpe.append(sharpe)
-        
-        return rolling_sharpe
-    
-    def compare_strategies(
-        self,
-        results_list: List[Tuple[str, BacktestResults]],
-        save_path: Optional[str] = None
-    ):
-        """
-        Compare multiple strategy results
-        
-        Args:
-            results_list: List of (name, results) tuples
-            save_path: Path to save comparison
-        """
-        comparison_data = []
-        
-        for name, results in results_list:
-            metrics = self.analyze(results)
-            
-            comparison_data.append({
-                'Strategy': name,
-                'Total Return': f"{metrics.total_return:.2%}",
-                'Sharpe Ratio': f"{metrics.sharpe_ratio:.2f}",
-                'Max Drawdown': f"{metrics.max_drawdown:.2%}",
-                'Win Rate': f"{metrics.win_rate:.1%}",
-                'Profit Factor': f"{metrics.profit_factor:.2f}",
-                'Total Trades': metrics.total_trades
-            })
-        
-        df = pd.DataFrame(comparison_data)
-        
-        if save_path:
-            df.to_csv(save_path, index=False)
-            logger.info(f"Comparison saved to {save_path}")
-        
-        return df
-
-
-# Example usage
-async def main():
-    """Example performance analysis"""
-    from src.backtesting.backtest_engine import BacktestEngine, StrategyParameters
-    
-    # Run backtest
-    engine = BacktestEngine()
-    params = StrategyParameters()
-    
-    results = await engine.run_backtest(
-        strategy_params=params,
-        start_date=datetime(2024, 1, 1),
-        end_date=datetime(2024, 12, 31),
-        markets=["NFL-CHIEFS-WIN"]
-    )
-    
-    # Analyze performance
-    analyzer = PerformanceAnalyzer()
-    metrics = analyzer.analyze(results)
-    
-    # Display metrics
-    print(json.dumps(metrics.to_dict(), indent=2))
-    
-    # Create report
-    analyzer.create_report(results, metrics)
-    
-    # Create plots
-    analyzer.plot_results(results, save_path="backtesting/results/performance_plots.png")
-
-
-if __name__ == "__main__":
-    import asyncio
-    logging.basicConfig(level=logging.INFO)
-    asyncio.run(main())
\ No newline at end of file
diff --git a/src/confidence_calibration/__init__.py b/src/confidence_calibration/__init__.py
new file mode 100644
index 00000000..6190c528
--- /dev/null
+++ b/src/confidence_calibration/__init__.py
@@ -0,0 +1,38 @@
+"""
+Confidence Calibration Module
+
+Advanced confidence calibration and uncertainty quantification 
+for agent decision-making in trading scenarios.
+"""
+
+from .calibrator import (
+    ConfidenceCalibrator,
+    CalibrationMethod,
+    CalibrationMetrics,
+    ConfidenceScore,
+    UncertaintyQuantifier
+)
+from .bootstrap_estimator import (
+    BootstrapConfidenceEstimator,
+    BootstrapConfig,
+    ConfidenceInterval
+)
+# from .bayesian_calibrator import (
+#     BayesianCalibrator,
+#     PriorDistribution,
+#     BayesianUpdate
+# )
+
+__all__ = [
+    'ConfidenceCalibrator',
+    'CalibrationMethod',
+    'CalibrationMetrics', 
+    'ConfidenceScore',
+    'UncertaintyQuantifier',
+    'BootstrapConfidenceEstimator',
+    'BootstrapConfig',
+    'ConfidenceInterval'
+    # 'BayesianCalibrator',
+    # 'PriorDistribution',
+    # 'BayesianUpdate'
+]
\ No newline at end of file
diff --git a/src/confidence_calibration/bootstrap_estimator.py b/src/confidence_calibration/bootstrap_estimator.py
new file mode 100644
index 00000000..a0714873
--- /dev/null
+++ b/src/confidence_calibration/bootstrap_estimator.py
@@ -0,0 +1,820 @@
+"""
+Bootstrap Confidence Estimator
+
+Uses bootstrap sampling to estimate confidence intervals and
+uncertainty for agent decision-making scenarios.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Any, Callable
+import numpy as np
+import asyncio
+import logging
+from datetime import datetime
+from collections import defaultdict
+import random
+
+
+@dataclass
+class BootstrapConfig:
+    """Configuration for bootstrap estimation"""
+    n_bootstrap_samples: int = 1000
+    confidence_level: float = 0.95
+    sample_size_fraction: float = 1.0  # Fraction of original data to sample
+    random_seed: Optional[int] = None
+    parallel_execution: bool = True
+    max_workers: int = 4
+    
+    # Advanced options
+    bias_correction: bool = True
+    acceleration_correction: bool = True  # BCa intervals
+    minimum_sample_size: int = 30
+
+
+@dataclass 
+class ConfidenceInterval:
+    """Bootstrap confidence interval result"""
+    lower_bound: float
+    upper_bound: float
+    point_estimate: float
+    confidence_level: float
+    method: str  # "percentile", "bias_corrected", "bca"
+    n_bootstrap_samples: int
+    
+    @property
+    def width(self) -> float:
+        """Width of confidence interval"""
+        return self.upper_bound - self.lower_bound
+    
+    @property
+    def margin_of_error(self) -> float:
+        """Margin of error (half-width)"""
+        return self.width / 2
+
+
+class BootstrapConfidenceEstimator:
+    """
+    Bootstrap-based confidence estimation for agent decision metrics.
+    
+    Uses resampling techniques to estimate confidence intervals and
+    uncertainty quantification for various performance metrics.
+    """
+    
+    def __init__(self, config: BootstrapConfig = None):
+        self.config = config or BootstrapConfig()
+        self.logger = logging.getLogger(__name__)
+        
+        # Set random seed for reproducibility
+        if self.config.random_seed is not None:
+            np.random.seed(self.config.random_seed)
+            random.seed(self.config.random_seed)
+        
+        # Cache for bootstrap results
+        self.bootstrap_cache: Dict[str, Any] = {}
+        self.cache_timestamps: Dict[str, datetime] = {}
+        
+        # Performance tracking
+        self.estimation_history: List[Dict[str, Any]] = []
+    
+    async def estimate_win_rate_confidence(
+        self,
+        outcomes: List[bool],
+        agent_id: Optional[str] = None
+    ) -> ConfidenceInterval:
+        """
+        Estimate confidence interval for win rate using bootstrap.
+        
+        Args:
+            outcomes: List of decision outcomes (True for win, False for loss)
+            agent_id: Optional agent identifier for caching
+            
+        Returns:
+            Confidence interval for win rate
+        """
+        try:
+            if len(outcomes) < self.config.minimum_sample_size:
+                self.logger.warning(f"Sample size too small for bootstrap: {len(outcomes)}")
+                return self._create_wide_interval(np.mean(outcomes), "insufficient_data")
+            
+            # Check cache
+            cache_key = f"win_rate_{agent_id}_{hash(str(outcomes))}" if agent_id else f"win_rate_{hash(str(outcomes))}"
+            if cache_key in self.bootstrap_cache:
+                cached_result = self.bootstrap_cache[cache_key]
+                if datetime.now() - self.cache_timestamps[cache_key] < timedelta(minutes=30):
+                    return cached_result
+            
+            # Bootstrap function for win rate
+            def win_rate_statistic(sample):
+                return np.mean(sample)
+            
+            # Perform bootstrap
+            bootstrap_estimates = await self._bootstrap_statistic(
+                data=outcomes,
+                statistic_func=win_rate_statistic,
+                description="win_rate"
+            )
+            
+            # Calculate confidence interval
+            point_estimate = np.mean(outcomes)
+            interval = self._calculate_confidence_interval(
+                bootstrap_estimates, 
+                point_estimate,
+                outcomes  # Original data for BCa
+            )
+            
+            # Cache result
+            self.bootstrap_cache[cache_key] = interval
+            self.cache_timestamps[cache_key] = datetime.now()
+            
+            return interval
+            
+        except Exception as e:
+            self.logger.error(f"Win rate confidence estimation failed: {e}")
+            return self._create_wide_interval(np.mean(outcomes) if outcomes else 0.5, "error")
+    
+    async def estimate_kelly_adherence_confidence(
+        self,
+        kelly_deviations: List[float],
+        agent_id: Optional[str] = None
+    ) -> ConfidenceInterval:
+        """
+        Estimate confidence interval for Kelly Criterion adherence.
+        
+        Args:
+            kelly_deviations: List of Kelly fraction deviations
+            agent_id: Optional agent identifier for caching
+            
+        Returns:
+            Confidence interval for Kelly adherence score
+        """
+        try:
+            if len(kelly_deviations) < self.config.minimum_sample_size:
+                return self._create_wide_interval(0.5, "insufficient_data")
+            
+            # Kelly adherence score = 1 - average deviation
+            def kelly_adherence_statistic(sample):
+                avg_deviation = np.mean(np.abs(sample))
+                return max(0.0, 1.0 - avg_deviation)
+            
+            # Perform bootstrap
+            bootstrap_estimates = await self._bootstrap_statistic(
+                data=kelly_deviations,
+                statistic_func=kelly_adherence_statistic,
+                description="kelly_adherence"
+            )
+            
+            # Calculate point estimate
+            point_estimate = kelly_adherence_statistic(kelly_deviations)
+            
+            # Calculate confidence interval
+            interval = self._calculate_confidence_interval(
+                bootstrap_estimates,
+                point_estimate,
+                kelly_deviations
+            )
+            
+            return interval
+            
+        except Exception as e:
+            self.logger.error(f"Kelly adherence confidence estimation failed: {e}")
+            return self._create_wide_interval(0.5, "error")
+    
+    async def estimate_sharpe_ratio_confidence(
+        self,
+        returns: List[float],
+        agent_id: Optional[str] = None
+    ) -> ConfidenceInterval:
+        """
+        Estimate confidence interval for Sharpe ratio.
+        
+        Args:
+            returns: List of return values
+            agent_id: Optional agent identifier for caching
+            
+        Returns:
+            Confidence interval for Sharpe ratio
+        """
+        try:
+            if len(returns) < self.config.minimum_sample_size:
+                return self._create_wide_interval(0.0, "insufficient_data")
+            
+            def sharpe_ratio_statistic(sample):
+                if len(sample) < 2:
+                    return 0.0
+                mean_return = np.mean(sample)
+                std_return = np.std(sample, ddof=1)  # Sample standard deviation
+                return mean_return / std_return if std_return > 0 else 0.0
+            
+            # Perform bootstrap
+            bootstrap_estimates = await self._bootstrap_statistic(
+                data=returns,
+                statistic_func=sharpe_ratio_statistic,
+                description="sharpe_ratio"
+            )
+            
+            # Calculate point estimate
+            point_estimate = sharpe_ratio_statistic(returns)
+            
+            # Calculate confidence interval
+            interval = self._calculate_confidence_interval(
+                bootstrap_estimates,
+                point_estimate,
+                returns
+            )
+            
+            return interval
+            
+        except Exception as e:
+            self.logger.error(f"Sharpe ratio confidence estimation failed: {e}")
+            return self._create_wide_interval(0.0, "error")
+    
+    async def estimate_confidence_calibration_interval(
+        self,
+        confidences: List[float],
+        outcomes: List[bool],
+        agent_id: Optional[str] = None
+    ) -> ConfidenceInterval:
+        """
+        Estimate confidence interval for confidence calibration score.
+        
+        Args:
+            confidences: List of confidence scores
+            outcomes: List of corresponding outcomes
+            agent_id: Optional agent identifier for caching
+            
+        Returns:
+            Confidence interval for calibration score
+        """
+        try:
+            if len(confidences) != len(outcomes) or len(confidences) < self.config.minimum_sample_size:
+                return self._create_wide_interval(0.5, "insufficient_data")
+            
+            def calibration_statistic(indices):
+                # Resample both confidences and outcomes using same indices
+                sample_confidences = [confidences[i] for i in indices]
+                sample_outcomes = [outcomes[i] for i in indices]
+                
+                # Calculate Expected Calibration Error
+                return self._calculate_expected_calibration_error(sample_confidences, sample_outcomes)
+            
+            # Perform bootstrap with paired resampling
+            bootstrap_estimates = await self._bootstrap_paired_statistic(
+                data1=confidences,
+                data2=outcomes,
+                statistic_func=calibration_statistic,
+                description="confidence_calibration"
+            )
+            
+            # Calculate point estimate
+            point_estimate = self._calculate_expected_calibration_error(confidences, outcomes)
+            
+            # For ECE, lower is better, so we want 1 - ECE as the score
+            calibration_scores = [max(0.0, 1.0 - ece) for ece in bootstrap_estimates]
+            point_calibration_score = max(0.0, 1.0 - point_estimate)
+            
+            # Calculate confidence interval
+            interval = self._calculate_confidence_interval(
+                calibration_scores,
+                point_calibration_score,
+                calibration_scores  # Use bootstrap estimates as "original data"
+            )
+            
+            return interval
+            
+        except Exception as e:
+            self.logger.error(f"Confidence calibration interval estimation failed: {e}")
+            return self._create_wide_interval(0.5, "error")
+    
+    def _calculate_expected_calibration_error(self, confidences: List[float], outcomes: List[bool]) -> float:
+        """Calculate Expected Calibration Error for bootstrap sampling"""
+        try:
+            if not confidences or len(confidences) != len(outcomes):
+                return 1.0  # Maximum error
+            
+            n_bins = min(10, len(confidences) // 5)  # Adaptive binning
+            if n_bins < 2:
+                n_bins = 2
+            
+            bin_boundaries = np.linspace(0, 1, n_bins + 1)
+            
+            ece = 0.0
+            total_samples = len(confidences)
+            
+            for i in range(n_bins):
+                # Find samples in this bin
+                in_bin = []
+                for j, conf in enumerate(confidences):
+                    if i == n_bins - 1:  # Last bin includes upper boundary
+                        if bin_boundaries[i] <= conf <= bin_boundaries[i + 1]:
+                            in_bin.append(j)
+                    else:
+                        if bin_boundaries[i] <= conf < bin_boundaries[i + 1]:
+                            in_bin.append(j)
+                
+                if in_bin:
+                    bin_confidences = [confidences[j] for j in in_bin]
+                    bin_outcomes = [outcomes[j] for j in in_bin]
+                    
+                    bin_size = len(bin_confidences)
+                    bin_conf_avg = np.mean(bin_confidences)
+                    bin_accuracy = np.mean(bin_outcomes)
+                    
+                    ece += (bin_size / total_samples) * abs(bin_conf_avg - bin_accuracy)
+            
+            return ece
+            
+        except Exception as e:
+            self.logger.error(f"ECE calculation failed: {e}")
+            return 1.0
+    
+    async def _bootstrap_statistic(
+        self,
+        data: List[Any],
+        statistic_func: Callable,
+        description: str
+    ) -> List[float]:
+        """
+        Perform bootstrap resampling for a single dataset.
+        
+        Args:
+            data: Original dataset
+            statistic_func: Function to compute statistic on sample
+            description: Description for logging
+            
+        Returns:
+            List of bootstrap estimates
+        """
+        try:
+            n_original = len(data)
+            sample_size = max(1, int(n_original * self.config.sample_size_fraction))
+            
+            if self.config.parallel_execution and self.config.n_bootstrap_samples > 100:
+                return await self._bootstrap_parallel(data, statistic_func, sample_size, description)
+            else:
+                return await self._bootstrap_sequential(data, statistic_func, sample_size, description)
+                
+        except Exception as e:
+            self.logger.error(f"Bootstrap sampling failed for {description}: {e}")
+            return [statistic_func(data)]  # Return original estimate
+    
+    async def _bootstrap_paired_statistic(
+        self,
+        data1: List[Any],
+        data2: List[Any],
+        statistic_func: Callable,
+        description: str
+    ) -> List[float]:
+        """
+        Perform bootstrap resampling for paired datasets.
+        
+        Args:
+            data1: First dataset
+            data2: Second dataset (must be same length as data1)
+            statistic_func: Function that takes indices and computes statistic
+            description: Description for logging
+            
+        Returns:
+            List of bootstrap estimates
+        """
+        try:
+            if len(data1) != len(data2):
+                raise ValueError("Paired datasets must have same length")
+            
+            n_original = len(data1)
+            sample_size = max(1, int(n_original * self.config.sample_size_fraction))
+            
+            bootstrap_estimates = []
+            
+            for i in range(self.config.n_bootstrap_samples):
+                # Sample indices with replacement
+                sample_indices = np.random.choice(n_original, size=sample_size, replace=True)
+                
+                # Compute statistic
+                estimate = statistic_func(sample_indices)
+                bootstrap_estimates.append(estimate)
+                
+                # Progress logging
+                if (i + 1) % 250 == 0:
+                    self.logger.debug(f"Bootstrap {description}: {i + 1}/{self.config.n_bootstrap_samples}")
+            
+            return bootstrap_estimates
+            
+        except Exception as e:
+            self.logger.error(f"Paired bootstrap sampling failed for {description}: {e}")
+            return [0.5]  # Default estimate
+    
+    async def _bootstrap_sequential(
+        self,
+        data: List[Any],
+        statistic_func: Callable,
+        sample_size: int,
+        description: str
+    ) -> List[float]:
+        """Sequential bootstrap sampling"""
+        try:
+            bootstrap_estimates = []
+            
+            for i in range(self.config.n_bootstrap_samples):
+                # Sample with replacement
+                sample = np.random.choice(data, size=sample_size, replace=True)
+                
+                # Compute statistic
+                estimate = statistic_func(sample)
+                bootstrap_estimates.append(estimate)
+                
+                # Yield control occasionally for async
+                if i % 100 == 0:
+                    await asyncio.sleep(0)
+                    
+                # Progress logging
+                if (i + 1) % 250 == 0:
+                    self.logger.debug(f"Bootstrap {description}: {i + 1}/{self.config.n_bootstrap_samples}")
+            
+            return bootstrap_estimates
+            
+        except Exception as e:
+            self.logger.error(f"Sequential bootstrap failed: {e}")
+            return [statistic_func(data)]
+    
+    async def _bootstrap_parallel(
+        self,
+        data: List[Any],
+        statistic_func: Callable,
+        sample_size: int,
+        description: str
+    ) -> List[float]:
+        """Parallel bootstrap sampling using asyncio"""
+        try:
+            # Split work into batches
+            batch_size = max(1, self.config.n_bootstrap_samples // self.config.max_workers)
+            
+            # Create tasks
+            tasks = []
+            remaining_samples = self.config.n_bootstrap_samples
+            
+            for worker in range(self.config.max_workers):
+                if remaining_samples <= 0:
+                    break
+                
+                worker_samples = min(batch_size, remaining_samples)
+                remaining_samples -= worker_samples
+                
+                task = asyncio.create_task(
+                    self._bootstrap_worker(data, statistic_func, sample_size, worker_samples, f"{description}_worker_{worker}")
+                )
+                tasks.append(task)
+            
+            # Wait for all workers to complete
+            worker_results = await asyncio.gather(*tasks)
+            
+            # Combine results
+            bootstrap_estimates = []
+            for result in worker_results:
+                bootstrap_estimates.extend(result)
+            
+            return bootstrap_estimates
+            
+        except Exception as e:
+            self.logger.error(f"Parallel bootstrap failed: {e}")
+            # Fallback to sequential
+            return await self._bootstrap_sequential(data, statistic_func, sample_size, description)
+    
+    async def _bootstrap_worker(
+        self,
+        data: List[Any],
+        statistic_func: Callable,
+        sample_size: int,
+        n_samples: int,
+        worker_id: str
+    ) -> List[float]:
+        """Bootstrap worker for parallel execution"""
+        try:
+            estimates = []
+            
+            for i in range(n_samples):
+                # Sample with replacement
+                sample = np.random.choice(data, size=sample_size, replace=True)
+                
+                # Compute statistic
+                estimate = statistic_func(sample)
+                estimates.append(estimate)
+                
+                # Yield control occasionally
+                if i % 50 == 0:
+                    await asyncio.sleep(0)
+            
+            return estimates
+            
+        except Exception as e:
+            self.logger.error(f"Bootstrap worker {worker_id} failed: {e}")
+            return []
+    
+    def _calculate_confidence_interval(
+        self,
+        bootstrap_estimates: List[float],
+        point_estimate: float,
+        original_data: List[Any]
+    ) -> ConfidenceInterval:
+        """
+        Calculate confidence interval from bootstrap estimates.
+        
+        Uses bias-corrected and accelerated (BCa) method if enabled,
+        otherwise falls back to percentile method.
+        """
+        try:
+            if not bootstrap_estimates:
+                return self._create_wide_interval(point_estimate, "no_bootstrap_data")
+            
+            bootstrap_estimates = np.array(bootstrap_estimates)
+            
+            # Remove any invalid estimates
+            valid_estimates = bootstrap_estimates[np.isfinite(bootstrap_estimates)]
+            if len(valid_estimates) == 0:
+                return self._create_wide_interval(point_estimate, "invalid_estimates")
+            
+            alpha = 1 - self.config.confidence_level
+            
+            if self.config.bias_correction and self.config.acceleration_correction:
+                # BCa intervals
+                return self._calculate_bca_interval(valid_estimates, point_estimate, original_data, alpha)
+            elif self.config.bias_correction:
+                # Bias-corrected intervals
+                return self._calculate_bc_interval(valid_estimates, point_estimate, alpha)
+            else:
+                # Simple percentile intervals
+                return self._calculate_percentile_interval(valid_estimates, point_estimate, alpha)
+                
+        except Exception as e:
+            self.logger.error(f"Confidence interval calculation failed: {e}")
+            return self._create_wide_interval(point_estimate, "calculation_error")
+    
+    def _calculate_percentile_interval(
+        self,
+        bootstrap_estimates: np.ndarray,
+        point_estimate: float,
+        alpha: float
+    ) -> ConfidenceInterval:
+        """Calculate simple percentile confidence interval"""
+        try:
+            lower_percentile = (alpha / 2) * 100
+            upper_percentile = (1 - alpha / 2) * 100
+            
+            lower_bound = np.percentile(bootstrap_estimates, lower_percentile)
+            upper_bound = np.percentile(bootstrap_estimates, upper_percentile)
+            
+            return ConfidenceInterval(
+                lower_bound=float(lower_bound),
+                upper_bound=float(upper_bound),
+                point_estimate=point_estimate,
+                confidence_level=self.config.confidence_level,
+                method="percentile",
+                n_bootstrap_samples=len(bootstrap_estimates)
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Percentile interval calculation failed: {e}")
+            return self._create_wide_interval(point_estimate, "percentile_error")
+    
+    def _calculate_bc_interval(
+        self,
+        bootstrap_estimates: np.ndarray,
+        point_estimate: float,
+        alpha: float
+    ) -> ConfidenceInterval:
+        """Calculate bias-corrected confidence interval"""
+        try:
+            # Calculate bias correction
+            n_less = np.sum(bootstrap_estimates < point_estimate)
+            p_less = n_less / len(bootstrap_estimates)
+            
+            if p_less == 0:
+                z0 = -np.inf
+            elif p_less == 1:
+                z0 = np.inf
+            else:
+                z0 = stats.norm.ppf(p_less)
+            
+            # Calculate corrected percentiles
+            z_alpha_2 = stats.norm.ppf(alpha / 2)
+            z_1_alpha_2 = stats.norm.ppf(1 - alpha / 2)
+            
+            # Apply bias correction
+            p1 = stats.norm.cdf(2 * z0 + z_alpha_2)
+            p2 = stats.norm.cdf(2 * z0 + z_1_alpha_2)
+            
+            # Ensure percentiles are within valid range
+            p1 = max(0.001, min(0.999, p1))
+            p2 = max(0.001, min(0.999, p2))
+            
+            lower_bound = np.percentile(bootstrap_estimates, p1 * 100)
+            upper_bound = np.percentile(bootstrap_estimates, p2 * 100)
+            
+            return ConfidenceInterval(
+                lower_bound=float(lower_bound),
+                upper_bound=float(upper_bound),
+                point_estimate=point_estimate,
+                confidence_level=self.config.confidence_level,
+                method="bias_corrected",
+                n_bootstrap_samples=len(bootstrap_estimates)
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Bias-corrected interval calculation failed: {e}")
+            return self._calculate_percentile_interval(bootstrap_estimates, point_estimate, alpha)
+    
+    def _calculate_bca_interval(
+        self,
+        bootstrap_estimates: np.ndarray,
+        point_estimate: float,
+        original_data: List[Any],
+        alpha: float
+    ) -> ConfidenceInterval:
+        """Calculate bias-corrected and accelerated (BCa) confidence interval"""
+        try:
+            # Calculate bias correction (same as BC method)
+            n_less = np.sum(bootstrap_estimates < point_estimate)
+            p_less = n_less / len(bootstrap_estimates)
+            
+            if p_less == 0:
+                z0 = -np.inf
+            elif p_less == 1:
+                z0 = np.inf
+            else:
+                z0 = stats.norm.ppf(p_less)
+            
+            # Calculate acceleration using jackknife
+            acceleration = self._calculate_acceleration(original_data, point_estimate)
+            
+            # Calculate corrected percentiles with acceleration
+            z_alpha_2 = stats.norm.ppf(alpha / 2)
+            z_1_alpha_2 = stats.norm.ppf(1 - alpha / 2)
+            
+            # Apply bias and acceleration corrections
+            p1_num = z0 + z_alpha_2
+            p1_denom = 1 - acceleration * (z0 + z_alpha_2)
+            p1 = stats.norm.cdf(z0 + p1_num / p1_denom) if p1_denom != 0 else stats.norm.cdf(z0 + z_alpha_2)
+            
+            p2_num = z0 + z_1_alpha_2
+            p2_denom = 1 - acceleration * (z0 + z_1_alpha_2)
+            p2 = stats.norm.cdf(z0 + p2_num / p2_denom) if p2_denom != 0 else stats.norm.cdf(z0 + z_1_alpha_2)
+            
+            # Ensure percentiles are within valid range
+            p1 = max(0.001, min(0.999, p1))
+            p2 = max(0.001, min(0.999, p2))
+            
+            lower_bound = np.percentile(bootstrap_estimates, p1 * 100)
+            upper_bound = np.percentile(bootstrap_estimates, p2 * 100)
+            
+            return ConfidenceInterval(
+                lower_bound=float(lower_bound),
+                upper_bound=float(upper_bound),
+                point_estimate=point_estimate,
+                confidence_level=self.config.confidence_level,
+                method="bca",
+                n_bootstrap_samples=len(bootstrap_estimates)
+            )
+            
+        except Exception as e:
+            self.logger.error(f"BCa interval calculation failed: {e}")
+            return self._calculate_bc_interval(bootstrap_estimates, point_estimate, alpha)
+    
+    def _calculate_acceleration(self, original_data: List[Any], point_estimate: float) -> float:
+        """Calculate acceleration parameter for BCa intervals using jackknife"""
+        try:
+            n = len(original_data)
+            
+            if n < 10:  # Not enough data for reliable acceleration
+                return 0.0
+            
+            # Jackknife estimates (leave-one-out)
+            jackknife_estimates = []
+            
+            for i in range(n):
+                # Create jackknife sample (all data except index i)
+                jackknife_sample = [original_data[j] for j in range(n) if j != i]
+                
+                # For this implementation, we'll use a simple approximation
+                # In practice, you would apply the same statistic function used for bootstrap
+                if isinstance(original_data[0], bool):
+                    # For boolean outcomes (like win rate)
+                    jackknife_estimate = np.mean(jackknife_sample)
+                else:
+                    # For continuous outcomes
+                    jackknife_estimate = np.mean(jackknife_sample)
+                
+                jackknife_estimates.append(jackknife_estimate)
+            
+            # Calculate acceleration
+            jackknife_mean = np.mean(jackknife_estimates)
+            numerator = np.sum((jackknife_mean - np.array(jackknife_estimates))**3)
+            denominator = 6 * (np.sum((jackknife_mean - np.array(jackknife_estimates))**2))**1.5
+            
+            acceleration = numerator / denominator if denominator != 0 else 0.0
+            
+            # Limit acceleration to reasonable range
+            acceleration = max(-0.25, min(0.25, acceleration))
+            
+            return acceleration
+            
+        except Exception as e:
+            self.logger.error(f"Acceleration calculation failed: {e}")
+            return 0.0  # No acceleration
+    
+    def _create_wide_interval(self, point_estimate: float, reason: str) -> ConfidenceInterval:
+        """Create a wide confidence interval when normal calculation fails"""
+        # Use 40% margin of error as fallback
+        margin = 0.4
+        lower_bound = max(0.0, point_estimate - margin)
+        upper_bound = min(1.0, point_estimate + margin)
+        
+        return ConfidenceInterval(
+            lower_bound=lower_bound,
+            upper_bound=upper_bound,
+            point_estimate=point_estimate,
+            confidence_level=self.config.confidence_level,
+            method=f"fallback_{reason}",
+            n_bootstrap_samples=0
+        )
+    
+    async def estimate_multiple_metrics(
+        self,
+        agent_data: Dict[str, List],
+        agent_id: Optional[str] = None
+    ) -> Dict[str, ConfidenceInterval]:
+        """
+        Estimate confidence intervals for multiple metrics simultaneously.
+        
+        Args:
+            agent_data: Dictionary with metric names as keys and data lists as values
+            agent_id: Optional agent identifier
+            
+        Returns:
+            Dictionary of confidence intervals for each metric
+        """
+        try:
+            results = {}
+            
+            # Create tasks for parallel estimation
+            tasks = []
+            
+            if "outcomes" in agent_data:
+                tasks.append(("win_rate", self.estimate_win_rate_confidence(agent_data["outcomes"], agent_id)))
+            
+            if "kelly_deviations" in agent_data:
+                tasks.append(("kelly_adherence", self.estimate_kelly_adherence_confidence(agent_data["kelly_deviations"], agent_id)))
+            
+            if "returns" in agent_data:
+                tasks.append(("sharpe_ratio", self.estimate_sharpe_ratio_confidence(agent_data["returns"], agent_id)))
+            
+            if "confidences" in agent_data and "outcomes" in agent_data:
+                tasks.append(("confidence_calibration", self.estimate_confidence_calibration_interval(
+                    agent_data["confidences"], agent_data["outcomes"], agent_id)))
+            
+            # Execute all tasks
+            if tasks:
+                task_results = await asyncio.gather(*[task for _, task in tasks])
+                
+                # Collect results
+                for (metric_name, _), result in zip(tasks, task_results):
+                    results[metric_name] = result
+            
+            return results
+            
+        except Exception as e:
+            self.logger.error(f"Multiple metrics estimation failed: {e}")
+            return {}
+    
+    def get_estimation_summary(self, intervals: Dict[str, ConfidenceInterval]) -> Dict[str, Any]:
+        """Generate summary of confidence interval estimations"""
+        try:
+            summary = {
+                "timestamp": datetime.now().isoformat(),
+                "total_metrics": len(intervals),
+                "confidence_level": self.config.confidence_level,
+                "bootstrap_samples": self.config.n_bootstrap_samples,
+                "metrics_summary": {}
+            }
+            
+            for metric_name, interval in intervals.items():
+                summary["metrics_summary"][metric_name] = {
+                    "point_estimate": interval.point_estimate,
+                    "confidence_interval": [interval.lower_bound, interval.upper_bound],
+                    "interval_width": interval.width,
+                    "margin_of_error": interval.margin_of_error,
+                    "method": interval.method,
+                    "bootstrap_samples": interval.n_bootstrap_samples
+                }
+            
+            # Overall quality assessment
+            narrow_intervals = sum(1 for interval in intervals.values() if interval.width < 0.2)
+            summary["estimation_quality"] = {
+                "narrow_intervals": narrow_intervals,
+                "narrow_interval_ratio": narrow_intervals / len(intervals) if intervals else 0,
+                "quality": "high" if narrow_intervals / len(intervals) > 0.7 else "medium" if narrow_intervals / len(intervals) > 0.4 else "low"
+            }
+            
+            return summary
+            
+        except Exception as e:
+            self.logger.error(f"Summary generation failed: {e}")
+            return {"error": str(e)}
\ No newline at end of file
diff --git a/src/confidence_calibration/calibrator.py b/src/confidence_calibration/calibrator.py
new file mode 100644
index 00000000..e8cbc6ee
--- /dev/null
+++ b/src/confidence_calibration/calibrator.py
@@ -0,0 +1,957 @@
+"""
+Confidence Calibration Engine
+
+Calibrates agent confidence scores to improve decision-making accuracy
+and uncertainty estimation in trading scenarios.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Any, Callable
+from datetime import datetime, timedelta
+from enum import Enum
+import logging
+import numpy as np
+from collections import defaultdict, deque
+import json
+from scipy import stats
+from sklearn.isotonic import IsotonicRegression
+from sklearn.linear_model import LogisticRegression
+from sklearn.calibration import CalibratedClassifierCV
+import asyncio
+
+from ..training.agent_analytics import DecisionMetrics
+
+
+class CalibrationMethod(Enum):
+    """Methods for confidence calibration"""
+    PLATT_SCALING = "platt_scaling"
+    ISOTONIC_REGRESSION = "isotonic_regression"
+    TEMPERATURE_SCALING = "temperature_scaling"
+    BAYESIAN_CALIBRATION = "bayesian_calibration"
+    HISTOGRAM_BINNING = "histogram_binning"
+
+
+@dataclass
+class ConfidenceScore:
+    """Enhanced confidence score with uncertainty quantification"""
+    raw_confidence: float  # Original agent confidence
+    calibrated_confidence: float  # Calibrated confidence
+    uncertainty: float  # Uncertainty estimate
+    confidence_interval: Tuple[float, float]  # Confidence bounds
+    method_used: CalibrationMethod
+    sample_size: int  # Number of samples used for calibration
+    
+    @property
+    def reliability(self) -> float:
+        """Get reliability score based on sample size and uncertainty"""
+        base_reliability = min(1.0, self.sample_size / 100)  # More samples = more reliable
+        uncertainty_penalty = self.uncertainty * 0.5
+        return max(0.0, base_reliability - uncertainty_penalty)
+
+
+@dataclass
+class CalibrationMetrics:
+    """Metrics for evaluating calibration quality"""
+    brier_score: float  # Lower is better
+    reliability: float  # Expected Calibration Error (ECE)
+    resolution: float  # Ability to discriminate
+    sharpness: float  # Confidence in predictions
+    calibration_slope: float  # Slope of calibration curve
+    calibration_intercept: float  # Intercept of calibration curve
+    sample_count: int
+    
+    @property
+    def calibration_quality(self) -> str:
+        """Overall calibration quality assessment"""
+        if self.reliability < 0.05:
+            return "excellent"
+        elif self.reliability < 0.10:
+            return "good"
+        elif self.reliability < 0.20:
+            return "fair"
+        else:
+            return "poor"
+
+
+@dataclass
+class CalibrationData:
+    """Data structure for calibration training"""
+    confidences: List[float]
+    outcomes: List[bool]  # True for success, False for failure
+    weights: Optional[List[float]] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def __len__(self) -> int:
+        return len(self.confidences)
+    
+    @property
+    def is_valid(self) -> bool:
+        """Check if calibration data is valid"""
+        return (len(self.confidences) == len(self.outcomes) and
+                len(self.confidences) > 10 and  # Minimum sample size
+                all(0 <= c <= 1 for c in self.confidences))
+
+
+class UncertaintyQuantifier:
+    """
+    Quantifies uncertainty in agent decisions using multiple approaches.
+    """
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        
+        # Historical data for uncertainty estimation
+        self.decision_history: deque = deque(maxlen=1000)
+        self.outcome_patterns: Dict[str, List[float]] = defaultdict(list)
+        
+    def estimate_uncertainty(
+        self,
+        confidence: float,
+        context: Dict[str, Any],
+        method: str = "ensemble"
+    ) -> float:
+        """
+        Estimate uncertainty for a given confidence score and context.
+        
+        Args:
+            confidence: Raw confidence score
+            context: Decision context (market conditions, agent state, etc.)
+            method: Uncertainty estimation method
+            
+        Returns:
+            Uncertainty estimate (0 = certain, 1 = maximum uncertainty)
+        """
+        try:
+            if method == "ensemble":
+                return self._ensemble_uncertainty(confidence, context)
+            elif method == "variance":
+                return self._variance_based_uncertainty(confidence, context)
+            elif method == "entropy":
+                return self._entropy_based_uncertainty(confidence, context)
+            else:
+                return self._default_uncertainty(confidence, context)
+                
+        except Exception as e:
+            self.logger.error(f"Failed to estimate uncertainty: {e}")
+            return 0.5  # Default moderate uncertainty
+    
+    def _ensemble_uncertainty(self, confidence: float, context: Dict[str, Any]) -> float:
+        """Ensemble uncertainty estimation combining multiple methods"""
+        try:
+            # Get uncertainty from different methods
+            variance_unc = self._variance_based_uncertainty(confidence, context)
+            entropy_unc = self._entropy_based_uncertainty(confidence, context)
+            pattern_unc = self._pattern_based_uncertainty(confidence, context)
+            
+            # Weighted combination
+            weights = [0.4, 0.3, 0.3]
+            uncertainties = [variance_unc, entropy_unc, pattern_unc]
+            
+            ensemble_uncertainty = sum(w * u for w, u in zip(weights, uncertainties))
+            return min(1.0, max(0.0, ensemble_uncertainty))
+            
+        except Exception as e:
+            self.logger.error(f"Ensemble uncertainty estimation failed: {e}")
+            return 0.5
+    
+    def _variance_based_uncertainty(self, confidence: float, context: Dict[str, Any]) -> float:
+        """Uncertainty based on confidence variance in similar situations"""
+        try:
+            # Find similar historical decisions
+            similar_decisions = self._find_similar_decisions(context)
+            
+            if len(similar_decisions) < 5:
+                return 0.7  # High uncertainty with limited data
+            
+            # Calculate confidence variance in similar situations
+            confidences = [d["confidence"] for d in similar_decisions]
+            variance = np.var(confidences)
+            
+            # Normalize variance to uncertainty scale
+            uncertainty = min(1.0, variance * 2)  # Scale factor
+            return uncertainty
+            
+        except Exception as e:
+            self.logger.error(f"Variance-based uncertainty failed: {e}")
+            return 0.5
+    
+    def _entropy_based_uncertainty(self, confidence: float, context: Dict[str, Any]) -> float:
+        """Uncertainty based on information entropy"""
+        try:
+            # Create probability distribution
+            p = confidence
+            q = 1 - confidence
+            
+            # Calculate entropy (maximum at p=0.5)
+            if p == 0 or p == 1:
+                entropy = 0
+            else:
+                entropy = -p * np.log2(p) - q * np.log2(q)
+            
+            # Normalize to 0-1 scale (max entropy = 1)
+            uncertainty = entropy
+            
+            # Adjust based on context complexity
+            context_complexity = self._assess_context_complexity(context)
+            uncertainty = uncertainty * (1 + context_complexity * 0.3)
+            
+            return min(1.0, uncertainty)
+            
+        except Exception as e:
+            self.logger.error(f"Entropy-based uncertainty failed: {e}")
+            return 0.5
+    
+    def _pattern_based_uncertainty(self, confidence: float, context: Dict[str, Any]) -> float:
+        """Uncertainty based on outcome patterns for similar confidence levels"""
+        try:
+            # Find decisions with similar confidence levels
+            confidence_range = 0.1  # ±10% confidence range
+            similar_confidences = []
+            
+            for decision in self.decision_history:
+                if abs(decision["confidence"] - confidence) <= confidence_range:
+                    similar_confidences.append(decision)
+            
+            if len(similar_confidences) < 3:
+                return 0.6  # Moderate uncertainty with limited pattern data
+            
+            # Calculate outcome variance for this confidence level
+            outcomes = [1.0 if d["outcome"] else 0.0 for d in similar_confidences]
+            outcome_variance = np.var(outcomes)
+            
+            # Higher variance = higher uncertainty
+            uncertainty = min(1.0, outcome_variance * 2)
+            return uncertainty
+            
+        except Exception as e:
+            self.logger.error(f"Pattern-based uncertainty failed: {e}")
+            return 0.5
+    
+    def _find_similar_decisions(self, context: Dict[str, Any], similarity_threshold: float = 0.7) -> List[Dict]:
+        """Find historically similar decision contexts"""
+        try:
+            similar_decisions = []
+            
+            for decision in self.decision_history:
+                similarity = self._calculate_context_similarity(
+                    context, decision.get("context", {})
+                )
+                
+                if similarity >= similarity_threshold:
+                    similar_decisions.append(decision)
+            
+            return similar_decisions
+            
+        except Exception as e:
+            self.logger.error(f"Failed to find similar decisions: {e}")
+            return []
+    
+    def _calculate_context_similarity(self, context1: Dict, context2: Dict) -> float:
+        """Calculate similarity between two decision contexts"""
+        try:
+            if not context1 or not context2:
+                return 0.0
+            
+            # Key context features to compare
+            features = ["market_ticker", "event_type", "quarter", "time_remaining"]
+            
+            matches = 0
+            total_features = 0
+            
+            for feature in features:
+                if feature in context1 and feature in context2:
+                    total_features += 1
+                    if context1[feature] == context2[feature]:
+                        matches += 1
+            
+            if total_features == 0:
+                return 0.0
+            
+            return matches / total_features
+            
+        except Exception as e:
+            self.logger.error(f"Context similarity calculation failed: {e}")
+            return 0.0
+    
+    def _assess_context_complexity(self, context: Dict[str, Any]) -> float:
+        """Assess complexity of decision context (0 = simple, 1 = complex)"""
+        try:
+            complexity_score = 0.0
+            
+            # Number of context features
+            feature_complexity = min(1.0, len(context) / 20)  # More features = more complex
+            complexity_score += feature_complexity * 0.3
+            
+            # Time pressure (less time = more complex)
+            time_remaining = context.get("time_remaining", 3600)  # Default 1 hour
+            time_complexity = max(0.0, 1 - time_remaining / 3600)  # Normalize to hour
+            complexity_score += time_complexity * 0.3
+            
+            # Market volatility proxy
+            market_events = context.get("recent_events", [])
+            volatility_complexity = min(1.0, len(market_events) / 10)
+            complexity_score += volatility_complexity * 0.4
+            
+            return min(1.0, complexity_score)
+            
+        except Exception as e:
+            self.logger.error(f"Context complexity assessment failed: {e}")
+            return 0.5
+    
+    def _default_uncertainty(self, confidence: float, context: Dict[str, Any]) -> float:
+        """Default uncertainty estimation"""
+        # Simple heuristic: uncertainty is highest at confidence = 0.5
+        base_uncertainty = 2 * min(confidence, 1 - confidence)
+        
+        # Add some noise based on context
+        context_factor = min(0.2, len(context) * 0.01)
+        return min(1.0, base_uncertainty + context_factor)
+    
+    def update_decision_history(self, decision_data: Dict[str, Any]) -> None:
+        """Update decision history with new outcome"""
+        try:
+            self.decision_history.append(decision_data)
+            
+            # Update outcome patterns
+            confidence_bucket = int(decision_data["confidence"] * 10) / 10  # Bucket to 0.1 precision
+            outcome_value = 1.0 if decision_data.get("outcome", False) else 0.0
+            self.outcome_patterns[str(confidence_bucket)].append(outcome_value)
+            
+        except Exception as e:
+            self.logger.error(f"Failed to update decision history: {e}")
+
+
+class ConfidenceCalibrator:
+    """
+    Main confidence calibration engine that trains calibration models
+    and provides calibrated confidence scores for agent decisions.
+    """
+    
+    def __init__(self, uncertainty_quantifier: Optional[UncertaintyQuantifier] = None):
+        self.logger = logging.getLogger(__name__)
+        
+        # Uncertainty quantification
+        self.uncertainty_quantifier = uncertainty_quantifier or UncertaintyQuantifier()
+        
+        # Calibration models for different methods
+        self.calibration_models: Dict[CalibrationMethod, Any] = {}
+        
+        # Training data storage
+        self.training_data: Dict[str, CalibrationData] = {}  # By agent_id
+        
+        # Calibration performance tracking
+        self.calibration_metrics: Dict[str, CalibrationMetrics] = {}
+        
+        # Default calibration parameters
+        self.default_method = CalibrationMethod.ISOTONIC_REGRESSION
+        self.min_training_samples = 50
+        self.calibration_update_frequency = timedelta(hours=6)
+        self.last_calibration_update: Dict[str, datetime] = {}
+        
+    async def train_calibration(self, agent_id: str, decisions: List[DecisionMetrics]) -> CalibrationMetrics:
+        """
+        Train calibration model for a specific agent.
+        
+        Args:
+            agent_id: Agent identifier
+            decisions: List of historical decisions with outcomes
+            
+        Returns:
+            Calibration metrics for the trained model
+        """
+        try:
+            # Prepare training data
+            training_data = self._prepare_training_data(decisions)
+            
+            if not training_data.is_valid:
+                raise ValueError(f"Invalid training data for agent {agent_id}")
+            
+            if len(training_data) < self.min_training_samples:
+                self.logger.warning(f"Insufficient training data for agent {agent_id}: {len(training_data)} samples")
+                return self._create_default_metrics()
+            
+            # Store training data
+            self.training_data[agent_id] = training_data
+            
+            # Train multiple calibration models
+            models = {}
+            for method in [CalibrationMethod.PLATT_SCALING, 
+                          CalibrationMethod.ISOTONIC_REGRESSION,
+                          CalibrationMethod.TEMPERATURE_SCALING]:
+                try:
+                    model = await self._train_single_method(method, training_data)
+                    models[method] = model
+                except Exception as e:
+                    self.logger.warning(f"Failed to train {method.value} for agent {agent_id}: {e}")
+            
+            # Select best model
+            best_method, best_model = self._select_best_model(models, training_data)
+            self.calibration_models[agent_id] = (best_method, best_model)
+            
+            # Calculate and store metrics
+            metrics = self._calculate_calibration_metrics(best_model, best_method, training_data)
+            self.calibration_metrics[agent_id] = metrics
+            
+            # Update timestamp
+            self.last_calibration_update[agent_id] = datetime.now()
+            
+            self.logger.info(f"Trained calibration for agent {agent_id} using {best_method.value}")
+            self.logger.info(f"Calibration quality: {metrics.calibration_quality} (reliability: {metrics.reliability:.3f})")
+            
+            return metrics
+            
+        except Exception as e:
+            self.logger.error(f"Failed to train calibration for agent {agent_id}: {e}")
+            return self._create_default_metrics()
+    
+    def _prepare_training_data(self, decisions: List[DecisionMetrics]) -> CalibrationData:
+        """Prepare training data from decision metrics"""
+        try:
+            confidences = []
+            outcomes = []
+            weights = []
+            
+            for decision in decisions:
+                if decision.outcome is not None and 0 <= decision.confidence <= 1:
+                    confidences.append(decision.confidence)
+                    outcomes.append(decision.outcome > 0)  # Convert to boolean
+                    
+                    # Weight more recent decisions higher
+                    age_days = (datetime.now() - decision.timestamp).days
+                    weight = max(0.1, 1.0 - age_days * 0.1)  # Decay weight over time
+                    weights.append(weight)
+            
+            return CalibrationData(
+                confidences=confidences,
+                outcomes=outcomes,
+                weights=weights,
+                metadata={"sample_count": len(confidences)}
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Failed to prepare training data: {e}")
+            return CalibrationData([], [])
+    
+    async def _train_single_method(self, method: CalibrationMethod, data: CalibrationData) -> Any:
+        """Train a single calibration method"""
+        try:
+            X = np.array(data.confidences).reshape(-1, 1)
+            y = np.array(data.outcomes)
+            sample_weights = np.array(data.weights) if data.weights else None
+            
+            if method == CalibrationMethod.PLATT_SCALING:
+                model = LogisticRegression()
+                model.fit(X, y, sample_weight=sample_weights)
+                return model
+                
+            elif method == CalibrationMethod.ISOTONIC_REGRESSION:
+                model = IsotonicRegression(out_of_bounds='clip')
+                model.fit(data.confidences, data.outcomes, sample_weight=sample_weights)
+                return model
+                
+            elif method == CalibrationMethod.TEMPERATURE_SCALING:
+                # Temperature scaling using logistic regression
+                model = self._train_temperature_scaling(X, y, sample_weights)
+                return model
+                
+            elif method == CalibrationMethod.HISTOGRAM_BINNING:
+                model = self._train_histogram_binning(data.confidences, data.outcomes, sample_weights)
+                return model
+                
+            else:
+                raise ValueError(f"Unsupported calibration method: {method}")
+                
+        except Exception as e:
+            self.logger.error(f"Failed to train {method.value}: {e}")
+            raise
+    
+    def _train_temperature_scaling(self, X: np.ndarray, y: np.ndarray, sample_weights: Optional[np.ndarray]) -> Dict:
+        """Train temperature scaling model"""
+        try:
+            # Use logistic regression to find optimal temperature
+            model = LogisticRegression()
+            model.fit(X, y, sample_weight=sample_weights)
+            
+            # Extract temperature parameter (inverse of coefficient)
+            temperature = 1.0 / abs(model.coef_[0][0]) if model.coef_[0][0] != 0 else 1.0
+            
+            return {
+                "type": "temperature_scaling",
+                "temperature": temperature,
+                "intercept": model.intercept_[0]
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Temperature scaling training failed: {e}")
+            return {"type": "temperature_scaling", "temperature": 1.0, "intercept": 0.0}
+    
+    def _train_histogram_binning(self, confidences: List[float], outcomes: List[bool], weights: Optional[List[float]]) -> Dict:
+        """Train histogram binning calibration"""
+        try:
+            n_bins = min(10, len(confidences) // 10)  # Adaptive number of bins
+            if n_bins < 2:
+                n_bins = 2
+            
+            # Create bins
+            bin_boundaries = np.linspace(0, 1, n_bins + 1)
+            bin_centers = (bin_boundaries[:-1] + bin_boundaries[1:]) / 2
+            
+            # Calculate calibrated probabilities for each bin
+            calibrated_probs = []
+            
+            for i in range(n_bins):
+                # Find samples in this bin
+                in_bin = [(confidences[j] >= bin_boundaries[i] and confidences[j] < bin_boundaries[i+1])
+                         for j in range(len(confidences))]
+                
+                if i == n_bins - 1:  # Last bin includes upper boundary
+                    in_bin = [(confidences[j] >= bin_boundaries[i] and confidences[j] <= bin_boundaries[i+1])
+                             for j in range(len(confidences))]
+                
+                # Calculate weighted average outcome for this bin
+                bin_outcomes = [outcomes[j] for j in range(len(outcomes)) if in_bin[j]]
+                bin_weights = [weights[j] for j in range(len(weights)) if in_bin[j]] if weights else None
+                
+                if bin_outcomes:
+                    if bin_weights:
+                        weighted_sum = sum(o * w for o, w in zip(bin_outcomes, bin_weights))
+                        weight_sum = sum(bin_weights)
+                        calibrated_prob = weighted_sum / weight_sum if weight_sum > 0 else 0.5
+                    else:
+                        calibrated_prob = sum(bin_outcomes) / len(bin_outcomes)
+                else:
+                    calibrated_prob = bin_centers[i]  # Use bin center as fallback
+                
+                calibrated_probs.append(calibrated_prob)
+            
+            return {
+                "type": "histogram_binning",
+                "bin_boundaries": bin_boundaries.tolist(),
+                "calibrated_probs": calibrated_probs
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Histogram binning training failed: {e}")
+            return {"type": "histogram_binning", "bin_boundaries": [0, 1], "calibrated_probs": [0.5]}
+    
+    def _select_best_model(self, models: Dict[CalibrationMethod, Any], data: CalibrationData) -> Tuple[CalibrationMethod, Any]:
+        """Select best calibration model based on validation performance"""
+        try:
+            if not models:
+                return self.default_method, None
+            
+            best_method = None
+            best_model = None
+            best_score = float('inf')
+            
+            # Use Brier score for model selection (lower is better)
+            for method, model in models.items():
+                try:
+                    score = self._calculate_brier_score(model, method, data)
+                    if score < best_score:
+                        best_score = score
+                        best_method = method
+                        best_model = model
+                except Exception as e:
+                    self.logger.warning(f"Failed to evaluate {method.value}: {e}")
+                    continue
+            
+            if best_method is None:
+                # Fallback to first available model
+                best_method = list(models.keys())[0]
+                best_model = models[best_method]
+            
+            return best_method, best_model
+            
+        except Exception as e:
+            self.logger.error(f"Model selection failed: {e}")
+            return self.default_method, None
+    
+    def _calculate_brier_score(self, model: Any, method: CalibrationMethod, data: CalibrationData) -> float:
+        """Calculate Brier score for model evaluation"""
+        try:
+            # Get calibrated predictions
+            calibrated_probs = self._apply_calibration_model(data.confidences, model, method)
+            
+            # Calculate Brier score
+            brier_score = np.mean([(prob - outcome)**2 for prob, outcome in zip(calibrated_probs, data.outcomes)])
+            
+            return brier_score
+            
+        except Exception as e:
+            self.logger.error(f"Brier score calculation failed: {e}")
+            return 1.0  # Worst possible score
+    
+    def _apply_calibration_model(self, confidences: List[float], model: Any, method: CalibrationMethod) -> List[float]:
+        """Apply calibration model to get calibrated probabilities"""
+        try:
+            if method == CalibrationMethod.PLATT_SCALING:
+                X = np.array(confidences).reshape(-1, 1)
+                return model.predict_proba(X)[:, 1].tolist()
+                
+            elif method == CalibrationMethod.ISOTONIC_REGRESSION:
+                return model.predict(confidences).tolist()
+                
+            elif method == CalibrationMethod.TEMPERATURE_SCALING:
+                temperature = model["temperature"]
+                intercept = model["intercept"]
+                
+                calibrated = []
+                for conf in confidences:
+                    # Apply temperature scaling
+                    logit = np.log(conf / (1 - conf)) if 0 < conf < 1 else 0
+                    scaled_logit = logit / temperature + intercept
+                    calibrated_prob = 1 / (1 + np.exp(-scaled_logit))
+                    calibrated.append(max(0.001, min(0.999, calibrated_prob)))
+                
+                return calibrated
+                
+            elif method == CalibrationMethod.HISTOGRAM_BINNING:
+                bin_boundaries = model["bin_boundaries"]
+                calibrated_probs = model["calibrated_probs"]
+                
+                calibrated = []
+                for conf in confidences:
+                    # Find appropriate bin
+                    bin_idx = np.digitize(conf, bin_boundaries) - 1
+                    bin_idx = max(0, min(len(calibrated_probs) - 1, bin_idx))
+                    calibrated.append(calibrated_probs[bin_idx])
+                
+                return calibrated
+                
+            else:
+                return confidences  # No calibration
+                
+        except Exception as e:
+            self.logger.error(f"Failed to apply calibration model: {e}")
+            return confidences
+    
+    def _calculate_calibration_metrics(self, model: Any, method: CalibrationMethod, data: CalibrationData) -> CalibrationMetrics:
+        """Calculate comprehensive calibration metrics"""
+        try:
+            # Get calibrated predictions
+            calibrated_probs = self._apply_calibration_model(data.confidences, model, method)
+            
+            # Brier score
+            brier_score = np.mean([(prob - outcome)**2 for prob, outcome in zip(calibrated_probs, data.outcomes)])
+            
+            # Reliability (Expected Calibration Error)
+            reliability = self._calculate_expected_calibration_error(calibrated_probs, data.outcomes)
+            
+            # Resolution
+            resolution = self._calculate_resolution(calibrated_probs, data.outcomes)
+            
+            # Sharpness
+            sharpness = np.var(calibrated_probs)
+            
+            # Calibration curve statistics
+            slope, intercept = self._calculate_calibration_curve_stats(calibrated_probs, data.outcomes)
+            
+            return CalibrationMetrics(
+                brier_score=brier_score,
+                reliability=reliability,
+                resolution=resolution,
+                sharpness=sharpness,
+                calibration_slope=slope,
+                calibration_intercept=intercept,
+                sample_count=len(data)
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Failed to calculate calibration metrics: {e}")
+            return self._create_default_metrics()
+    
+    def _calculate_expected_calibration_error(self, predictions: List[float], outcomes: List[bool]) -> float:
+        """Calculate Expected Calibration Error (ECE)"""
+        try:
+            n_bins = 10
+            bin_boundaries = np.linspace(0, 1, n_bins + 1)
+            
+            ece = 0.0
+            total_samples = len(predictions)
+            
+            for i in range(n_bins):
+                # Find samples in this bin
+                in_bin_mask = [(predictions[j] >= bin_boundaries[i] and predictions[j] < bin_boundaries[i+1])
+                              for j in range(len(predictions))]
+                
+                if i == n_bins - 1:  # Last bin includes upper boundary
+                    in_bin_mask = [(predictions[j] >= bin_boundaries[i] and predictions[j] <= bin_boundaries[i+1])
+                                  for j in range(len(predictions))]
+                
+                bin_predictions = [predictions[j] for j in range(len(predictions)) if in_bin_mask[j]]
+                bin_outcomes = [outcomes[j] for j in range(len(outcomes)) if in_bin_mask[j]]
+                
+                if bin_predictions:
+                    bin_size = len(bin_predictions)
+                    bin_confidence = np.mean(bin_predictions)
+                    bin_accuracy = np.mean(bin_outcomes)
+                    
+                    ece += (bin_size / total_samples) * abs(bin_confidence - bin_accuracy)
+            
+            return ece
+            
+        except Exception as e:
+            self.logger.error(f"ECE calculation failed: {e}")
+            return 1.0
+    
+    def _calculate_resolution(self, predictions: List[float], outcomes: List[bool]) -> float:
+        """Calculate resolution (ability to discriminate between classes)"""
+        try:
+            # Resolution is the variance of conditional probabilities weighted by frequency
+            n_bins = 10
+            bin_boundaries = np.linspace(0, 1, n_bins + 1)
+            
+            resolution = 0.0
+            total_samples = len(predictions)
+            overall_base_rate = np.mean(outcomes)
+            
+            for i in range(n_bins):
+                # Find samples in this bin
+                in_bin_mask = [(predictions[j] >= bin_boundaries[i] and predictions[j] < bin_boundaries[i+1])
+                              for j in range(len(predictions))]
+                
+                if i == n_bins - 1:  # Last bin includes upper boundary
+                    in_bin_mask = [(predictions[j] >= bin_boundaries[i] and predictions[j] <= bin_boundaries[i+1])
+                                  for j in range(len(predictions))]
+                
+                bin_outcomes = [outcomes[j] for j in range(len(outcomes)) if in_bin_mask[j]]
+                
+                if bin_outcomes:
+                    bin_size = len(bin_outcomes)
+                    bin_accuracy = np.mean(bin_outcomes)
+                    
+                    resolution += (bin_size / total_samples) * (bin_accuracy - overall_base_rate)**2
+            
+            return resolution
+            
+        except Exception as e:
+            self.logger.error(f"Resolution calculation failed: {e}")
+            return 0.0
+    
+    def _calculate_calibration_curve_stats(self, predictions: List[float], outcomes: List[bool]) -> Tuple[float, float]:
+        """Calculate slope and intercept of calibration curve"""
+        try:
+            # Linear regression of outcomes vs predictions
+            slope, intercept, _, _, _ = stats.linregress(predictions, outcomes)
+            return slope, intercept
+            
+        except Exception as e:
+            self.logger.error(f"Calibration curve stats calculation failed: {e}")
+            return 1.0, 0.0  # Perfect calibration
+    
+    def _create_default_metrics(self) -> CalibrationMetrics:
+        """Create default calibration metrics"""
+        return CalibrationMetrics(
+            brier_score=0.25,  # Random prediction
+            reliability=0.5,   # Poor reliability
+            resolution=0.0,    # No resolution
+            sharpness=0.25,    # Moderate sharpness
+            calibration_slope=1.0,
+            calibration_intercept=0.0,
+            sample_count=0
+        )
+    
+    async def calibrate_confidence(
+        self,
+        agent_id: str,
+        raw_confidence: float,
+        context: Dict[str, Any]
+    ) -> ConfidenceScore:
+        """
+        Calibrate confidence score for an agent's decision.
+        
+        Args:
+            agent_id: Agent identifier
+            raw_confidence: Original confidence score (0-1)
+            context: Decision context for uncertainty estimation
+            
+        Returns:
+            Calibrated confidence score with uncertainty bounds
+        """
+        try:
+            # Check if we have calibration model for this agent
+            if agent_id not in self.calibration_models:
+                # Try to train calibration if we have enough data
+                if agent_id in self.training_data and len(self.training_data[agent_id]) >= self.min_training_samples:
+                    # Use existing training data to create temporary model
+                    decisions = []  # Would need to reconstruct from training data
+                    await self.train_calibration(agent_id, decisions)
+                else:
+                    # Return uncalibrated confidence with high uncertainty
+                    return self._create_default_confidence_score(raw_confidence, context)
+            
+            method, model = self.calibration_models[agent_id]
+            
+            # Apply calibration
+            calibrated_conf = self._apply_calibration_model([raw_confidence], model, method)[0]
+            
+            # Estimate uncertainty
+            uncertainty = self.uncertainty_quantifier.estimate_uncertainty(
+                raw_confidence, context, method="ensemble"
+            )
+            
+            # Calculate confidence interval
+            conf_interval = self._calculate_confidence_interval(
+                calibrated_conf, uncertainty, context
+            )
+            
+            # Get sample size used for calibration
+            sample_size = self.training_data.get(agent_id, CalibrationData([], [])).sample_count if agent_id in self.training_data else 0
+            
+            return ConfidenceScore(
+                raw_confidence=raw_confidence,
+                calibrated_confidence=calibrated_conf,
+                uncertainty=uncertainty,
+                confidence_interval=conf_interval,
+                method_used=method,
+                sample_size=sample_size
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Failed to calibrate confidence for agent {agent_id}: {e}")
+            return self._create_default_confidence_score(raw_confidence, context)
+    
+    def _create_default_confidence_score(self, raw_confidence: float, context: Dict[str, Any]) -> ConfidenceScore:
+        """Create default confidence score when calibration is not available"""
+        # Use simple uncertainty estimation
+        uncertainty = max(0.3, 2 * min(raw_confidence, 1 - raw_confidence))  # Higher at extremes
+        
+        # Wide confidence interval due to lack of calibration
+        margin = uncertainty * 0.5
+        conf_interval = (
+            max(0.0, raw_confidence - margin),
+            min(1.0, raw_confidence + margin)
+        )
+        
+        return ConfidenceScore(
+            raw_confidence=raw_confidence,
+            calibrated_confidence=raw_confidence,  # No calibration applied
+            uncertainty=uncertainty,
+            confidence_interval=conf_interval,
+            method_used=CalibrationMethod.HISTOGRAM_BINNING,  # Default method
+            sample_size=0
+        )
+    
+    def _calculate_confidence_interval(
+        self,
+        calibrated_confidence: float,
+        uncertainty: float,
+        context: Dict[str, Any],
+        confidence_level: float = 0.95
+    ) -> Tuple[float, float]:
+        """Calculate confidence interval for calibrated score"""
+        try:
+            # Use uncertainty to determine interval width
+            z_score = stats.norm.ppf((1 + confidence_level) / 2)  # 95% confidence
+            
+            # Scale uncertainty by z-score
+            margin = uncertainty * z_score * 0.5
+            
+            # Adjust margin based on context
+            context_adjustment = self._get_context_adjustment(context)
+            margin = margin * (1 + context_adjustment)
+            
+            # Calculate bounds
+            lower_bound = max(0.0, calibrated_confidence - margin)
+            upper_bound = min(1.0, calibrated_confidence + margin)
+            
+            return (lower_bound, upper_bound)
+            
+        except Exception as e:
+            self.logger.error(f"Confidence interval calculation failed: {e}")
+            return (max(0.0, calibrated_confidence - 0.2), min(1.0, calibrated_confidence + 0.2))
+    
+    def _get_context_adjustment(self, context: Dict[str, Any]) -> float:
+        """Get adjustment factor based on decision context"""
+        try:
+            adjustment = 0.0
+            
+            # Time pressure increases uncertainty
+            time_remaining = context.get("time_remaining", 3600)
+            if time_remaining < 300:  # Less than 5 minutes
+                adjustment += 0.2
+            elif time_remaining < 900:  # Less than 15 minutes
+                adjustment += 0.1
+            
+            # Market volatility increases uncertainty
+            recent_events = context.get("recent_events", [])
+            if len(recent_events) > 5:
+                adjustment += 0.15
+            
+            # Edge case scenarios increase uncertainty
+            if context.get("is_edge_case", False):
+                adjustment += 0.25
+            
+            return min(0.5, adjustment)  # Cap adjustment
+            
+        except Exception as e:
+            self.logger.error(f"Context adjustment calculation failed: {e}")
+            return 0.1  # Small default adjustment
+    
+    async def should_update_calibration(self, agent_id: str) -> bool:
+        """Check if calibration model should be updated"""
+        try:
+            if agent_id not in self.last_calibration_update:
+                return True  # Never been updated
+            
+            last_update = self.last_calibration_update[agent_id]
+            time_since_update = datetime.now() - last_update
+            
+            # Time-based update
+            if time_since_update >= self.calibration_update_frequency:
+                return True
+            
+            # Performance-based update
+            if agent_id in self.calibration_metrics:
+                metrics = self.calibration_metrics[agent_id]
+                if metrics.reliability > 0.2:  # Poor calibration
+                    return True
+            
+            return False
+            
+        except Exception as e:
+            self.logger.error(f"Failed to check update status for agent {agent_id}: {e}")
+            return False
+    
+    def get_calibration_status(self, agent_id: Optional[str] = None) -> Dict[str, Any]:
+        """Get calibration status for agent(s)"""
+        try:
+            if agent_id:
+                # Single agent status
+                if agent_id not in self.calibration_models:
+                    return {"agent_id": agent_id, "status": "not_calibrated", "reason": "no_model"}
+                
+                method, _ = self.calibration_models[agent_id]
+                metrics = self.calibration_metrics.get(agent_id)
+                last_update = self.last_calibration_update.get(agent_id)
+                
+                return {
+                    "agent_id": agent_id,
+                    "status": "calibrated",
+                    "method": method.value,
+                    "metrics": {
+                        "calibration_quality": metrics.calibration_quality if metrics else "unknown",
+                        "reliability": metrics.reliability if metrics else 0.5,
+                        "brier_score": metrics.brier_score if metrics else 0.25,
+                        "sample_count": metrics.sample_count if metrics else 0
+                    },
+                    "last_update": last_update.isoformat() if last_update else None,
+                    "needs_update": False  # Will be checked separately if needed
+                }
+            else:
+                # All agents status
+                all_status = {}
+                for agent_id in set(list(self.calibration_models.keys()) + list(self.training_data.keys())):
+                    all_status[agent_id] = self.get_calibration_status(agent_id)
+                
+                return {
+                    "timestamp": datetime.now().isoformat(),
+                    "total_agents": len(all_status),
+                    "calibrated_agents": len([s for s in all_status.values() if s.get("status") == "calibrated"]),
+                    "agents": all_status
+                }
+                
+        except Exception as e:
+            self.logger.error(f"Failed to get calibration status: {e}")
+            return {"error": str(e)}
\ No newline at end of file
diff --git a/src/data_pipeline/README_OLD.md b/src/data_pipeline/README_OLD.md
index 2c493340..6f0826ce 100644
--- a/src/data_pipeline/README_OLD.md
+++ b/src/data_pipeline/README_OLD.md
@@ -61,7 +61,7 @@ python kalshi_stream.py
 ## WebSocket URLs
 
 - **Demo**: `wss://demo-api.kalshi.co/trade-api/ws/v2`
-- **Production**: `wss://api.kalshi.co/trade-api/ws/v2`
+- **Production**: `wss://api.elections.kalshi.com/trade-api/ws/v2`
 
 ## Authentication
 
diff --git a/src/data_pipeline/config/settings.py b/src/data_pipeline/config/settings.py
index 62d03fdd..2e4d79c8 100644
--- a/src/data_pipeline/config/settings.py
+++ b/src/data_pipeline/config/settings.py
@@ -9,9 +9,15 @@
 from dotenv import load_dotenv
 import os
 
-# Load environment variables
-env_path = Path(__file__).parent.parent.parent / '.env'
-load_dotenv(env_path)
+# Load environment variables - try multiple .env files in order of preference
+project_root = Path(__file__).parent.parent.parent.parent
+env_files = ['.env', '.env.demo', '.env.production']
+
+for env_file in env_files:
+    env_path = project_root / env_file
+    if env_path.exists():
+        load_dotenv(env_path)
+        break
 
 
 @dataclass
@@ -64,8 +70,8 @@ def get_config() -> KalshiConfig:
     
     # Set URLs based on environment
     if environment == 'prod':
-        api_base_url = 'https://api.kalshi.co/trade-api/v2/'
-        ws_url = 'wss://api.kalshi.co/trade-api/ws/v2'
+        api_base_url = 'https://api.elections.kalshi.com/trade-api/v2/'
+        ws_url = 'wss://api.elections.kalshi.com/trade-api/ws/v2'
     else:  # demo
         api_base_url = 'https://demo-api.kalshi.co/trade-api/v2/'
         ws_url = 'wss://demo-api.kalshi.co/trade-api/ws/v2'
@@ -86,7 +92,7 @@ def get_config() -> KalshiConfig:
             key_path = Path(key_file)
             if not key_path.is_absolute():
                 # Make relative paths relative to project root
-                key_path = Path(__file__).parent.parent.parent / key_path
+                key_path = Path(__file__).parent.parent.parent.parent / key_path
             
             # Expand user home directory if present
             key_path = key_path.expanduser()
@@ -98,7 +104,7 @@ def get_config() -> KalshiConfig:
                     raise ValueError(f"Failed to read private key from {key_path}: {e}")
             else:
                 # Provide helpful error message
-                available_keys = list(Path(__file__).parent.parent.parent.glob("keys/*.key"))
+                available_keys = list(Path(__file__).parent.parent.parent.parent.glob("keys/*.key"))
                 if available_keys:
                     key_names = [k.name for k in available_keys]
                     raise ValueError(
diff --git a/src/data_pipeline/data_sources/espn/models.py b/src/data_pipeline/data_sources/espn/models.py
index fa85efaf..dd777815 100644
--- a/src/data_pipeline/data_sources/espn/models.py
+++ b/src/data_pipeline/data_sources/espn/models.py
@@ -41,6 +41,8 @@ class EventType(Enum):
     QUARTER_END = "quarter_end"
     HALF_END = "half_end"
     GAME_END = "game_end"
+    TWO_POINT_CONVERSION = "two_point_conversion"
+    PENALTY = "penalty"
 
 
 @dataclass
diff --git a/src/data_pipeline/data_sources/kalshi/auth.py b/src/data_pipeline/data_sources/kalshi/auth.py
index 7e82e0ba..7f0cb276 100644
--- a/src/data_pipeline/data_sources/kalshi/auth.py
+++ b/src/data_pipeline/data_sources/kalshi/auth.py
@@ -11,7 +11,7 @@
 from cryptography.hazmat.primitives.asymmetric import padding
 from cryptography.hazmat.backends import default_backend
 
-from ...config import KalshiConfig
+from ...config.settings import KalshiConfig
 
 
 class KalshiAuth:
@@ -25,8 +25,39 @@ def __init__(self, config: Optional[KalshiConfig] = None):
             config: Optional KalshiConfig instance. If not provided, will get from environment
         """
         if config is None:
-            from ..config import get_config
-            config = get_config()
+            # Use environment to create config
+            import os
+            from pathlib import Path
+            from dotenv import load_dotenv
+            
+            env_path = Path(__file__).parent.parent.parent.parent.parent / '.env'
+            load_dotenv(env_path)
+            
+            from ...config.settings import KalshiConfig
+            
+            environment = os.getenv("KALSHI_ENVIRONMENT", "prod")
+            api_base_url = f"https://api.elections.kalshi.com/trade-api/v2" if environment == "prod" else "https://demo-api.kalshi.co/trade-api/v2"
+            ws_url = f"wss://api.elections.kalshi.com/trade-api/ws/v2" if environment == "prod" else "wss://demo-api.kalshi.co/trade-api/ws/v2"
+            
+            # Load private key from file  
+            private_key_file = os.getenv("KALSHI_PRIVATE_KEY_FILE", "./keys/kalshi_prod_private.key")
+            if not private_key_file.startswith('/'):
+                # Relative path - resolve from project root
+                key_path = Path(__file__).parent.parent.parent.parent.parent / private_key_file
+            else:
+                # Absolute path
+                key_path = Path(private_key_file)
+            
+            with open(key_path, 'r') as f:
+                private_key = f.read()
+            
+            config = KalshiConfig(
+                api_key_id=os.getenv("KALSHI_API_KEY_ID"),
+                private_key=private_key,
+                environment=environment,
+                api_base_url=api_base_url,
+                ws_url=ws_url
+            )
         
         self.config = config
         self.api_key_id = config.api_key_id
diff --git a/src/data_pipeline/data_sources/kalshi/client.py b/src/data_pipeline/data_sources/kalshi/client.py
index c2962ee8..0d649fb2 100644
--- a/src/data_pipeline/data_sources/kalshi/client.py
+++ b/src/data_pipeline/data_sources/kalshi/client.py
@@ -8,7 +8,12 @@
 from urllib.parse import urljoin
 
 from .auth import KalshiAuth
-from ...config import KalshiConfig
+
+# Import for type hints - will be redefined in __init__ if needed
+try:
+    from ...config.settings import KalshiConfig
+except ImportError:
+    KalshiConfig = None
 
 
 class KalshiClient:
@@ -23,8 +28,28 @@ def __init__(self, config: Optional[KalshiConfig] = None, auth: Optional[KalshiA
             auth: Optional KalshiAuth instance
         """
         if config is None:
-            from ...config import get_config
-            config = get_config()
+            # Create basic config from environment
+            import os
+            from pathlib import Path
+            from dotenv import load_dotenv
+            
+            # Load env
+            env_path = Path(__file__).parent.parent.parent.parent.parent / '.env'
+            load_dotenv(env_path)
+            
+            from ...config.settings import KalshiConfig
+            
+            environment = os.getenv("KALSHI_ENVIRONMENT", "prod")
+            api_base_url = f"https://api.elections.kalshi.com/trade-api/v2" if environment == "prod" else "https://demo-api.kalshi.co/trade-api/v2"
+            ws_url = f"wss://api.elections.kalshi.com/trade-api/ws/v2" if environment == "prod" else "wss://demo-api.kalshi.co/trade-api/ws/v2"
+            
+            config = KalshiConfig(
+                api_key_id=os.getenv("KALSHI_API_KEY_ID"),
+                private_key=os.getenv("KALSHI_PRIVATE_KEY"),
+                environment=environment,
+                api_base_url=api_base_url,
+                ws_url=ws_url
+            )
         
         self.config = config
         self.auth = auth or KalshiAuth(config)
@@ -54,15 +79,21 @@ def _make_request(
         if not path.startswith('/'):
             path = '/' + path
         
-        # Get authentication headers
-        headers = self.auth.get_auth_headers(method, path)
+        # Get authentication headers with full path for signing
+        # The signature needs the full path including /trade-api/v2
+        full_path = path
+        if '/trade-api/v2' in self.base_url and not path.startswith('/trade-api/v2'):
+            full_path = '/trade-api/v2' + path
+        
+        headers = self.auth.get_auth_headers(method, full_path)
         
         # Add content type for JSON requests
         if json_data is not None:
             headers['Content-Type'] = 'application/json'
         
-        # Build full URL
-        url = urljoin(self.base_url, path.lstrip('/'))
+        # Build full URL - ensure base_url ends with / for proper joining
+        base_url = self.base_url.rstrip('/') + '/'
+        url = urljoin(base_url, path.lstrip('/'))
         
         # Make request
         response = self.session.request(
@@ -135,7 +166,7 @@ def get_markets(
         if status:
             params['status'] = status
         
-        return self.get('/trade-api/v2/markets', params=params)
+        return self.get('/markets', params=params)
     
     def get_all_markets(
         self,
diff --git a/src/data_pipeline/orchestration/unified_stream_manager.py b/src/data_pipeline/orchestration/unified_stream_manager.py
index 466ddebd..5d1a41fe 100644
--- a/src/data_pipeline/orchestration/unified_stream_manager.py
+++ b/src/data_pipeline/orchestration/unified_stream_manager.py
@@ -1,6 +1,6 @@
 """
 Stream Manager Service
-Unified streaming manager for all data sources - Agentuity compliant
+Unified streaming manager for all data sources - SDK compliant
 Single source of truth for WebSocket connections and data correlation
 """
 
@@ -127,7 +127,7 @@ class StreamManager:
     Unified Stream Manager - Single source of truth for all streaming data
     
     Manages all WebSocket connections, correlates data, and publishes to agents
-    via Agentuity messaging system.
+    via SDK messaging system.
     """
     
     def __init__(self, agent_context=None):
@@ -135,7 +135,7 @@ def __init__(self, agent_context=None):
         Initialize Stream Manager
         
         Args:
-            agent_context: Agentuity AgentContext for messaging
+            agent_context: SDK AgentContext for messaging
         """
         self.agent_context = agent_context
         
@@ -147,7 +147,7 @@ def __init__(self, agent_context=None):
         # Market contexts
         self.markets: Dict[str, MarketContext] = {}
         
-        # Event subscribers (for non-Agentuity use)
+        # Event subscribers (for non-SDK use)
         self.event_handlers: Dict[EventType, List[Callable]] = {}
         
         # State
@@ -198,10 +198,10 @@ async def initialize(self):
             from src.data_pipeline.data_sources.kalshi.auth import KalshiAuth
             from src.data_pipeline.config.settings import KalshiConfig
             
-            # Get environment settings
+            # Get environment settings - UPDATED with correct API URLs
             environment = os.getenv("KALSHI_ENVIRONMENT", "demo")
-            api_base_url = f"https://trading-api.kalshi.com/trade-api/v2" if environment == "prod" else "https://demo-api.kalshi.co/trade-api/v2"
-            ws_url = f"wss://trading-api.kalshi.com/trade-api/ws/v2" if environment == "prod" else "wss://demo-api.kalshi.co/trade-api/ws/v2"
+            api_base_url = f"https://api.elections.kalshi.com/trade-api/v2" if environment == "prod" else "https://demo-api.kalshi.co/trade-api/v2"
+            ws_url = f"wss://api.elections.kalshi.com/trade-api/ws/v2" if environment == "prod" else "wss://demo-api.kalshi.co/trade-api/ws/v2"
             
             config = KalshiConfig(
                 api_key_id=kalshi_key_id,
@@ -415,6 +415,153 @@ async def track_market(
             }
         ))
     
+    async def track_sport(self, sport: str, limit: int = 50) -> List[str]:
+        """
+        Discover and track all markets for a sport
+        
+        Args:
+            sport: Sport name ("nfl", "cfp")
+            limit: Maximum number of markets to track
+        
+        Returns:
+            List of market tickers being tracked
+        """
+        from ..data_sources.kalshi.market_discovery import KalshiMarketDiscovery
+        from ..sports_config import Sport
+        
+        # Map string to enum
+        sport_enum = None
+        if sport.lower() == "nfl":
+            sport_enum = Sport.NFL
+        elif sport.lower() == "cfp":
+            sport_enum = Sport.CFP
+        else:
+            logger.error(f"Unsupported sport: {sport}")
+            return []
+        
+        # Discover markets
+        discovery = KalshiMarketDiscovery()
+        markets = await discovery.discover_sport_markets(sport_enum)
+        
+        if not markets:
+            logger.warning(f"No active markets found for {sport}")
+            return []
+        
+        # Limit markets if requested
+        markets = markets[:limit]
+        
+        logger.info(f"Tracking {len(markets)} {sport.upper()} markets")
+        
+        # Track each market
+        tracked_tickers = []
+        for market in markets:
+            try:
+                await self.track_market(
+                    market_ticker=market.ticker,
+                    game_id=None,  # ESPN game ID not available from Kalshi
+                    home_team=market.home_team,
+                    away_team=market.away_team,
+                    sport=sport.lower()
+                )
+                tracked_tickers.append(market.ticker)
+                logger.info(f"Tracking {market.display_name} ({market.ticker})")
+                
+            except Exception as e:
+                logger.error(f"Failed to track market {market.ticker}: {e}")
+        
+        return tracked_tickers
+    
+    async def track_nfl_markets(self, limit: int = 50) -> List[str]:
+        """Track NFL markets"""
+        return await self.track_sport("nfl", limit)
+    
+    async def track_cfp_markets(self, limit: int = 50) -> List[str]:
+        """Track CFP markets"""
+        return await self.track_sport("cfp", limit)
+    
+    async def track_team_markets(self, sport: str, team_name: str) -> List[str]:
+        """
+        Track all markets for a specific team
+        
+        Args:
+            sport: Sport name ("nfl", "cfp") 
+            team_name: Team name (e.g., "PHI", "DAL")
+        
+        Returns:
+            List of market tickers being tracked
+        """
+        from ..data_sources.kalshi.market_discovery import KalshiMarketDiscovery
+        from ..sports_config import Sport
+        
+        # Map string to enum
+        sport_enum = Sport.NFL if sport.lower() == "nfl" else Sport.CFP
+        
+        # Discover team markets
+        discovery = KalshiMarketDiscovery()
+        markets = await discovery.find_team_markets(sport_enum, team_name)
+        
+        logger.info(f"Found {len(markets)} markets for {team_name}")
+        
+        # Track each market
+        tracked_tickers = []
+        for market in markets:
+            try:
+                await self.track_market(
+                    market_ticker=market.ticker,
+                    home_team=market.home_team,
+                    away_team=market.away_team,
+                    sport=sport.lower()
+                )
+                tracked_tickers.append(market.ticker)
+                logger.info(f"Tracking {market.display_name} ({market.ticker})")
+                
+            except Exception as e:
+                logger.error(f"Failed to track market {market.ticker}: {e}")
+        
+        return tracked_tickers
+    
+    async def track_game_markets(self, sport: str, home_team: str, away_team: str) -> List[str]:
+        """
+        Track all markets for a specific game
+        
+        Args:
+            sport: Sport name ("nfl", "cfp")
+            home_team: Home team name
+            away_team: Away team name
+        
+        Returns:
+            List of market tickers being tracked
+        """
+        from ..data_sources.kalshi.market_discovery import KalshiMarketDiscovery
+        from ..sports_config import Sport
+        
+        # Map string to enum
+        sport_enum = Sport.NFL if sport.lower() == "nfl" else Sport.CFP
+        
+        # Discover game markets
+        discovery = KalshiMarketDiscovery()
+        markets = await discovery.find_game_markets(sport_enum, home_team, away_team)
+        
+        logger.info(f"Found {len(markets)} markets for {away_team} @ {home_team}")
+        
+        # Track each market
+        tracked_tickers = []
+        for market in markets:
+            try:
+                await self.track_market(
+                    market_ticker=market.ticker,
+                    home_team=market.home_team,
+                    away_team=market.away_team,
+                    sport=sport.lower()
+                )
+                tracked_tickers.append(market.ticker)
+                logger.info(f"Tracking {market.display_name} ({market.ticker})")
+                
+            except Exception as e:
+                logger.error(f"Failed to track market {market.ticker}: {e}")
+        
+        return tracked_tickers
+    
     async def _handle_kalshi_message(self, message: Dict[str, Any]):
         """Process Kalshi WebSocket messages"""
         try:
@@ -1045,7 +1192,7 @@ async def stop(self):
         logger.info(f"Stream Manager stopped. Events processed: {self.events_processed}")
 
 
-# Standalone usage (for testing without Agentuity)
+# Standalone usage (for testing without SDK)
 async def example_usage():
     """Example of using StreamManager standalone"""
     
diff --git a/src/data_pipeline/reliability/resilience_coordinator.py b/src/data_pipeline/reliability/resilience_coordinator.py
index c5aa9704..ba72247d 100644
--- a/src/data_pipeline/reliability/resilience_coordinator.py
+++ b/src/data_pipeline/reliability/resilience_coordinator.py
@@ -74,7 +74,7 @@ def __init__(self, agent_context=None):
         Initialize resilience coordinator
         
         Args:
-            agent_context: Optional Agentuity context for KV storage
+            agent_context: Optional SDK context for KV storage
         """
         self.agent_context = agent_context
         self.services: Dict[str, ServiceConfig] = {}
diff --git a/src/data_pipeline/state_manager.py b/src/data_pipeline/state_manager.py
index 71fcfabb..ba379a3f 100644
--- a/src/data_pipeline/state_manager.py
+++ b/src/data_pipeline/state_manager.py
@@ -1,6 +1,6 @@
 """
 State Manager - Manages agent state with hot/warm/cold storage tiers
-Provides consistent state management across all agents using Agentuity KV storage
+Provides consistent state management across all agents using SDK KV storage
 """
 
 import json
@@ -170,7 +170,7 @@ def __init__(self, hot_cache_size: int = 100):
     
     async def save_state(
         self, 
-        context,  # Agentuity context
+        context,  # SDK context
         namespace: str,
         key: str,
         value: Any,
@@ -180,7 +180,7 @@ async def save_state(
         Save state to appropriate tier
         
         Args:
-            context: Agentuity context with KV access
+            context: SDK context with KV access
             namespace: Storage namespace
             key: State key
             value: State value
@@ -210,7 +210,7 @@ async def save_state(
     
     async def restore_state(
         self,
-        context,  # Agentuity context
+        context,  # SDK context
         namespace: str,
         key: str,
         default: Any = None
@@ -219,7 +219,7 @@ async def restore_state(
         Restore state from storage tiers
         
         Args:
-            context: Agentuity context with KV access
+            context: SDK context with KV access
             namespace: Storage namespace
             key: State key
             default: Default value if not found
@@ -255,7 +255,7 @@ async def save_agent_state(self, context, agent_name: str, state: Dict[str, Any]
         Save complete agent state
         
         Args:
-            context: Agentuity context
+            context: SDK context
             agent_name: Name of the agent
             state: Agent state dictionary
             
@@ -275,7 +275,7 @@ async def restore_agent_state(self, context, agent_name: str) -> Dict[str, Any]:
         Restore agent state
         
         Args:
-            context: Agentuity context
+            context: SDK context
             agent_name: Name of the agent
             
         Returns:
@@ -337,7 +337,7 @@ async def get_or_compute(
         Get cached value or compute it
         
         Args:
-            context: Agentuity context
+            context: SDK context
             key: Cache key
             compute_fn: Async function to compute value
             ttl: Time to live in seconds (default 5 minutes)
diff --git a/src/hybrid_pipeline/__init__.py b/src/hybrid_pipeline/__init__.py
new file mode 100644
index 00000000..de43fb60
--- /dev/null
+++ b/src/hybrid_pipeline/__init__.py
@@ -0,0 +1,38 @@
+"""
+Hybrid Data Pipeline Module
+
+Seamless switching between live API data and synthetic data generation
+based on training requirements, API costs, and agent performance needs.
+"""
+
+from .data_orchestrator import (
+    HybridDataOrchestrator,
+    DataSource,
+    DataMode,
+    CostThreshold,
+    SwitchingStrategy
+)
+from .cost_monitor import (
+    APITracker,
+    CostAlert,
+    BudgetManager
+)
+from .adaptive_scheduler import (
+    AdaptiveScheduler,
+    SchedulingPolicy,
+    TrainingPhase
+)
+
+__all__ = [
+    'HybridDataOrchestrator',
+    'DataSource',
+    'DataMode', 
+    'CostThreshold',
+    'SwitchingStrategy',
+    'APITracker',
+    'CostAlert',
+    'BudgetManager',
+    'AdaptiveScheduler',
+    'SchedulingPolicy',
+    'TrainingPhase'
+]
\ No newline at end of file
diff --git a/src/hybrid_pipeline/adaptive_scheduler.py b/src/hybrid_pipeline/adaptive_scheduler.py
new file mode 100644
index 00000000..ba0cd3d2
--- /dev/null
+++ b/src/hybrid_pipeline/adaptive_scheduler.py
@@ -0,0 +1,908 @@
+"""
+Adaptive Scheduler for Hybrid Data Pipeline
+
+Intelligently schedules data requests and training sessions based on
+agent performance, cost optimization, and system resources.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Callable, Tuple
+from datetime import datetime, timedelta
+from enum import Enum
+import asyncio
+import logging
+import json
+from collections import defaultdict, deque
+import heapq
+import random
+
+from .data_orchestrator import DataSource, DataMode, HybridDataOrchestrator
+from .cost_monitor import BudgetManager, APITracker
+from ..training.agent_analytics import AgentAnalytics
+
+
+class TrainingPhase(Enum):
+    """Different phases of agent training"""
+    INITIAL = "initial"
+    FOUNDATION = "foundation"
+    ADVANCED = "advanced"
+    VALIDATION = "validation"
+    PRODUCTION_PREP = "production_prep"
+    MAINTENANCE = "maintenance"
+
+
+class SchedulingPolicy(Enum):
+    """Scheduling policy options"""
+    COST_OPTIMIZED = "cost_optimized"
+    PERFORMANCE_OPTIMIZED = "performance_optimized"
+    BALANCED = "balanced"
+    AGGRESSIVE = "aggressive"
+    CONSERVATIVE = "conservative"
+
+
+class Priority(Enum):
+    """Task priority levels"""
+    LOW = 1
+    NORMAL = 2
+    HIGH = 3
+    CRITICAL = 4
+
+
+@dataclass
+class TrainingTask:
+    """Individual training task definition"""
+    task_id: str
+    agent_id: str
+    task_type: str  # "scenario_training", "validation", "edge_case_practice"
+    priority: Priority
+    estimated_cost: float
+    estimated_duration: timedelta
+    data_requirements: Dict[str, Any]
+    preferred_data_source: DataSource
+    created_at: datetime = field(default_factory=datetime.now)
+    scheduled_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    status: str = "pending"  # pending, scheduled, running, completed, failed
+    retry_count: int = 0
+    max_retries: int = 3
+    
+    def __lt__(self, other):
+        """For priority queue ordering"""
+        return (self.priority.value, self.scheduled_at or datetime.max) > (other.priority.value, other.scheduled_at or datetime.max)
+
+
+@dataclass
+class SchedulingContext:
+    """Context for scheduling decisions"""
+    current_time: datetime
+    available_budget: float
+    system_load: float
+    api_rate_limits: Dict[str, int]
+    agent_performance_metrics: Dict[str, Dict]
+    active_tasks: List[TrainingTask]
+    failed_tasks: List[TrainingTask]
+    time_window: timedelta = timedelta(hours=24)
+
+
+class AdaptiveScheduler:
+    """
+    Adaptive scheduler that optimizes training task scheduling based on:
+    - Agent performance and learning needs
+    - API cost constraints and budget optimization
+    - System resources and capacity
+    - Training phase requirements
+    - Historical performance data
+    """
+    
+    def __init__(
+        self,
+        orchestrator: HybridDataOrchestrator,
+        budget_manager: BudgetManager,
+        api_tracker: APITracker,
+        agent_analytics: AgentAnalytics
+    ):
+        self.orchestrator = orchestrator
+        self.budget_manager = budget_manager
+        self.api_tracker = api_tracker
+        self.agent_analytics = agent_analytics
+        self.logger = logging.getLogger(__name__)
+        
+        # Configuration
+        self.scheduling_policy = SchedulingPolicy.BALANCED
+        self.max_concurrent_tasks = 5
+        self.planning_horizon = timedelta(hours=24)
+        self.rebalance_interval = timedelta(minutes=30)
+        
+        # Task management
+        self.task_queue: List[TrainingTask] = []
+        self.active_tasks: Dict[str, TrainingTask] = {}
+        self.completed_tasks: List[TrainingTask] = []
+        self.failed_tasks: List[TrainingTask] = []
+        
+        # Agent training phases
+        self.agent_phases: Dict[str, TrainingPhase] = {}
+        self.phase_requirements: Dict[TrainingPhase, Dict[str, Any]] = {
+            TrainingPhase.INITIAL: {
+                "synthetic_data_ratio": 1.0,
+                "scenario_diversity": 0.3,
+                "edge_case_ratio": 0.05,
+                "validation_frequency": 0.1
+            },
+            TrainingPhase.FOUNDATION: {
+                "synthetic_data_ratio": 0.9,
+                "scenario_diversity": 0.5,
+                "edge_case_ratio": 0.1,
+                "validation_frequency": 0.15
+            },
+            TrainingPhase.ADVANCED: {
+                "synthetic_data_ratio": 0.7,
+                "scenario_diversity": 0.8,
+                "edge_case_ratio": 0.2,
+                "validation_frequency": 0.2
+            },
+            TrainingPhase.VALIDATION: {
+                "synthetic_data_ratio": 0.3,
+                "scenario_diversity": 1.0,
+                "edge_case_ratio": 0.3,
+                "validation_frequency": 0.5
+            },
+            TrainingPhase.PRODUCTION_PREP: {
+                "synthetic_data_ratio": 0.1,
+                "scenario_diversity": 0.6,
+                "edge_case_ratio": 0.1,
+                "validation_frequency": 0.8
+            }
+        }
+        
+        # Scheduling metrics
+        self.scheduling_history: List[Dict[str, Any]] = []
+        self.performance_metrics: Dict[str, float] = defaultdict(float)
+        
+        # Task execution callbacks
+        self.task_callbacks: Dict[str, Callable] = {}
+        
+    async def initialize(self) -> None:
+        """Initialize the adaptive scheduler"""
+        try:
+            self.logger.info("Initializing Adaptive Scheduler")
+            
+            # Initialize agent phases
+            await self._initialize_agent_phases()
+            
+            # Start background scheduling loop
+            asyncio.create_task(self._scheduling_loop())
+            
+            self.logger.info("Adaptive Scheduler initialized successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize scheduler: {e}")
+            raise
+    
+    async def _initialize_agent_phases(self) -> None:
+        """Initialize training phases for all agents"""
+        try:
+            # Get all agents from analytics
+            for agent_id in self.agent_analytics.decision_history.keys():
+                # Determine initial phase based on agent experience
+                analytics = await self.agent_analytics.get_agent_analytics(agent_id)
+                
+                if analytics.get("total_decisions", 0) == 0:
+                    phase = TrainingPhase.INITIAL
+                elif analytics.get("total_decisions", 0) < 100:
+                    phase = TrainingPhase.FOUNDATION
+                elif analytics.get("latest_snapshot", {}).get("win_rate", 0) < 0.5:
+                    phase = TrainingPhase.ADVANCED
+                else:
+                    phase = TrainingPhase.VALIDATION
+                
+                self.agent_phases[agent_id] = phase
+                self.logger.info(f"Agent {agent_id} initialized in {phase.value} phase")
+                
+        except Exception as e:
+            self.logger.error(f"Failed to initialize agent phases: {e}")
+    
+    async def schedule_training_task(
+        self,
+        agent_id: str,
+        task_type: str,
+        priority: Priority = Priority.NORMAL,
+        data_requirements: Optional[Dict[str, Any]] = None,
+        preferred_time: Optional[datetime] = None
+    ) -> str:
+        """Schedule a new training task"""
+        try:
+            task_id = f"{agent_id}_{task_type}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            
+            # Get agent's current phase
+            agent_phase = self.agent_phases.get(agent_id, TrainingPhase.INITIAL)
+            
+            # Determine optimal data source and requirements
+            optimal_source, requirements = await self._determine_optimal_task_config(
+                agent_id, task_type, agent_phase, data_requirements
+            )
+            
+            # Estimate cost and duration
+            estimated_cost = await self._estimate_task_cost(task_type, requirements, optimal_source)
+            estimated_duration = self._estimate_task_duration(task_type, requirements)
+            
+            # Create task
+            task = TrainingTask(
+                task_id=task_id,
+                agent_id=agent_id,
+                task_type=task_type,
+                priority=priority,
+                estimated_cost=estimated_cost,
+                estimated_duration=estimated_duration,
+                data_requirements=requirements,
+                preferred_data_source=optimal_source
+            )
+            
+            # Schedule the task
+            await self._schedule_task(task, preferred_time)
+            
+            self.logger.info(f"Scheduled task {task_id} for agent {agent_id}")
+            return task_id
+            
+        except Exception as e:
+            self.logger.error(f"Failed to schedule training task: {e}")
+            raise
+    
+    async def _determine_optimal_task_config(
+        self,
+        agent_id: str,
+        task_type: str,
+        agent_phase: TrainingPhase,
+        data_requirements: Optional[Dict[str, Any]]
+    ) -> Tuple[DataSource, Dict[str, Any]]:
+        """Determine optimal configuration for a training task"""
+        try:
+            # Get phase requirements
+            phase_config = self.phase_requirements[agent_phase]
+            
+            # Base requirements from phase
+            requirements = {
+                "count": data_requirements.get("count", 100) if data_requirements else 100,
+                "scenario_diversity": phase_config["scenario_diversity"],
+                "edge_case_ratio": phase_config["edge_case_ratio"],
+                "include_edge_cases": phase_config["edge_case_ratio"] > 0.1,
+                "training_phase": agent_phase.value,
+                "agent_id": agent_id
+            }
+            
+            # Override with specific requirements
+            if data_requirements:
+                requirements.update(data_requirements)
+            
+            # Determine optimal data source
+            synthetic_ratio = phase_config["synthetic_data_ratio"]
+            
+            # Adjust based on scheduling policy
+            if self.scheduling_policy == SchedulingPolicy.COST_OPTIMIZED:
+                # Favor synthetic data for cost savings
+                synthetic_ratio = min(1.0, synthetic_ratio * 1.2)
+            elif self.scheduling_policy == SchedulingPolicy.PERFORMANCE_OPTIMIZED:
+                # Favor live data for realism
+                synthetic_ratio = max(0.1, synthetic_ratio * 0.8)
+            
+            # Select data source based on ratio and current context
+            if synthetic_ratio > 0.8:
+                optimal_source = DataSource.SYNTHETIC
+            elif synthetic_ratio < 0.3:
+                optimal_source = DataSource.LIVE_API
+            else:
+                optimal_source = DataSource.HYBRID
+            
+            # Consider current budget constraints
+            daily_budget_used = self.budget_manager.get_budget_status().get("daily_cost", 0)
+            if daily_budget_used > 50:  # If already spent significant amount
+                optimal_source = DataSource.SYNTHETIC
+            
+            return optimal_source, requirements
+            
+        except Exception as e:
+            self.logger.error(f"Failed to determine optimal task config: {e}")
+            return DataSource.SYNTHETIC, {"count": 100}
+    
+    async def _estimate_task_cost(
+        self,
+        task_type: str,
+        requirements: Dict[str, Any],
+        data_source: DataSource
+    ) -> float:
+        """Estimate the cost of a training task"""
+        try:
+            base_cost = 0.0
+            data_count = requirements.get("count", 100)
+            
+            if data_source == DataSource.SYNTHETIC:
+                base_cost = data_count * 0.001  # Very low cost for synthetic
+            elif data_source == DataSource.LIVE_API:
+                base_cost = data_count * 0.01   # Higher cost for live API
+            elif data_source == DataSource.CACHED:
+                base_cost = 0.0  # No cost for cached data
+            else:  # HYBRID
+                # Mix of costs
+                base_cost = data_count * 0.005
+            
+            # Adjust for task complexity
+            complexity_multiplier = 1.0
+            if task_type == "edge_case_practice":
+                complexity_multiplier = 1.5
+            elif task_type == "validation":
+                complexity_multiplier = 2.0
+            
+            # Adjust for special requirements
+            if requirements.get("include_edge_cases", False):
+                complexity_multiplier *= 1.2
+            
+            if requirements.get("scenario_diversity", 0) > 0.8:
+                complexity_multiplier *= 1.3
+            
+            return base_cost * complexity_multiplier
+            
+        except Exception as e:
+            self.logger.error(f"Failed to estimate task cost: {e}")
+            return 1.0  # Default cost
+    
+    def _estimate_task_duration(self, task_type: str, requirements: Dict[str, Any]) -> timedelta:
+        """Estimate the duration of a training task"""
+        try:
+            base_duration = timedelta(minutes=30)  # Base 30 minutes
+            data_count = requirements.get("count", 100)
+            
+            # Scale with data count
+            duration_multiplier = max(1.0, data_count / 100)
+            
+            # Adjust for task type
+            if task_type == "scenario_training":
+                duration_multiplier *= 1.0
+            elif task_type == "validation":
+                duration_multiplier *= 1.5
+            elif task_type == "edge_case_practice":
+                duration_multiplier *= 2.0
+            
+            # Adjust for complexity
+            if requirements.get("scenario_diversity", 0) > 0.8:
+                duration_multiplier *= 1.2
+            
+            return base_duration * duration_multiplier
+            
+        except Exception as e:
+            self.logger.error(f"Failed to estimate task duration: {e}")
+            return timedelta(hours=1)  # Default duration
+    
+    async def _schedule_task(self, task: TrainingTask, preferred_time: Optional[datetime] = None) -> None:
+        """Schedule a task in the queue"""
+        try:
+            # Determine optimal scheduling time
+            if preferred_time:
+                scheduled_time = preferred_time
+            else:
+                scheduled_time = await self._find_optimal_schedule_time(task)
+            
+            task.scheduled_at = scheduled_time
+            task.status = "scheduled"
+            
+            # Add to priority queue
+            heapq.heappush(self.task_queue, task)
+            
+            # Record scheduling decision
+            self.scheduling_history.append({
+                "task_id": task.task_id,
+                "scheduled_at": scheduled_time.isoformat(),
+                "estimated_cost": task.estimated_cost,
+                "priority": task.priority.value,
+                "data_source": task.preferred_data_source.value,
+                "scheduling_policy": self.scheduling_policy.value
+            })
+            
+        except Exception as e:
+            self.logger.error(f"Failed to schedule task: {e}")
+            raise
+    
+    async def _find_optimal_schedule_time(self, task: TrainingTask) -> datetime:
+        """Find optimal time to schedule a task"""
+        try:
+            current_time = datetime.now()
+            
+            # Get scheduling context
+            context = await self._build_scheduling_context()
+            
+            # Base scheduling logic
+            if task.priority == Priority.CRITICAL:
+                return current_time  # Schedule immediately
+            
+            # Consider budget constraints
+            if task.estimated_cost > context.available_budget:
+                # Schedule for next budget period
+                return current_time + timedelta(hours=24)
+            
+            # Consider system load
+            if context.system_load > 0.8:
+                # Schedule when load is lower
+                return current_time + timedelta(hours=2)
+            
+            # Consider API rate limits
+            if task.preferred_data_source == DataSource.LIVE_API:
+                api_usage = context.api_rate_limits.get("live_api", 0)
+                if api_usage > 80:  # Near rate limit
+                    return current_time + timedelta(hours=1)
+            
+            # Policy-based scheduling
+            if self.scheduling_policy == SchedulingPolicy.COST_OPTIMIZED:
+                # Schedule during low-cost periods (example: off-peak hours)
+                if current_time.hour >= 9 and current_time.hour <= 17:
+                    return current_time.replace(hour=20, minute=0, second=0)
+            
+            # Default: schedule with small random delay to spread load
+            delay_minutes = random.randint(0, 30)
+            return current_time + timedelta(minutes=delay_minutes)
+            
+        except Exception as e:
+            self.logger.error(f"Failed to find optimal schedule time: {e}")
+            return datetime.now() + timedelta(minutes=5)  # Default short delay
+    
+    async def _build_scheduling_context(self) -> SchedulingContext:
+        """Build context for scheduling decisions"""
+        try:
+            current_time = datetime.now()
+            
+            # Get budget information
+            budget_status = self.budget_manager.get_budget_status()
+            available_budget = 0.0
+            if budget_status.get("budget_periods"):
+                for period_data in budget_status["budget_periods"].values():
+                    available_budget += period_data.get("remaining", 0)
+            
+            # Get system metrics
+            performance_metrics = self.api_tracker.get_performance_metrics()
+            system_load = performance_metrics.get("error_rate", 0) + (performance_metrics.get("avg_latency_ms", 0) / 1000)
+            
+            # Get API rate limit status (simplified)
+            api_rate_limits = {
+                "live_api": performance_metrics.get("requests_last_hour", 0),
+                "synthetic": 0  # No limits for synthetic
+            }
+            
+            # Get agent performance metrics
+            agent_metrics = {}
+            for agent_id in self.agent_phases.keys():
+                try:
+                    analytics = await self.agent_analytics.get_agent_analytics(agent_id, timedelta(hours=6))
+                    agent_metrics[agent_id] = analytics
+                except Exception as e:
+                    self.logger.warning(f"Failed to get analytics for {agent_id}: {e}")
+                    agent_metrics[agent_id] = {}
+            
+            return SchedulingContext(
+                current_time=current_time,
+                available_budget=available_budget,
+                system_load=min(1.0, system_load),
+                api_rate_limits=api_rate_limits,
+                agent_performance_metrics=agent_metrics,
+                active_tasks=list(self.active_tasks.values()),
+                failed_tasks=self.failed_tasks[-10:]  # Last 10 failures
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Failed to build scheduling context: {e}")
+            return SchedulingContext(
+                current_time=datetime.now(),
+                available_budget=100.0,
+                system_load=0.5,
+                api_rate_limits={},
+                agent_performance_metrics={},
+                active_tasks=[],
+                failed_tasks=[]
+            )
+    
+    async def _scheduling_loop(self) -> None:
+        """Main scheduling loop"""
+        try:
+            while True:
+                await asyncio.sleep(60)  # Check every minute
+                
+                current_time = datetime.now()
+                
+                # Execute scheduled tasks
+                await self._execute_ready_tasks(current_time)
+                
+                # Rebalance schedule periodically
+                if hasattr(self, '_last_rebalance'):
+                    if current_time - self._last_rebalance >= self.rebalance_interval:
+                        await self._rebalance_schedule()
+                        self._last_rebalance = current_time
+                else:
+                    self._last_rebalance = current_time
+                
+                # Update agent phases based on performance
+                await self._update_agent_phases()
+                
+                # Clean up old completed tasks
+                self._cleanup_old_tasks()
+                
+        except Exception as e:
+            self.logger.error(f"Scheduling loop error: {e}")
+            await asyncio.sleep(300)  # Wait 5 minutes before retrying
+    
+    async def _execute_ready_tasks(self, current_time: datetime) -> None:
+        """Execute tasks that are ready to run"""
+        try:
+            # Check for tasks ready to execute
+            ready_tasks = []
+            
+            while (self.task_queue and 
+                   self.task_queue[0].scheduled_at and 
+                   self.task_queue[0].scheduled_at <= current_time and
+                   len(self.active_tasks) < self.max_concurrent_tasks):
+                
+                task = heapq.heappop(self.task_queue)
+                ready_tasks.append(task)
+            
+            # Execute ready tasks
+            for task in ready_tasks:
+                try:
+                    # Check if task is still viable (budget, etc.)
+                    can_execute, reason = await self._can_execute_task(task)
+                    
+                    if can_execute:
+                        asyncio.create_task(self._execute_task(task))
+                    else:
+                        self.logger.warning(f"Cannot execute task {task.task_id}: {reason}")
+                        # Reschedule or fail the task
+                        if task.retry_count < task.max_retries:
+                            task.retry_count += 1
+                            task.scheduled_at = current_time + timedelta(minutes=30)
+                            heapq.heappush(self.task_queue, task)
+                        else:
+                            task.status = "failed"
+                            self.failed_tasks.append(task)
+                
+                except Exception as e:
+                    self.logger.error(f"Failed to execute task {task.task_id}: {e}")
+                    task.status = "failed"
+                    self.failed_tasks.append(task)
+                    
+        except Exception as e:
+            self.logger.error(f"Failed to execute ready tasks: {e}")
+    
+    async def _can_execute_task(self, task: TrainingTask) -> Tuple[bool, str]:
+        """Check if a task can be executed now"""
+        try:
+            # Budget check
+            is_allowed, budget_reason = self.budget_manager.is_request_allowed(task.estimated_cost)
+            if not is_allowed:
+                return False, budget_reason
+            
+            # Concurrency check
+            if len(self.active_tasks) >= self.max_concurrent_tasks:
+                return False, "Maximum concurrent tasks reached"
+            
+            # Agent-specific checks
+            agent_tasks = [t for t in self.active_tasks.values() if t.agent_id == task.agent_id]
+            if len(agent_tasks) >= 2:  # Max 2 tasks per agent
+                return False, "Agent has too many active tasks"
+            
+            return True, "Task can be executed"
+            
+        except Exception as e:
+            self.logger.error(f"Failed to check task executability: {e}")
+            return False, str(e)
+    
+    async def _execute_task(self, task: TrainingTask) -> None:
+        """Execute a training task"""
+        try:
+            task.started_at = datetime.now()
+            task.status = "running"
+            self.active_tasks[task.task_id] = task
+            
+            self.logger.info(f"Executing task {task.task_id} for agent {task.agent_id}")
+            
+            # Get training data from orchestrator
+            training_data = await self.orchestrator.get_training_data(
+                data_type=task.task_type,
+                count=task.data_requirements.get("count", 100),
+                specific_requirements=task.data_requirements
+            )
+            
+            # Execute training callback if available
+            callback = self.task_callbacks.get(task.task_type)
+            if callback:
+                await callback(task, training_data)
+            else:
+                # Default training execution (simplified)
+                await self._default_training_execution(task, training_data)
+            
+            # Mark task as completed
+            task.completed_at = datetime.now()
+            task.status = "completed"
+            self.completed_tasks.append(task)
+            
+            # Remove from active tasks
+            del self.active_tasks[task.task_id]
+            
+            # Update performance metrics
+            await self._update_task_performance_metrics(task, success=True)
+            
+            self.logger.info(f"Completed task {task.task_id}")
+            
+        except Exception as e:
+            self.logger.error(f"Task execution failed {task.task_id}: {e}")
+            task.status = "failed"
+            self.failed_tasks.append(task)
+            
+            if task.task_id in self.active_tasks:
+                del self.active_tasks[task.task_id]
+            
+            await self._update_task_performance_metrics(task, success=False)
+    
+    async def _default_training_execution(self, task: TrainingTask, training_data: List) -> None:
+        """Default training execution (placeholder)"""
+        # Simulate training time
+        await asyncio.sleep(2)  # 2 second simulation
+        
+        # In real implementation, this would:
+        # 1. Pass data to agent training system
+        # 2. Execute training scenarios
+        # 3. Collect performance metrics
+        # 4. Update agent memory systems
+        
+        self.logger.info(f"Simulated training execution for task {task.task_id} with {len(training_data)} data points")
+    
+    async def _update_task_performance_metrics(self, task: TrainingTask, success: bool) -> None:
+        """Update performance metrics for completed tasks"""
+        try:
+            # Calculate actual vs estimated metrics
+            if task.started_at and task.completed_at:
+                actual_duration = task.completed_at - task.started_at
+                estimated_duration = task.estimated_duration
+                
+                duration_accuracy = 1 - abs((actual_duration - estimated_duration).total_seconds()) / estimated_duration.total_seconds()
+                self.performance_metrics["duration_accuracy"] = (
+                    self.performance_metrics["duration_accuracy"] * 0.9 + duration_accuracy * 0.1
+                )
+            
+            # Update success rate
+            current_success_rate = self.performance_metrics.get("success_rate", 0.5)
+            new_success_rate = current_success_rate * 0.9 + (1.0 if success else 0.0) * 0.1
+            self.performance_metrics["success_rate"] = new_success_rate
+            
+            # Update cost accuracy (simplified)
+            self.performance_metrics["cost_accuracy"] = 0.85  # Placeholder
+            
+        except Exception as e:
+            self.logger.error(f"Failed to update task performance metrics: {e}")
+    
+    async def _rebalance_schedule(self) -> None:
+        """Rebalance the task schedule based on current conditions"""
+        try:
+            self.logger.info("Rebalancing task schedule")
+            
+            # Get current context
+            context = await self._build_scheduling_context()
+            
+            # Identify tasks that should be rescheduled
+            tasks_to_rebalance = []
+            
+            for task in list(self.task_queue):
+                # Check if task should be rescheduled based on new context
+                if self._should_reschedule_task(task, context):
+                    tasks_to_rebalance.append(task)
+            
+            # Remove and reschedule identified tasks
+            for task in tasks_to_rebalance:
+                self.task_queue.remove(task)
+                new_schedule_time = await self._find_optimal_schedule_time(task)
+                task.scheduled_at = new_schedule_time
+                heapq.heappush(self.task_queue, task)
+            
+            if tasks_to_rebalance:
+                self.logger.info(f"Rescheduled {len(tasks_to_rebalance)} tasks")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to rebalance schedule: {e}")
+    
+    def _should_reschedule_task(self, task: TrainingTask, context: SchedulingContext) -> bool:
+        """Determine if a task should be rescheduled"""
+        try:
+            # Don't reschedule high priority tasks
+            if task.priority in [Priority.HIGH, Priority.CRITICAL]:
+                return False
+            
+            # Reschedule if budget is tight and task is expensive
+            if task.estimated_cost > context.available_budget * 0.5:
+                return True
+            
+            # Reschedule if system load is high
+            if context.system_load > 0.8 and task.priority == Priority.LOW:
+                return True
+            
+            # Reschedule based on agent performance
+            agent_metrics = context.agent_performance_metrics.get(task.agent_id, {})
+            if agent_metrics.get("latest_snapshot", {}).get("learning_velocity", 0) < 0.2:
+                # Agent learning slowly, might want to delay advanced tasks
+                if task.task_type in ["validation", "edge_case_practice"]:
+                    return True
+            
+            return False
+            
+        except Exception as e:
+            self.logger.error(f"Failed to check if task should be rescheduled: {e}")
+            return False
+    
+    async def _update_agent_phases(self) -> None:
+        """Update agent training phases based on performance"""
+        try:
+            for agent_id, current_phase in self.agent_phases.items():
+                try:
+                    # Get recent analytics
+                    analytics = await self.agent_analytics.get_agent_analytics(agent_id, timedelta(hours=24))
+                    
+                    if not analytics or "latest_snapshot" not in analytics:
+                        continue
+                    
+                    snapshot = analytics["latest_snapshot"]
+                    
+                    # Phase progression logic
+                    new_phase = self._determine_agent_phase(current_phase, snapshot, analytics)
+                    
+                    if new_phase != current_phase:
+                        self.agent_phases[agent_id] = new_phase
+                        self.logger.info(f"Agent {agent_id} progressed from {current_phase.value} to {new_phase.value}")
+                        
+                        # Schedule phase transition tasks
+                        await self._schedule_phase_transition_tasks(agent_id, current_phase, new_phase)
+                
+                except Exception as e:
+                    self.logger.warning(f"Failed to update phase for agent {agent_id}: {e}")
+                    continue
+                    
+        except Exception as e:
+            self.logger.error(f"Failed to update agent phases: {e}")
+    
+    def _determine_agent_phase(self, current_phase: TrainingPhase, snapshot: Dict, analytics: Dict) -> TrainingPhase:
+        """Determine appropriate training phase for an agent"""
+        try:
+            total_decisions = analytics.get("total_decisions", 0)
+            win_rate = snapshot.get("win_rate", 0)
+            kelly_adherence = snapshot.get("kelly_adherence_score", 0)
+            learning_velocity = snapshot.get("learning_velocity", 0)
+            
+            # Phase transition criteria
+            if current_phase == TrainingPhase.INITIAL:
+                if total_decisions >= 50 and win_rate > 0.3:
+                    return TrainingPhase.FOUNDATION
+            
+            elif current_phase == TrainingPhase.FOUNDATION:
+                if total_decisions >= 200 and win_rate > 0.45 and kelly_adherence > 0.6:
+                    return TrainingPhase.ADVANCED
+            
+            elif current_phase == TrainingPhase.ADVANCED:
+                if total_decisions >= 500 and win_rate > 0.55 and kelly_adherence > 0.75:
+                    return TrainingPhase.VALIDATION
+            
+            elif current_phase == TrainingPhase.VALIDATION:
+                if total_decisions >= 1000 and win_rate > 0.6 and kelly_adherence > 0.8:
+                    return TrainingPhase.PRODUCTION_PREP
+            
+            # Regression checks
+            if win_rate < 0.3 or learning_velocity < 0.1:
+                # Agent struggling, may need to go back
+                if current_phase == TrainingPhase.PRODUCTION_PREP:
+                    return TrainingPhase.VALIDATION
+                elif current_phase == TrainingPhase.VALIDATION:
+                    return TrainingPhase.ADVANCED
+            
+            return current_phase
+            
+        except Exception as e:
+            self.logger.error(f"Failed to determine agent phase: {e}")
+            return current_phase
+    
+    async def _schedule_phase_transition_tasks(self, agent_id: str, old_phase: TrainingPhase, new_phase: TrainingPhase) -> None:
+        """Schedule tasks appropriate for phase transition"""
+        try:
+            # Schedule validation task to confirm readiness
+            await self.schedule_training_task(
+                agent_id=agent_id,
+                task_type="validation",
+                priority=Priority.HIGH,
+                data_requirements={
+                    "count": 50,
+                    "include_edge_cases": True,
+                    "phase_transition": True,
+                    "old_phase": old_phase.value,
+                    "new_phase": new_phase.value
+                }
+            )
+            
+            # Schedule new phase introduction task
+            await self.schedule_training_task(
+                agent_id=agent_id,
+                task_type="scenario_training",
+                priority=Priority.NORMAL,
+                data_requirements={
+                    "count": 100,
+                    "training_phase": new_phase.value,
+                    "phase_introduction": True
+                }
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Failed to schedule phase transition tasks: {e}")
+    
+    def _cleanup_old_tasks(self) -> None:
+        """Clean up old completed and failed tasks"""
+        try:
+            cutoff_time = datetime.now() - timedelta(days=7)
+            
+            # Clean completed tasks
+            self.completed_tasks = [
+                task for task in self.completed_tasks
+                if task.completed_at and task.completed_at > cutoff_time
+            ]
+            
+            # Clean failed tasks
+            self.failed_tasks = [
+                task for task in self.failed_tasks
+                if task.created_at > cutoff_time
+            ]
+            
+        except Exception as e:
+            self.logger.error(f"Failed to cleanup old tasks: {e}")
+    
+    def register_task_callback(self, task_type: str, callback: Callable) -> None:
+        """Register callback for specific task type"""
+        self.task_callbacks[task_type] = callback
+        self.logger.info(f"Registered callback for task type: {task_type}")
+    
+    def set_scheduling_policy(self, policy: SchedulingPolicy) -> None:
+        """Set the scheduling policy"""
+        old_policy = self.scheduling_policy
+        self.scheduling_policy = policy
+        self.logger.info(f"Changed scheduling policy from {old_policy.value} to {policy.value}")
+    
+    def get_scheduler_status(self) -> Dict[str, Any]:
+        """Get comprehensive scheduler status"""
+        try:
+            return {
+                "timestamp": datetime.now().isoformat(),
+                "scheduling_policy": self.scheduling_policy.value,
+                "queue_size": len(self.task_queue),
+                "active_tasks": len(self.active_tasks),
+                "completed_tasks": len(self.completed_tasks),
+                "failed_tasks": len(self.failed_tasks),
+                "agent_phases": {agent_id: phase.value for agent_id, phase in self.agent_phases.items()},
+                "performance_metrics": dict(self.performance_metrics),
+                "next_scheduled_task": self.task_queue[0].scheduled_at.isoformat() if self.task_queue else None,
+                "system_load": self.performance_metrics.get("system_load", 0.5)
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Failed to get scheduler status: {e}")
+            return {"error": str(e)}
+    
+    async def shutdown(self) -> None:
+        """Gracefully shutdown the scheduler"""
+        try:
+            self.logger.info("Shutting down Adaptive Scheduler")
+            
+            # Wait for active tasks to complete (with timeout)
+            timeout = 300  # 5 minutes
+            start_time = datetime.now()
+            
+            while self.active_tasks and (datetime.now() - start_time).seconds < timeout:
+                await asyncio.sleep(10)
+            
+            # Force stop remaining tasks
+            for task in self.active_tasks.values():
+                task.status = "cancelled"
+                self.failed_tasks.append(task)
+            
+            self.active_tasks.clear()
+            
+            self.logger.info("Adaptive Scheduler shutdown complete")
+            
+        except Exception as e:
+            self.logger.error(f"Error during scheduler shutdown: {e}")
\ No newline at end of file
diff --git a/src/hybrid_pipeline/cost_monitor.py b/src/hybrid_pipeline/cost_monitor.py
new file mode 100644
index 00000000..a375a044
--- /dev/null
+++ b/src/hybrid_pipeline/cost_monitor.py
@@ -0,0 +1,610 @@
+"""
+API Cost Monitor and Budget Management
+
+Tracks API usage costs, enforces budget limits, and provides
+cost optimization recommendations for hybrid data pipeline.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Callable, Any, Tuple
+from datetime import datetime, timedelta, date
+from enum import Enum
+import asyncio
+import logging
+import json
+from collections import defaultdict, deque
+
+
+class AlertLevel(Enum):
+    """Alert severity levels"""
+    INFO = "info"
+    WARNING = "warning"
+    CRITICAL = "critical"
+    EMERGENCY = "emergency"
+
+
+@dataclass
+class CostAlert:
+    """Cost alert definition"""
+    alert_id: str
+    level: AlertLevel
+    threshold: float
+    description: str
+    callback: Optional[Callable] = None
+    enabled: bool = True
+    last_triggered: Optional[datetime] = None
+    trigger_count: int = 0
+
+
+@dataclass
+class APIEndpoint:
+    """API endpoint cost configuration"""
+    name: str
+    base_cost: float
+    cost_per_request: float = 0.0
+    cost_per_data_unit: float = 0.0  # per KB, record, etc.
+    rate_limit_requests: int = 1000
+    rate_limit_window: timedelta = timedelta(hours=1)
+    current_usage: int = 0
+    window_start: datetime = field(default_factory=datetime.now)
+
+
+@dataclass
+class BudgetPeriod:
+    """Budget tracking for a specific time period"""
+    period_name: str  # "daily", "weekly", "monthly"
+    budget_limit: float
+    spent_amount: float = 0.0
+    period_start: datetime = field(default_factory=datetime.now)
+    period_end: datetime = field(default_factory=lambda: datetime.now() + timedelta(days=1))
+    
+    @property
+    def utilization_percent(self) -> float:
+        """Get budget utilization percentage"""
+        return (self.spent_amount / self.budget_limit) * 100 if self.budget_limit > 0 else 0
+    
+    @property
+    def remaining_budget(self) -> float:
+        """Get remaining budget amount"""
+        return max(0, self.budget_limit - self.spent_amount)
+
+
+class APITracker:
+    """
+    Tracks API usage, costs, and performance metrics for cost optimization.
+    """
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        
+        # API endpoints configuration
+        self.endpoints: Dict[str, APIEndpoint] = {}
+        
+        # Usage tracking
+        self.request_history: deque = deque(maxlen=10000)
+        self.cost_history: Dict[date, float] = defaultdict(float)
+        
+        # Performance metrics
+        self.latency_history: deque = deque(maxlen=1000)
+        self.error_history: deque = deque(maxlen=1000)
+        
+        # Cost breakdown
+        self.cost_by_endpoint: Dict[str, float] = defaultdict(float)
+        self.cost_by_hour: Dict[datetime, float] = defaultdict(float)
+        
+    def register_endpoint(self, endpoint: APIEndpoint) -> None:
+        """Register an API endpoint for tracking"""
+        self.endpoints[endpoint.name] = endpoint
+        self.logger.info(f"Registered API endpoint: {endpoint.name}")
+    
+    async def track_request(
+        self,
+        endpoint_name: str,
+        data_size: int = 0,
+        latency_ms: float = 0,
+        success: bool = True,
+        cost_override: Optional[float] = None
+    ) -> float:
+        """
+        Track an API request and return the cost incurred.
+        
+        Args:
+            endpoint_name: Name of the API endpoint
+            data_size: Size of data transferred (for cost calculation)
+            latency_ms: Request latency in milliseconds
+            success: Whether the request was successful
+            cost_override: Override calculated cost with specific amount
+            
+        Returns:
+            Cost incurred for this request
+        """
+        try:
+            timestamp = datetime.now()
+            
+            # Get endpoint configuration
+            endpoint = self.endpoints.get(endpoint_name)
+            if not endpoint:
+                self.logger.warning(f"Unknown endpoint: {endpoint_name}")
+                return 0.0
+            
+            # Check rate limits
+            if not self._check_rate_limit(endpoint, timestamp):
+                self.logger.warning(f"Rate limit exceeded for {endpoint_name}")
+                return 0.0
+            
+            # Calculate cost
+            if cost_override is not None:
+                cost = cost_override
+            else:
+                cost = endpoint.cost_per_request + (endpoint.cost_per_data_unit * data_size / 1024)  # Assume data_size in bytes
+            
+            # Record request
+            request_record = {
+                "timestamp": timestamp,
+                "endpoint": endpoint_name,
+                "data_size": data_size,
+                "latency_ms": latency_ms,
+                "success": success,
+                "cost": cost
+            }
+            
+            self.request_history.append(request_record)
+            
+            # Update metrics
+            self._update_cost_metrics(endpoint_name, cost, timestamp)
+            self._update_performance_metrics(latency_ms, success, timestamp)
+            
+            # Update endpoint usage
+            endpoint.current_usage += 1
+            
+            return cost
+            
+        except Exception as e:
+            self.logger.error(f"Failed to track request: {e}")
+            return 0.0
+    
+    def _check_rate_limit(self, endpoint: APIEndpoint, timestamp: datetime) -> bool:
+        """Check if request is within rate limits"""
+        try:
+            # Reset window if needed
+            if timestamp - endpoint.window_start >= endpoint.rate_limit_window:
+                endpoint.current_usage = 0
+                endpoint.window_start = timestamp
+            
+            # Check limit
+            return endpoint.current_usage < endpoint.rate_limit_requests
+            
+        except Exception as e:
+            self.logger.error(f"Rate limit check failed: {e}")
+            return True  # Allow request on error
+    
+    def _update_cost_metrics(self, endpoint_name: str, cost: float, timestamp: datetime) -> None:
+        """Update cost tracking metrics"""
+        # Daily cost tracking
+        today = timestamp.date()
+        self.cost_history[today] += cost
+        
+        # Endpoint cost tracking
+        self.cost_by_endpoint[endpoint_name] += cost
+        
+        # Hourly cost tracking
+        hour_key = timestamp.replace(minute=0, second=0, microsecond=0)
+        self.cost_by_hour[hour_key] += cost
+    
+    def _update_performance_metrics(self, latency_ms: float, success: bool, timestamp: datetime) -> None:
+        """Update performance tracking metrics"""
+        if latency_ms > 0:
+            self.latency_history.append({"timestamp": timestamp, "latency": latency_ms})
+        
+        self.error_history.append({"timestamp": timestamp, "success": success})
+    
+    def get_daily_cost(self, target_date: Optional[date] = None) -> float:
+        """Get total cost for a specific day"""
+        target_date = target_date or datetime.now().date()
+        return self.cost_history.get(target_date, 0.0)
+    
+    def get_hourly_costs(self, hours: int = 24) -> Dict[str, float]:
+        """Get hourly cost breakdown for the last N hours"""
+        cutoff_time = datetime.now() - timedelta(hours=hours)
+        
+        return {
+            hour.strftime("%Y-%m-%d %H:00"): cost
+            for hour, cost in self.cost_by_hour.items()
+            if hour >= cutoff_time
+        }
+    
+    def get_endpoint_costs(self) -> Dict[str, Dict[str, Any]]:
+        """Get cost breakdown by endpoint"""
+        total_cost = sum(self.cost_by_endpoint.values())
+        
+        return {
+            endpoint: {
+                "total_cost": cost,
+                "percentage": (cost / total_cost) * 100 if total_cost > 0 else 0,
+                "requests": sum(1 for r in self.request_history if r["endpoint"] == endpoint),
+                "avg_cost_per_request": cost / max(1, sum(1 for r in self.request_history if r["endpoint"] == endpoint))
+            }
+            for endpoint, cost in self.cost_by_endpoint.items()
+        }
+    
+    def get_performance_metrics(self) -> Dict[str, Any]:
+        """Get performance metrics summary"""
+        recent_latencies = [r["latency"] for r in self.latency_history if r["latency"] > 0]
+        recent_errors = [not r["success"] for r in self.error_history]
+        
+        return {
+            "avg_latency_ms": sum(recent_latencies) / len(recent_latencies) if recent_latencies else 0,
+            "p95_latency_ms": sorted(recent_latencies)[int(len(recent_latencies) * 0.95)] if recent_latencies else 0,
+            "error_rate": sum(recent_errors) / len(recent_errors) if recent_errors else 0,
+            "total_requests": len(self.request_history),
+            "requests_last_hour": sum(1 for r in self.request_history 
+                                    if datetime.now() - r["timestamp"] <= timedelta(hours=1))
+        }
+    
+    def generate_cost_report(self, days: int = 7) -> Dict[str, Any]:
+        """Generate comprehensive cost report"""
+        cutoff_date = datetime.now().date() - timedelta(days=days)
+        
+        # Daily costs
+        daily_costs = {
+            str(date_key): cost
+            for date_key, cost in self.cost_history.items()
+            if date_key >= cutoff_date
+        }
+        
+        # Total cost
+        total_cost = sum(daily_costs.values())
+        
+        return {
+            "report_period": f"{days} days",
+            "total_cost": total_cost,
+            "daily_average": total_cost / days if days > 0 else 0,
+            "daily_breakdown": daily_costs,
+            "endpoint_breakdown": self.get_endpoint_costs(),
+            "hourly_breakdown": self.get_hourly_costs(24 * days),
+            "performance_metrics": self.get_performance_metrics(),
+            "cost_trend": self._calculate_cost_trend(daily_costs)
+        }
+    
+    def _calculate_cost_trend(self, daily_costs: Dict[str, float]) -> str:
+        """Calculate cost trend over time"""
+        if len(daily_costs) < 2:
+            return "insufficient_data"
+        
+        costs = list(daily_costs.values())
+        first_half_avg = sum(costs[:len(costs)//2]) / (len(costs)//2)
+        second_half_avg = sum(costs[len(costs)//2:]) / (len(costs) - len(costs)//2)
+        
+        if abs(second_half_avg - first_half_avg) < first_half_avg * 0.1:
+            return "stable"
+        elif second_half_avg > first_half_avg:
+            return "increasing"
+        else:
+            return "decreasing"
+
+
+class BudgetManager:
+    """
+    Manages budget limits and enforces cost controls across multiple time periods.
+    """
+    
+    def __init__(self, api_tracker: APITracker):
+        self.api_tracker = api_tracker
+        self.logger = logging.getLogger(__name__)
+        
+        # Budget periods
+        self.budget_periods: Dict[str, BudgetPeriod] = {}
+        
+        # Alerts system
+        self.alerts: Dict[str, CostAlert] = {}
+        self.alert_callbacks: Dict[str, Callable] = {}
+        
+        # Emergency controls
+        self.emergency_stop_enabled = False
+        self.emergency_threshold = 500.0  # $500 emergency cutoff
+        
+        # Cost predictions
+        self.prediction_window_hours = 24
+        
+    def set_budget(self, period_name: str, budget_limit: float, period_duration: timedelta) -> None:
+        """Set budget for a specific period"""
+        period_end = datetime.now() + period_duration
+        
+        budget_period = BudgetPeriod(
+            period_name=period_name,
+            budget_limit=budget_limit,
+            period_start=datetime.now(),
+            period_end=period_end
+        )
+        
+        self.budget_periods[period_name] = budget_period
+        self.logger.info(f"Set budget for {period_name}: ${budget_limit} until {period_end}")
+    
+    def add_alert(self, alert: CostAlert) -> None:
+        """Add a cost alert"""
+        self.alerts[alert.alert_id] = alert
+        self.logger.info(f"Added cost alert: {alert.alert_id} at {alert.threshold} threshold")
+    
+    async def check_budgets_and_alerts(self) -> List[Dict[str, Any]]:
+        """Check all budgets and trigger alerts if needed"""
+        triggered_alerts = []
+        
+        try:
+            # Update budget periods with current costs
+            await self._update_budget_periods()
+            
+            # Check budget violations
+            for period_name, budget_period in self.budget_periods.items():
+                utilization = budget_period.utilization_percent
+                
+                # Check alerts for this budget period
+                for alert_id, alert in self.alerts.items():
+                    if not alert.enabled:
+                        continue
+                    
+                    # Check if alert threshold is met
+                    should_trigger = False
+                    
+                    if alert.level == AlertLevel.INFO and utilization >= 50:
+                        should_trigger = True
+                    elif alert.level == AlertLevel.WARNING and utilization >= 75:
+                        should_trigger = True
+                    elif alert.level == AlertLevel.CRITICAL and utilization >= 90:
+                        should_trigger = True
+                    elif alert.level == AlertLevel.EMERGENCY and utilization >= 95:
+                        should_trigger = True
+                    
+                    # Or check absolute cost threshold
+                    if budget_period.spent_amount >= alert.threshold:
+                        should_trigger = True
+                    
+                    if should_trigger:
+                        triggered_alert = await self._trigger_alert(alert, budget_period)
+                        triggered_alerts.append(triggered_alert)
+            
+            # Check emergency stop
+            total_daily_cost = self.api_tracker.get_daily_cost()
+            if total_daily_cost >= self.emergency_threshold:
+                await self._trigger_emergency_stop()
+            
+            return triggered_alerts
+            
+        except Exception as e:
+            self.logger.error(f"Failed to check budgets and alerts: {e}")
+            return []
+    
+    async def _update_budget_periods(self) -> None:
+        """Update budget periods with current spending"""
+        current_time = datetime.now()
+        
+        for period_name, budget_period in self.budget_periods.items():
+            # Check if period has expired and needs renewal
+            if current_time >= budget_period.period_end:
+                await self._renew_budget_period(period_name, budget_period)
+                continue
+            
+            # Calculate spent amount for this period
+            period_costs = []
+            for record in self.api_tracker.request_history:
+                if (budget_period.period_start <= record["timestamp"] <= current_time and
+                    record["timestamp"] <= budget_period.period_end):
+                    period_costs.append(record["cost"])
+            
+            budget_period.spent_amount = sum(period_costs)
+    
+    async def _renew_budget_period(self, period_name: str, old_period: BudgetPeriod) -> None:
+        """Renew an expired budget period"""
+        try:
+            # Calculate duration of old period
+            duration = old_period.period_end - old_period.period_start
+            
+            # Create new period with same budget limit
+            new_period = BudgetPeriod(
+                period_name=period_name,
+                budget_limit=old_period.budget_limit,
+                period_start=datetime.now(),
+                period_end=datetime.now() + duration
+            )
+            
+            self.budget_periods[period_name] = new_period
+            
+            self.logger.info(f"Renewed budget period {period_name}: ${new_period.budget_limit}")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to renew budget period {period_name}: {e}")
+    
+    async def _trigger_alert(self, alert: CostAlert, budget_period: BudgetPeriod) -> Dict[str, Any]:
+        """Trigger a cost alert"""
+        try:
+            current_time = datetime.now()
+            
+            alert_data = {
+                "alert_id": alert.alert_id,
+                "level": alert.level.value,
+                "timestamp": current_time.isoformat(),
+                "description": alert.description,
+                "budget_period": budget_period.period_name,
+                "spent_amount": budget_period.spent_amount,
+                "budget_limit": budget_period.budget_limit,
+                "utilization_percent": budget_period.utilization_percent,
+                "threshold_exceeded": budget_period.spent_amount >= alert.threshold
+            }
+            
+            # Update alert record
+            alert.last_triggered = current_time
+            alert.trigger_count += 1
+            
+            # Execute callback if available
+            if alert.callback:
+                try:
+                    await alert.callback(alert_data)
+                except Exception as e:
+                    self.logger.error(f"Alert callback failed for {alert.alert_id}: {e}")
+            
+            self.logger.warning(f"Cost alert triggered: {alert.alert_id} - {alert.description}")
+            
+            return alert_data
+            
+        except Exception as e:
+            self.logger.error(f"Failed to trigger alert {alert.alert_id}: {e}")
+            return {"error": str(e)}
+    
+    async def _trigger_emergency_stop(self) -> None:
+        """Trigger emergency stop to halt all API usage"""
+        try:
+            self.emergency_stop_enabled = True
+            
+            emergency_data = {
+                "timestamp": datetime.now().isoformat(),
+                "reason": "emergency_cost_threshold_exceeded",
+                "daily_cost": self.api_tracker.get_daily_cost(),
+                "emergency_threshold": self.emergency_threshold
+            }
+            
+            self.logger.critical(f"EMERGENCY STOP TRIGGERED: Daily cost ${emergency_data['daily_cost']} exceeded threshold ${self.emergency_threshold}")
+            
+            # Execute emergency callbacks
+            for callback in self.alert_callbacks.get("emergency", []):
+                try:
+                    await callback(emergency_data)
+                except Exception as e:
+                    self.logger.error(f"Emergency callback failed: {e}")
+                    
+        except Exception as e:
+            self.logger.error(f"Failed to trigger emergency stop: {e}")
+    
+    def is_request_allowed(self, estimated_cost: float) -> Tuple[bool, str]:
+        """Check if a request is allowed based on budget constraints"""
+        try:
+            # Emergency stop check
+            if self.emergency_stop_enabled:
+                return False, "Emergency stop is active"
+            
+            # Check daily emergency threshold
+            current_daily_cost = self.api_tracker.get_daily_cost()
+            if current_daily_cost + estimated_cost >= self.emergency_threshold:
+                return False, f"Would exceed emergency threshold (${self.emergency_threshold})"
+            
+            # Check budget periods
+            for period_name, budget_period in self.budget_periods.items():
+                if budget_period.spent_amount + estimated_cost > budget_period.budget_limit:
+                    return False, f"Would exceed {period_name} budget (${budget_period.budget_limit})"
+            
+            return True, "Request allowed"
+            
+        except Exception as e:
+            self.logger.error(f"Error checking request allowance: {e}")
+            return False, "Error in budget check"
+    
+    def predict_costs(self, hours: int = None) -> Dict[str, Any]:
+        """Predict future costs based on current usage patterns"""
+        try:
+            hours = hours or self.prediction_window_hours
+            cutoff_time = datetime.now() - timedelta(hours=hours)
+            
+            # Get recent requests for trend analysis
+            recent_requests = [
+                r for r in self.api_tracker.request_history
+                if r["timestamp"] >= cutoff_time
+            ]
+            
+            if not recent_requests:
+                return {"error": "No recent data for prediction"}
+            
+            # Calculate hourly rate
+            recent_cost = sum(r["cost"] for r in recent_requests)
+            hourly_rate = recent_cost / hours
+            
+            # Predict next period costs
+            predictions = {
+                "next_hour": hourly_rate,
+                "next_6_hours": hourly_rate * 6,
+                "next_24_hours": hourly_rate * 24,
+                "end_of_day": hourly_rate * (24 - datetime.now().hour),
+                "end_of_week": hourly_rate * ((7 - datetime.now().weekday()) * 24 + (24 - datetime.now().hour))
+            }
+            
+            # Check budget implications
+            budget_warnings = []
+            for period_name, budget_period in self.budget_periods.items():
+                remaining_hours = (budget_period.period_end - datetime.now()).total_seconds() / 3600
+                if remaining_hours > 0:
+                    predicted_spend = hourly_rate * remaining_hours
+                    if budget_period.spent_amount + predicted_spend > budget_period.budget_limit:
+                        budget_warnings.append(f"{period_name} budget may be exceeded")
+            
+            return {
+                "hourly_rate": hourly_rate,
+                "predictions": predictions,
+                "budget_warnings": budget_warnings,
+                "confidence": "medium" if len(recent_requests) >= 10 else "low"
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Cost prediction failed: {e}")
+            return {"error": str(e)}
+    
+    def get_budget_status(self) -> Dict[str, Any]:
+        """Get comprehensive budget status"""
+        try:
+            status = {
+                "timestamp": datetime.now().isoformat(),
+                "emergency_stop_active": self.emergency_stop_enabled,
+                "daily_cost": self.api_tracker.get_daily_cost(),
+                "emergency_threshold": self.emergency_threshold,
+                "budget_periods": {},
+                "active_alerts": len([a for a in self.alerts.values() if a.enabled]),
+                "recent_alerts": [
+                    {
+                        "alert_id": alert.alert_id,
+                        "last_triggered": alert.last_triggered.isoformat() if alert.last_triggered else None,
+                        "trigger_count": alert.trigger_count
+                    }
+                    for alert in self.alerts.values()
+                    if alert.last_triggered and 
+                    datetime.now() - alert.last_triggered <= timedelta(hours=24)
+                ]
+            }
+            
+            # Add budget period details
+            for period_name, budget_period in self.budget_periods.items():
+                status["budget_periods"][period_name] = {
+                    "budget_limit": budget_period.budget_limit,
+                    "spent_amount": budget_period.spent_amount,
+                    "remaining": budget_period.remaining_budget,
+                    "utilization_percent": budget_period.utilization_percent,
+                    "period_start": budget_period.period_start.isoformat(),
+                    "period_end": budget_period.period_end.isoformat(),
+                    "time_remaining": str(budget_period.period_end - datetime.now())
+                }
+            
+            return status
+            
+        except Exception as e:
+            self.logger.error(f"Failed to get budget status: {e}")
+            return {"error": str(e)}
+    
+    def reset_emergency_stop(self) -> None:
+        """Reset emergency stop (manual override)"""
+        self.emergency_stop_enabled = False
+        self.logger.info("Emergency stop reset manually")
+    
+    def disable_alert(self, alert_id: str) -> None:
+        """Disable a specific alert"""
+        if alert_id in self.alerts:
+            self.alerts[alert_id].enabled = False
+            self.logger.info(f"Disabled alert: {alert_id}")
+    
+    def enable_alert(self, alert_id: str) -> None:
+        """Enable a specific alert"""
+        if alert_id in self.alerts:
+            self.alerts[alert_id].enabled = True
+            self.logger.info(f"Enabled alert: {alert_id}")
+    
+    def register_callback(self, event_type: str, callback: Callable) -> None:
+        """Register callback for specific events"""
+        if event_type not in self.alert_callbacks:
+            self.alert_callbacks[event_type] = []
+        
+        self.alert_callbacks[event_type].append(callback)
+        self.logger.info(f"Registered callback for {event_type}")
\ No newline at end of file
diff --git a/src/hybrid_pipeline/data_orchestrator.py b/src/hybrid_pipeline/data_orchestrator.py
new file mode 100644
index 00000000..3beae655
--- /dev/null
+++ b/src/hybrid_pipeline/data_orchestrator.py
@@ -0,0 +1,779 @@
+"""
+Hybrid Data Orchestrator
+
+Intelligently switches between live API data and synthetic data generation
+based on training requirements, API costs, and performance metrics.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Union, AsyncGenerator
+from enum import Enum
+import asyncio
+import logging
+from datetime import datetime, timedelta
+import json
+
+from ..synthetic_data.generators.game_engine import SyntheticGameEngine
+from ..synthetic_data.generators.market_simulator import MarketSimulator
+from ..synthetic_data.generators.scenario_builder import ScenarioBuilder
+from ..synthetic_data.storage.chromadb_manager import ChromaDBManager
+from ..synthetic_data.preprocessing.nfl_dataset_processor import ProcessedNFLPlay
+from ..sdk.core.base_adapter import StandardizedEvent
+from ..training.agent_analytics import AgentAnalytics
+
+
+class DataSource(Enum):
+    """Available data sources"""
+    LIVE_API = "live_api"
+    SYNTHETIC = "synthetic"
+    HYBRID = "hybrid"
+    CACHED = "cached"
+
+
+class DataMode(Enum):
+    """Operating modes for data pipeline"""
+    TRAINING = "training"
+    BACKTESTING = "backtesting"
+    LIVE_TRADING = "live_trading"
+    DEVELOPMENT = "development"
+
+
+class SwitchingStrategy(Enum):
+    """Strategies for switching between data sources"""
+    COST_BASED = "cost_based"
+    PERFORMANCE_BASED = "performance_based"
+    TIME_BASED = "time_based"
+    MANUAL = "manual"
+    INTELLIGENT = "intelligent"
+
+
+@dataclass
+class CostThreshold:
+    """Cost thresholds for data source switching"""
+    daily_limit: float = 100.0
+    hourly_limit: float = 10.0
+    per_request_limit: float = 0.50
+    emergency_cutoff: float = 200.0
+    synthetic_cost_per_event: float = 0.001  # Much lower cost
+
+
+@dataclass
+class DataSourceMetrics:
+    """Metrics for a specific data source"""
+    source: DataSource
+    requests_made: int = 0
+    cost_incurred: float = 0.0
+    latency_ms: float = 0.0
+    error_rate: float = 0.0
+    data_quality_score: float = 1.0
+    last_used: Optional[datetime] = None
+    availability: bool = True
+
+
+@dataclass
+class HybridConfig:
+    """Configuration for hybrid data pipeline"""
+    default_mode: DataMode = DataMode.TRAINING
+    primary_source: DataSource = DataSource.SYNTHETIC
+    fallback_source: DataSource = DataSource.CACHED
+    switching_strategy: SwitchingStrategy = SwitchingStrategy.INTELLIGENT
+    cost_thresholds: CostThreshold = field(default_factory=CostThreshold)
+    
+    # Performance thresholds
+    max_latency_ms: float = 1000.0
+    min_data_quality: float = 0.8
+    max_error_rate: float = 0.05
+    
+    # Synthetic data preferences
+    synthetic_scenario_count: int = 1000
+    edge_case_probability: float = 0.1
+    information_asymmetry_level: float = 0.3
+    
+    # Caching settings
+    cache_duration_hours: int = 24
+    cache_size_limit: int = 10000
+
+
+class HybridDataOrchestrator:
+    """
+    Orchestrates hybrid data pipeline for optimal cost-performance balance.
+    
+    Automatically switches between live API data and synthetic data based on:
+    - API costs and budget constraints
+    - Agent training performance requirements
+    - Data quality and availability
+    - Training phase and objectives
+    """
+    
+    def __init__(
+        self,
+        config: HybridConfig,
+        chroma_manager: ChromaDBManager,
+        synthetic_engine: SyntheticGameEngine,
+        market_simulator: MarketSimulator,
+        scenario_builder: ScenarioBuilder,
+        agent_analytics: AgentAnalytics
+    ):
+        self.config = config
+        self.chroma_manager = chroma_manager
+        self.synthetic_engine = synthetic_engine
+        self.market_simulator = market_simulator
+        self.scenario_builder = scenario_builder
+        self.agent_analytics = agent_analytics
+        
+        self.logger = logging.getLogger(__name__)
+        
+        # Data source metrics
+        self.source_metrics = {
+            DataSource.LIVE_API: DataSourceMetrics(DataSource.LIVE_API),
+            DataSource.SYNTHETIC: DataSourceMetrics(DataSource.SYNTHETIC),
+            DataSource.CACHED: DataSourceMetrics(DataSource.CACHED)
+        }
+        
+        # Current state
+        self.active_source = self.config.primary_source
+        self.current_mode = self.config.default_mode
+        self.daily_costs = 0.0
+        self.last_cost_reset = datetime.now().date()
+        
+        # Cache for processed data
+        self.data_cache: Dict[str, Any] = {}
+        self.cache_timestamps: Dict[str, datetime] = {}
+        
+        # Decision history for intelligent switching
+        self.switching_history: List[Dict[str, Any]] = []
+        
+    async def initialize(self) -> None:
+        """Initialize the hybrid data orchestrator"""
+        try:
+            self.logger.info("Initializing Hybrid Data Orchestrator")
+            
+            # Reset daily costs if needed
+            self._check_daily_cost_reset()
+            
+            # Verify synthetic data systems
+            await self._verify_synthetic_systems()
+            
+            # Load cached decisions if available
+            await self._load_switching_history()
+            
+            # Initial data source selection
+            await self._select_optimal_data_source()
+            
+            self.logger.info(f"Hybrid orchestrator initialized with {self.active_source} as active source")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize hybrid orchestrator: {e}")
+            raise
+    
+    async def get_training_data(
+        self,
+        data_type: str,
+        count: int = 100,
+        specific_requirements: Optional[Dict[str, Any]] = None
+    ) -> List[StandardizedEvent]:
+        """
+        Get training data using optimal data source selection.
+        
+        Args:
+            data_type: Type of data needed ("game_events", "market_events", etc.)
+            count: Number of events requested
+            specific_requirements: Specific requirements (edge cases, scenarios, etc.)
+            
+        Returns:
+            List of standardized events for training
+        """
+        try:
+            # Evaluate current data source optimality
+            should_switch = await self._should_switch_data_source(data_type, count, specific_requirements)
+            
+            if should_switch:
+                await self._switch_data_source(should_switch)
+            
+            # Get data from active source
+            if self.active_source == DataSource.SYNTHETIC:
+                return await self._get_synthetic_data(data_type, count, specific_requirements)
+            elif self.active_source == DataSource.LIVE_API:
+                return await self._get_live_api_data(data_type, count, specific_requirements)
+            elif self.active_source == DataSource.CACHED:
+                return await self._get_cached_data(data_type, count, specific_requirements)
+            else:
+                raise ValueError(f"Unsupported data source: {self.active_source}")
+                
+        except Exception as e:
+            self.logger.error(f"Failed to get training data: {e}")
+            # Fallback to synthetic data
+            if self.active_source != DataSource.SYNTHETIC:
+                self.logger.info("Falling back to synthetic data")
+                return await self._get_synthetic_data(data_type, count, specific_requirements)
+            raise
+    
+    async def _should_switch_data_source(
+        self,
+        data_type: str,
+        count: int,
+        requirements: Optional[Dict[str, Any]]
+    ) -> Optional[DataSource]:
+        """Determine if data source should be switched and to which source"""
+        try:
+            current_metrics = self.source_metrics[self.active_source]
+            
+            # Cost-based switching
+            if self.config.switching_strategy in [SwitchingStrategy.COST_BASED, SwitchingStrategy.INTELLIGENT]:
+                estimated_cost = await self._estimate_request_cost(self.active_source, count)
+                
+                # Check if cost exceeds thresholds
+                if (self.daily_costs + estimated_cost > self.config.cost_thresholds.daily_limit or
+                    estimated_cost > self.config.cost_thresholds.per_request_limit):
+                    
+                    # Switch to synthetic if currently using live API
+                    if self.active_source == DataSource.LIVE_API:
+                        return DataSource.SYNTHETIC
+            
+            # Performance-based switching
+            if self.config.switching_strategy in [SwitchingStrategy.PERFORMANCE_BASED, SwitchingStrategy.INTELLIGENT]:
+                if (current_metrics.latency_ms > self.config.max_latency_ms or
+                    current_metrics.error_rate > self.config.max_error_rate or
+                    current_metrics.data_quality_score < self.config.min_data_quality):
+                    
+                    # Find best alternative source
+                    return await self._find_best_alternative_source()
+            
+            # Intelligence-based switching
+            if self.config.switching_strategy == SwitchingStrategy.INTELLIGENT:
+                return await self._intelligent_source_selection(data_type, count, requirements)
+            
+            return None  # No switch needed
+            
+        except Exception as e:
+            self.logger.error(f"Error in switch evaluation: {e}")
+            return None
+    
+    async def _intelligent_source_selection(
+        self,
+        data_type: str,
+        count: int,
+        requirements: Optional[Dict[str, Any]]
+    ) -> Optional[DataSource]:
+        """Intelligent data source selection based on multiple factors"""
+        try:
+            # Factors to consider
+            factors = {}
+            
+            # 1. Training phase analysis
+            if requirements and requirements.get("training_phase"):
+                phase = requirements["training_phase"]
+                if phase == "initial":
+                    # Use synthetic for initial training (cheaper, unlimited scenarios)
+                    factors["phase_preference"] = DataSource.SYNTHETIC
+                elif phase == "advanced":
+                    # Mix of synthetic and live for advanced training
+                    factors["phase_preference"] = DataSource.HYBRID
+                elif phase == "validation":
+                    # Live data for final validation
+                    factors["phase_preference"] = DataSource.LIVE_API
+            
+            # 2. Agent performance analysis
+            if requirements and requirements.get("agent_id"):
+                agent_id = requirements["agent_id"]
+                # Get recent analytics to determine if agent needs diverse scenarios
+                analytics = await self.agent_analytics.get_agent_analytics(agent_id, timedelta(hours=24))
+                
+                if analytics.get("latest_snapshot"):
+                    snapshot = analytics["latest_snapshot"]
+                    
+                    # If learning velocity is low, provide more diverse synthetic scenarios
+                    if snapshot.get("learning_velocity", 0) < 0.3:
+                        factors["performance_need"] = DataSource.SYNTHETIC
+                    
+                    # If agent is performing well, validate with live data
+                    elif snapshot.get("win_rate", 0) > 0.6:
+                        factors["performance_need"] = DataSource.LIVE_API
+            
+            # 3. Cost efficiency analysis
+            synthetic_cost = self.config.cost_thresholds.synthetic_cost_per_event * count
+            api_cost = await self._estimate_request_cost(DataSource.LIVE_API, count)
+            
+            if api_cost > synthetic_cost * 10:  # API is 10x more expensive
+                factors["cost_efficiency"] = DataSource.SYNTHETIC
+            
+            # 4. Data requirements analysis
+            if requirements:
+                # Edge cases are better handled by synthetic data
+                if requirements.get("include_edge_cases", False):
+                    factors["data_requirement"] = DataSource.SYNTHETIC
+                
+                # Real market conditions need live data
+                if requirements.get("market_realism", False):
+                    factors["data_requirement"] = DataSource.LIVE_API
+            
+            # 5. System load analysis
+            current_load = await self._get_system_load()
+            if current_load > 0.8:  # High load, prefer cached data
+                factors["system_load"] = DataSource.CACHED
+            
+            # Decision algorithm: weighted voting
+            votes = {source: 0 for source in DataSource}
+            for factor_name, preferred_source in factors.items():
+                weight = self._get_factor_weight(factor_name)
+                votes[preferred_source] += weight
+            
+            # Select highest voted source
+            best_source = max(votes, key=votes.get)
+            
+            # Only switch if significantly better
+            if votes[best_source] > votes[self.active_source] * 1.2:
+                return best_source
+            
+            return None
+            
+        except Exception as e:
+            self.logger.error(f"Error in intelligent source selection: {e}")
+            return None
+    
+    def _get_factor_weight(self, factor_name: str) -> float:
+        """Get weight for different decision factors"""
+        weights = {
+            "cost_efficiency": 0.4,
+            "phase_preference": 0.3,
+            "performance_need": 0.2,
+            "data_requirement": 0.25,
+            "system_load": 0.15
+        }
+        return weights.get(factor_name, 0.1)
+    
+    async def _estimate_request_cost(self, source: DataSource, count: int) -> float:
+        """Estimate cost for a data request"""
+        if source == DataSource.SYNTHETIC:
+            return self.config.cost_thresholds.synthetic_cost_per_event * count
+        elif source == DataSource.LIVE_API:
+            # Estimate based on typical API costs
+            return count * 0.01  # $0.01 per event (example)
+        elif source == DataSource.CACHED:
+            return 0.0  # No cost for cached data
+        else:
+            return 0.0
+    
+    async def _get_system_load(self) -> float:
+        """Get current system load (simplified implementation)"""
+        try:
+            # In real implementation, would check CPU, memory, network
+            # For now, return random load between 0.1 and 0.9
+            import random
+            return random.uniform(0.1, 0.9)
+        except Exception:
+            return 0.5  # Default moderate load
+    
+    async def _find_best_alternative_source(self) -> DataSource:
+        """Find the best alternative data source based on current metrics"""
+        best_source = None
+        best_score = -1
+        
+        for source, metrics in self.source_metrics.items():
+            if source == self.active_source:
+                continue
+                
+            if not metrics.availability:
+                continue
+            
+            # Score based on multiple factors
+            score = (
+                (1 - metrics.error_rate) * 0.3 +
+                min(1.0, 1000.0 / max(metrics.latency_ms, 1)) * 0.3 +
+                metrics.data_quality_score * 0.4
+            )
+            
+            if score > best_score:
+                best_score = score
+                best_source = source
+        
+        return best_source or DataSource.SYNTHETIC  # Fallback to synthetic
+    
+    async def _switch_data_source(self, new_source: DataSource) -> None:
+        """Switch to a new data source"""
+        try:
+            old_source = self.active_source
+            self.active_source = new_source
+            
+            # Record the switch
+            switch_record = {
+                "timestamp": datetime.now().isoformat(),
+                "from_source": old_source.value,
+                "to_source": new_source.value,
+                "reason": "intelligent_switching",
+                "daily_cost": self.daily_costs
+            }
+            self.switching_history.append(switch_record)
+            
+            # Update metrics
+            self.source_metrics[new_source].last_used = datetime.now()
+            
+            self.logger.info(f"Switched data source from {old_source.value} to {new_source.value}")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to switch data source: {e}")
+            raise
+    
+    async def _get_synthetic_data(
+        self,
+        data_type: str,
+        count: int,
+        requirements: Optional[Dict[str, Any]]
+    ) -> List[StandardizedEvent]:
+        """Get synthetic training data"""
+        try:
+            start_time = datetime.now()
+            
+            if data_type == "game_events":
+                # Generate synthetic games
+                scenarios = await self.scenario_builder.build_comprehensive_training_set(
+                    num_scenarios=max(count // 20, 1),  # ~20 events per game
+                    include_edge_cases=requirements.get("include_edge_cases", True) if requirements else True
+                )
+                
+                # Convert scenarios to standardized events
+                events = []
+                for scenario in scenarios.scenarios[:count]:
+                    game_events = await self._convert_scenario_to_events(scenario)
+                    events.extend(game_events)
+                
+                events = events[:count]  # Trim to requested count
+                
+            elif data_type == "market_events":
+                # Generate market-specific scenarios
+                trading_scenarios = await self.scenario_builder.build_market_scenarios(count)
+                events = await self._convert_market_scenarios_to_events(trading_scenarios)
+                
+            else:
+                # Default: generate mixed scenarios
+                scenarios = await self.scenario_builder.build_comprehensive_training_set(
+                    num_scenarios=count // 10,
+                    include_edge_cases=True
+                )
+                events = []
+                for scenario in scenarios.scenarios:
+                    scenario_events = await self._convert_scenario_to_events(scenario)
+                    events.extend(scenario_events)
+                events = events[:count]
+            
+            # Update metrics
+            latency = (datetime.now() - start_time).total_seconds() * 1000
+            cost = len(events) * self.config.cost_thresholds.synthetic_cost_per_event
+            
+            await self._update_source_metrics(
+                DataSource.SYNTHETIC,
+                requests=1,
+                cost=cost,
+                latency=latency,
+                success=True
+            )
+            
+            return events
+            
+        except Exception as e:
+            await self._update_source_metrics(DataSource.SYNTHETIC, requests=1, success=False)
+            self.logger.error(f"Failed to get synthetic data: {e}")
+            raise
+    
+    async def _get_live_api_data(
+        self,
+        data_type: str,
+        count: int,
+        requirements: Optional[Dict[str, Any]]
+    ) -> List[StandardizedEvent]:
+        """Get data from live APIs (placeholder implementation)"""
+        try:
+            start_time = datetime.now()
+            
+            # This would integrate with actual live APIs
+            # For now, return cached data as proxy for live data
+            events = await self._get_cached_data(data_type, count, requirements)
+            
+            # Simulate API cost and latency
+            latency = 500  # 500ms typical API latency
+            cost = count * 0.01  # $0.01 per event
+            
+            await self._update_source_metrics(
+                DataSource.LIVE_API,
+                requests=1,
+                cost=cost,
+                latency=latency,
+                success=True
+            )
+            
+            return events
+            
+        except Exception as e:
+            await self._update_source_metrics(DataSource.LIVE_API, requests=1, success=False)
+            self.logger.error(f"Failed to get live API data: {e}")
+            raise
+    
+    async def _get_cached_data(
+        self,
+        data_type: str,
+        count: int,
+        requirements: Optional[Dict[str, Any]]
+    ) -> List[StandardizedEvent]:
+        """Get cached training data"""
+        try:
+            # Check cache freshness
+            cache_key = f"{data_type}_{count}_{hash(str(requirements))}"
+            
+            if (cache_key in self.data_cache and 
+                cache_key in self.cache_timestamps and
+                datetime.now() - self.cache_timestamps[cache_key] < timedelta(hours=self.config.cache_duration_hours)):
+                
+                cached_events = self.data_cache[cache_key]
+                await self._update_source_metrics(DataSource.CACHED, requests=1, cost=0.0, latency=10, success=True)
+                return cached_events
+            
+            # If no cached data, generate synthetic data and cache it
+            events = await self._get_synthetic_data(data_type, count, requirements)
+            
+            # Cache the results
+            if len(self.data_cache) < self.config.cache_size_limit:
+                self.data_cache[cache_key] = events
+                self.cache_timestamps[cache_key] = datetime.now()
+            
+            return events
+            
+        except Exception as e:
+            await self._update_source_metrics(DataSource.CACHED, requests=1, success=False)
+            self.logger.error(f"Failed to get cached data: {e}")
+            raise
+    
+    async def _convert_scenario_to_events(self, scenario) -> List[StandardizedEvent]:
+        """Convert training scenario to standardized events"""
+        try:
+            events = []
+            
+            # Extract game events from scenario
+            if hasattr(scenario, 'game') and scenario.game:
+                for play in scenario.game.plays:
+                    event = StandardizedEvent(
+                        event_id=f"synth_{play.play_id}",
+                        game_id=scenario.game.game_id,
+                        timestamp=play.timestamp,
+                        event_type=play.play_type,
+                        description=play.description,
+                        team_possession=play.team_possession,
+                        score_home=play.score_home,
+                        score_away=play.score_away,
+                        quarter=play.quarter,
+                        time_remaining=play.time_remaining,
+                        down=getattr(play, 'down', None),
+                        yards_to_go=getattr(play, 'yards_to_go', None),
+                        yard_line=getattr(play, 'yard_line', None),
+                        metadata={
+                            "synthetic": True,
+                            "scenario_id": scenario.scenario_id,
+                            "source": "hybrid_orchestrator"
+                        }
+                    )
+                    events.append(event)
+            
+            return events
+            
+        except Exception as e:
+            self.logger.error(f"Failed to convert scenario to events: {e}")
+            return []
+    
+    async def _convert_market_scenarios_to_events(self, scenarios) -> List[StandardizedEvent]:
+        """Convert market scenarios to standardized events"""
+        try:
+            events = []
+            
+            for scenario in scenarios:
+                # Convert market events to standardized format
+                for market_event in scenario.events:
+                    event = StandardizedEvent(
+                        event_id=f"market_{market_event.event_id}",
+                        game_id=scenario.market_ticker,
+                        timestamp=market_event.timestamp,
+                        event_type="market_update",
+                        description=f"Market price update: {market_event.price_change}",
+                        metadata={
+                            "synthetic": True,
+                            "scenario_id": scenario.scenario_id,
+                            "price_change": market_event.price_change,
+                            "volume": getattr(market_event, 'volume', 0),
+                            "source": "hybrid_orchestrator"
+                        }
+                    )
+                    events.append(event)
+            
+            return events
+            
+        except Exception as e:
+            self.logger.error(f"Failed to convert market scenarios to events: {e}")
+            return []
+    
+    async def _update_source_metrics(
+        self,
+        source: DataSource,
+        requests: int = 0,
+        cost: float = 0.0,
+        latency: float = 0.0,
+        success: bool = True
+    ) -> None:
+        """Update metrics for a data source"""
+        try:
+            metrics = self.source_metrics[source]
+            
+            metrics.requests_made += requests
+            metrics.cost_incurred += cost
+            
+            if latency > 0:
+                # Exponential moving average for latency
+                alpha = 0.1
+                metrics.latency_ms = (1 - alpha) * metrics.latency_ms + alpha * latency
+            
+            # Update error rate
+            if requests > 0:
+                alpha = 0.1
+                new_error_rate = 0.0 if success else 1.0
+                metrics.error_rate = (1 - alpha) * metrics.error_rate + alpha * new_error_rate
+            
+            # Update daily costs
+            self.daily_costs += cost
+            
+            metrics.last_used = datetime.now()
+            
+        except Exception as e:
+            self.logger.error(f"Failed to update source metrics: {e}")
+    
+    async def _verify_synthetic_systems(self) -> None:
+        """Verify that synthetic data systems are available"""
+        try:
+            # Test synthetic game engine
+            test_game = await self.synthetic_engine.generate_single_game()
+            if not test_game or not test_game.plays:
+                raise Exception("Synthetic game engine not working")
+            
+            # Test scenario builder
+            test_scenarios = await self.scenario_builder.build_comprehensive_training_set(num_scenarios=1)
+            if not test_scenarios or not test_scenarios.scenarios:
+                raise Exception("Scenario builder not working")
+            
+            self.logger.info("Synthetic systems verified successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Synthetic systems verification failed: {e}")
+            # Mark synthetic as unavailable
+            self.source_metrics[DataSource.SYNTHETIC].availability = False
+            raise
+    
+    def _check_daily_cost_reset(self) -> None:
+        """Check if daily costs should be reset"""
+        today = datetime.now().date()
+        if today > self.last_cost_reset:
+            self.daily_costs = 0.0
+            self.last_cost_reset = today
+            self.logger.info("Daily costs reset")
+    
+    async def _load_switching_history(self) -> None:
+        """Load switching history from persistent storage"""
+        try:
+            # In real implementation, would load from database
+            # For now, initialize empty history
+            self.switching_history = []
+            
+        except Exception as e:
+            self.logger.error(f"Failed to load switching history: {e}")
+            self.switching_history = []
+    
+    async def _select_optimal_data_source(self) -> None:
+        """Select optimal initial data source"""
+        try:
+            # For training mode, prefer synthetic data
+            if self.current_mode == DataMode.TRAINING:
+                self.active_source = DataSource.SYNTHETIC
+            # For live trading, prefer live API
+            elif self.current_mode == DataMode.LIVE_TRADING:
+                self.active_source = DataSource.LIVE_API
+            # For backtesting, prefer cached data
+            elif self.current_mode == DataMode.BACKTESTING:
+                self.active_source = DataSource.CACHED
+            else:
+                # Default to configured primary source
+                self.active_source = self.config.primary_source
+            
+            self.logger.info(f"Selected {self.active_source.value} as optimal data source for {self.current_mode.value} mode")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to select optimal data source: {e}")
+            self.active_source = DataSource.SYNTHETIC  # Safe fallback
+    
+    async def get_cost_summary(self) -> Dict[str, Any]:
+        """Get comprehensive cost summary"""
+        try:
+            return {
+                "daily_costs": self.daily_costs,
+                "daily_limit": self.config.cost_thresholds.daily_limit,
+                "utilization_percent": (self.daily_costs / self.config.cost_thresholds.daily_limit) * 100,
+                "source_breakdown": {
+                    source.value: {
+                        "requests": metrics.requests_made,
+                        "cost": metrics.cost_incurred,
+                        "avg_latency": metrics.latency_ms,
+                        "error_rate": metrics.error_rate,
+                        "last_used": metrics.last_used.isoformat() if metrics.last_used else None
+                    }
+                    for source, metrics in self.source_metrics.items()
+                },
+                "active_source": self.active_source.value,
+                "switching_history": self.switching_history[-10:]  # Last 10 switches
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Failed to generate cost summary: {e}")
+            return {"error": str(e)}
+    
+    async def force_data_source(self, source: DataSource) -> None:
+        """Manually force a specific data source"""
+        try:
+            old_source = self.active_source
+            self.active_source = source
+            
+            # Record manual switch
+            switch_record = {
+                "timestamp": datetime.now().isoformat(),
+                "from_source": old_source.value,
+                "to_source": source.value,
+                "reason": "manual_override",
+                "daily_cost": self.daily_costs
+            }
+            self.switching_history.append(switch_record)
+            
+            self.logger.info(f"Manually switched data source to {source.value}")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to force data source: {e}")
+            raise
+    
+    async def shutdown(self) -> None:
+        """Gracefully shutdown the hybrid orchestrator"""
+        try:
+            self.logger.info("Shutting down Hybrid Data Orchestrator")
+            
+            # Save switching history
+            await self._save_switching_history()
+            
+            # Clear cache
+            self.data_cache.clear()
+            self.cache_timestamps.clear()
+            
+            self.logger.info("Hybrid Data Orchestrator shutdown complete")
+            
+        except Exception as e:
+            self.logger.error(f"Error during shutdown: {e}")
+    
+    async def _save_switching_history(self) -> None:
+        """Save switching history to persistent storage"""
+        try:
+            # In real implementation, would save to database
+            # For now, just log summary
+            self.logger.info(f"Saving switching history: {len(self.switching_history)} records")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to save switching history: {e}")
\ No newline at end of file
diff --git a/src/integration/__init__.py b/src/integration/__init__.py
new file mode 100644
index 00000000..831c2320
--- /dev/null
+++ b/src/integration/__init__.py
@@ -0,0 +1,84 @@
+"""
+Integration Module
+
+Bridges synthetic data generation and training systems with 
+the existing Redis-based agent infrastructure.
+"""
+
+from .training_bridge import (
+    TrainingBridge,
+    TrainingMode,
+    TrainingSession,
+    TrainingConfig
+)
+from .synthetic_injector import (
+    SyntheticDataInjector,
+    InjectionConfig,
+    EventTiming
+)
+from .training_harness import (
+    AgentTrainingHarness,
+    TrainingScenario,
+    HarnessConfig
+)
+from .decision_tracker import (
+    DecisionTracker,
+    DecisionRecord,
+    TrackingConfig,
+    DecisionType,
+    DecisionOutcome,
+    SignalSource,
+    MarketContext,
+    DecisionReasoning
+)
+from .decision_replay import (
+    DecisionReplayEngine,
+    ReplayConfig,
+    ReplayMode,
+    ReplaySpeed,
+    ReplayResult
+)
+from .training_controller import (
+    TrainingModeController,
+    ModeConfig,
+    DataSourceMode,
+    TransitionState,
+    AgentState,
+    AgentInfo,
+    TransitionPlan,
+    ModeStatus
+)
+
+__all__ = [
+    'TrainingBridge',
+    'TrainingMode',
+    'TrainingSession',
+    'TrainingConfig',
+    'SyntheticDataInjector',
+    'InjectionConfig',
+    'EventTiming',
+    'AgentTrainingHarness',
+    'TrainingScenario',
+    'HarnessConfig',
+    'DecisionTracker',
+    'DecisionRecord',
+    'TrackingConfig',
+    'DecisionType',
+    'DecisionOutcome',
+    'SignalSource',
+    'MarketContext',
+    'DecisionReasoning',
+    'DecisionReplayEngine',
+    'ReplayConfig',
+    'ReplayMode',
+    'ReplaySpeed',
+    'ReplayResult',
+    'TrainingModeController',
+    'ModeConfig',
+    'DataSourceMode',
+    'TransitionState',
+    'AgentState',
+    'AgentInfo',
+    'TransitionPlan',
+    'ModeStatus'
+]
\ No newline at end of file
diff --git a/src/integration/synthetic_injector.py b/src/integration/synthetic_injector.py
new file mode 100644
index 00000000..5c772087
--- /dev/null
+++ b/src/integration/synthetic_injector.py
@@ -0,0 +1,688 @@
+"""
+Synthetic Data Injector
+
+Injects synthetic training data into Redis channels with realistic timing,
+sequencing, and market dynamics for agent training.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Tuple
+from datetime import datetime, timedelta
+from enum import Enum
+import asyncio
+import logging
+import json
+import redis.asyncio as redis
+import random
+import numpy as np
+
+from ..sdk.core.base_adapter import StandardizedEvent
+from ..synthetic_data.generators.game_engine import SyntheticGame
+from ..synthetic_data.generators.market_simulator import TradingScenario, MarketEvent
+
+
+class EventTiming(Enum):
+    """Event timing strategies"""
+    REALTIME = "realtime"  # Real-world timing
+    ACCELERATED = "accelerated"  # Faster than realtime
+    BURST = "burst"  # All at once
+    ADAPTIVE = "adaptive"  # Adjust based on agent response
+
+
+@dataclass
+class InjectionConfig:
+    """Configuration for data injection"""
+    timing_mode: EventTiming = EventTiming.ACCELERATED
+    acceleration_factor: float = 10.0  # 10x speed
+    
+    # Realistic delays (in seconds)
+    min_event_delay: float = 0.05  # 50ms minimum
+    max_event_delay: float = 5.0  # 5s maximum
+    market_update_frequency: float = 0.5  # Market updates every 500ms
+    
+    # Noise and realism
+    add_timing_jitter: bool = True
+    jitter_factor: float = 0.2  # ±20% timing variation
+    add_missing_data: bool = True  # Simulate data gaps
+    missing_data_probability: float = 0.02  # 2% chance of missing data
+    
+    # Market dynamics
+    add_market_noise: bool = True
+    price_noise_stddev: float = 0.01  # 1% price noise
+    volume_multiplier_range: Tuple[float, float] = (0.8, 1.2)
+    
+    # Redis configuration
+    redis_url: str = "redis://localhost:6379"
+    channel_prefix: str = ""  # Empty for production channels, "training:" for isolated
+    batch_size: int = 100  # Events to buffer before publishing
+    
+    # Performance
+    max_concurrent_injections: int = 10
+    enable_backpressure: bool = True
+    backpressure_threshold: int = 1000  # Pause if this many events pending
+
+
+@dataclass
+class InjectionMetrics:
+    """Metrics for injection performance"""
+    events_injected: int = 0
+    events_failed: int = 0
+    total_latency: float = 0.0
+    min_latency: float = float('inf')
+    max_latency: float = 0.0
+    start_time: datetime = field(default_factory=datetime.now)
+    
+    @property
+    def avg_latency(self) -> float:
+        return self.total_latency / self.events_injected if self.events_injected > 0 else 0.0
+    
+    @property
+    def success_rate(self) -> float:
+        total = self.events_injected + self.events_failed
+        return self.events_injected / total if total > 0 else 0.0
+    
+    @property
+    def events_per_second(self) -> float:
+        elapsed = (datetime.now() - self.start_time).total_seconds()
+        return self.events_injected / elapsed if elapsed > 0 else 0.0
+
+
+class SyntheticDataInjector:
+    """
+    Injects synthetic data into Redis channels for agent training.
+    
+    Handles timing, sequencing, and realistic market dynamics to create
+    believable training scenarios.
+    """
+    
+    def __init__(self, config: InjectionConfig = None):
+        self.config = config or InjectionConfig()
+        self.logger = logging.getLogger(__name__)
+        
+        # Redis connections
+        self.redis_client: Optional[redis.Redis] = None
+        self.publisher: Optional[redis.Redis] = None
+        
+        # Injection state
+        self.is_injecting = False
+        self.injection_tasks: List[asyncio.Task] = []
+        self.event_queue: asyncio.Queue = asyncio.Queue()
+        self.pending_events = 0
+        
+        # Metrics
+        self.metrics = InjectionMetrics()
+        
+        # Channel mappings
+        self.channel_map = {
+            "game_event": "espn:games",
+            "market_update": "kalshi:markets",
+            "trade": "kalshi:trades",
+            "signal": "kalshi:signals",
+            "sentiment": "twitter:sentiment",
+            "orderbook": "kalshi:orderbook"
+        }
+        
+        # Market state tracking (for realistic updates)
+        self.market_states: Dict[str, Dict[str, float]] = {}
+    
+    async def initialize(self) -> None:
+        """Initialize the injector"""
+        try:
+            self.logger.info("Initializing Synthetic Data Injector")
+            
+            # Connect to Redis
+            self.redis_client = redis.from_url(self.config.redis_url)
+            self.publisher = redis.from_url(self.config.redis_url)
+            
+            # Test connection
+            await self.redis_client.ping()
+            
+            # Start background publisher
+            self.injection_tasks.append(
+                asyncio.create_task(self._publisher_loop())
+            )
+            
+            self.logger.info("Synthetic Data Injector initialized")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize injector: {e}")
+            raise
+    
+    async def inject_game_scenario(
+        self,
+        game: SyntheticGame,
+        market_ticker: Optional[str] = None,
+        start_immediately: bool = True
+    ) -> str:
+        """
+        Inject a complete game scenario with synchronized market updates.
+        
+        Args:
+            game: Synthetic game to inject
+            market_ticker: Associated market ticker for price updates
+            start_immediately: Whether to start injection immediately
+            
+        Returns:
+            Injection ID for tracking
+        """
+        try:
+            injection_id = f"game_{game.game_id}_{datetime.now().timestamp()}"
+            
+            # Convert game to events
+            events = self._game_to_events(game, market_ticker)
+            
+            # Calculate timing
+            event_timings = self._calculate_event_timings(events)
+            
+            # Create injection task
+            if start_immediately:
+                task = asyncio.create_task(
+                    self._inject_event_sequence(injection_id, events, event_timings)
+                )
+                self.injection_tasks.append(task)
+            else:
+                # Queue for later injection
+                for event, timing in zip(events, event_timings):
+                    await self.event_queue.put((event, timing))
+            
+            self.logger.info(f"Injecting game scenario {injection_id} with {len(events)} events")
+            return injection_id
+            
+        except Exception as e:
+            self.logger.error(f"Failed to inject game scenario: {e}")
+            raise
+    
+    async def inject_trading_scenario(
+        self,
+        scenario: TradingScenario,
+        include_orderbook: bool = True
+    ) -> str:
+        """
+        Inject a trading scenario with market events and price updates.
+        
+        Args:
+            scenario: Trading scenario to inject
+            include_orderbook: Whether to include orderbook updates
+            
+        Returns:
+            Injection ID for tracking
+        """
+        try:
+            injection_id = f"trading_{scenario.scenario_id}_{datetime.now().timestamp()}"
+            
+            # Convert scenario to events
+            events = self._trading_scenario_to_events(scenario, include_orderbook)
+            
+            # Calculate timing with market update frequency
+            event_timings = self._calculate_market_timings(events)
+            
+            # Start injection
+            task = asyncio.create_task(
+                self._inject_event_sequence(injection_id, events, event_timings)
+            )
+            self.injection_tasks.append(task)
+            
+            self.logger.info(f"Injecting trading scenario {injection_id} with {len(events)} events")
+            return injection_id
+            
+        except Exception as e:
+            self.logger.error(f"Failed to inject trading scenario: {e}")
+            raise
+    
+    def _game_to_events(self, game: SyntheticGame, market_ticker: Optional[str]) -> List[Dict[str, Any]]:
+        """Convert a synthetic game to injectable events"""
+        events = []
+        
+        for play in game.plays:
+            # Game event
+            event = {
+                "type": "game_event",
+                "event_id": f"play_{play.play_id}",
+                "game_id": game.game_id,
+                "timestamp": play.timestamp,
+                "data": {
+                    "play_type": play.play_type,
+                    "description": play.description,
+                    "team_possession": play.team_possession,
+                    "score_home": play.score_home,
+                    "score_away": play.score_away,
+                    "quarter": play.quarter,
+                    "time_remaining": play.time_remaining,
+                    "yards_gained": getattr(play, 'yards_gained', 0),
+                    "down": getattr(play, 'down', None),
+                    "yards_to_go": getattr(play, 'yards_to_go', None)
+                }
+            }
+            events.append(event)
+            
+            # Add correlated market update if ticker provided
+            if market_ticker and self._is_significant_play(play):
+                market_event = self._generate_market_reaction(play, market_ticker)
+                events.append(market_event)
+        
+        return events
+    
+    def _is_significant_play(self, play) -> bool:
+        """Determine if a play should trigger market movement"""
+        significant_types = ["touchdown", "field_goal", "interception", "fumble", "injury"]
+        return any(sig in play.play_type.lower() for sig in significant_types)
+    
+    def _generate_market_reaction(self, play, market_ticker: str) -> Dict[str, Any]:
+        """Generate a market price reaction to a game event"""
+        # Get current market state or initialize
+        if market_ticker not in self.market_states:
+            self.market_states[market_ticker] = {
+                "yes_price": 0.5,
+                "no_price": 0.5,
+                "volume": 1000
+            }
+        
+        current_state = self.market_states[market_ticker]
+        
+        # Calculate price impact based on play type
+        impact = 0.0
+        if "touchdown" in play.play_type.lower():
+            # Touchdown by home team increases yes price
+            # Assuming home team is the team we're tracking for "YES" price
+            if hasattr(play, 'team_possession'):
+                # If possession matches home indication, positive impact
+                impact = random.uniform(0.02, 0.05) if "home" in play.team_possession.lower() else random.uniform(-0.05, -0.02)
+            else:
+                impact = random.uniform(-0.02, 0.02)  # Random if unknown
+        elif "field_goal" in play.play_type.lower():
+            if hasattr(play, 'team_possession'):
+                impact = random.uniform(-0.01, 0.01) if "home" in play.team_possession.lower() else random.uniform(-0.02, 0.0)
+            else:
+                impact = random.uniform(-0.015, 0.005)
+        elif "interception" in play.play_type.lower() or "fumble" in play.play_type.lower():
+            if hasattr(play, 'team_possession'):
+                impact = random.uniform(-0.03, -0.01) if "home" in play.team_possession.lower() else random.uniform(0.01, 0.03)
+            else:
+                impact = random.uniform(-0.01, 0.01)
+        
+        # Apply impact with noise
+        if self.config.add_market_noise:
+            noise = np.random.normal(0, self.config.price_noise_stddev)
+            impact += noise
+        
+        # Update prices
+        new_yes_price = max(0.01, min(0.99, current_state["yes_price"] + impact))
+        new_no_price = 1.0 - new_yes_price
+        
+        # Update volume
+        volume_multiplier = random.uniform(*self.config.volume_multiplier_range)
+        new_volume = current_state["volume"] * volume_multiplier
+        
+        # Store new state
+        self.market_states[market_ticker] = {
+            "yes_price": new_yes_price,
+            "no_price": new_no_price,
+            "volume": new_volume
+        }
+        
+        return {
+            "type": "market_update",
+            "event_id": f"market_{play.play_id}",
+            "market_ticker": market_ticker,
+            "timestamp": play.timestamp + timedelta(seconds=random.uniform(0.1, 0.5)),
+            "data": {
+                "yes_price": new_yes_price,
+                "no_price": new_no_price,
+                "yes_bid": new_yes_price - 0.01,
+                "yes_ask": new_yes_price + 0.01,
+                "no_bid": new_no_price - 0.01,
+                "no_ask": new_no_price + 0.01,
+                "volume": new_volume,
+                "trigger_event": play.play_id
+            }
+        }
+    
+    def _trading_scenario_to_events(self, scenario: TradingScenario, include_orderbook: bool) -> List[Dict[str, Any]]:
+        """Convert trading scenario to injectable events"""
+        events = []
+        
+        for market_event in scenario.events:
+            # Market price update
+            event = {
+                "type": "market_update",
+                "event_id": market_event.event_id,
+                "market_ticker": scenario.market_ticker,
+                "timestamp": market_event.timestamp,
+                "data": {
+                    "event_type": market_event.event_type,
+                    "yes_price": market_event.price,
+                    "no_price": 1.0 - market_event.price,
+                    "volume": market_event.volume,
+                    "price_change": market_event.price_change,
+                    "information_content": market_event.information_value
+                }
+            }
+            events.append(event)
+            
+            # Add orderbook update if requested
+            if include_orderbook and random.random() < 0.3:  # 30% chance
+                orderbook_event = self._generate_orderbook_update(scenario.market_ticker, market_event)
+                events.append(orderbook_event)
+        
+        return events
+    
+    def _generate_orderbook_update(self, market_ticker: str, market_event: MarketEvent) -> Dict[str, Any]:
+        """Generate a realistic orderbook update"""
+        base_price = market_event.price
+        
+        # Generate bid/ask levels
+        levels = 5
+        bids = []
+        asks = []
+        
+        for i in range(levels):
+            spread = 0.01 * (i + 1)
+            bid_price = base_price - spread
+            ask_price = base_price + spread
+            
+            # Volume decreases with distance from mid
+            volume = market_event.volume * (1.0 / (i + 1))
+            
+            if bid_price > 0:
+                bids.append({
+                    "price": bid_price,
+                    "quantity": int(volume * random.uniform(0.8, 1.2))
+                })
+            
+            if ask_price < 1:
+                asks.append({
+                    "price": ask_price,
+                    "quantity": int(volume * random.uniform(0.8, 1.2))
+                })
+        
+        return {
+            "type": "orderbook",
+            "event_id": f"orderbook_{market_event.event_id}",
+            "market_ticker": market_ticker,
+            "timestamp": market_event.timestamp + timedelta(milliseconds=50),
+            "data": {
+                "bids": bids,
+                "asks": asks,
+                "mid_price": base_price,
+                "spread": asks[0]["price"] - bids[0]["price"] if bids and asks else 0.02
+            }
+        }
+    
+    def _calculate_event_timings(self, events: List[Dict[str, Any]]) -> List[float]:
+        """Calculate realistic timing delays for events"""
+        timings = []
+        
+        for i, event in enumerate(events):
+            if self.config.timing_mode == EventTiming.BURST:
+                delay = 0.0  # No delay
+            elif self.config.timing_mode == EventTiming.REALTIME:
+                # Calculate actual time difference
+                if i > 0:
+                    prev_timestamp = events[i-1].get("timestamp", datetime.now())
+                    curr_timestamp = event.get("timestamp", datetime.now())
+                    
+                    if isinstance(prev_timestamp, str):
+                        prev_timestamp = datetime.fromisoformat(prev_timestamp)
+                    if isinstance(curr_timestamp, str):
+                        curr_timestamp = datetime.fromisoformat(curr_timestamp)
+                    
+                    delay = (curr_timestamp - prev_timestamp).total_seconds()
+                else:
+                    delay = 0.0
+            elif self.config.timing_mode == EventTiming.ACCELERATED:
+                # Base delay with acceleration
+                base_delay = random.uniform(self.config.min_event_delay, self.config.max_event_delay)
+                delay = base_delay / self.config.acceleration_factor
+            else:  # ADAPTIVE
+                # Adjust based on event type and importance
+                if event["type"] == "market_update":
+                    delay = self.config.market_update_frequency / self.config.acceleration_factor
+                else:
+                    delay = random.uniform(0.1, 1.0) / self.config.acceleration_factor
+            
+            # Add jitter if configured
+            if self.config.add_timing_jitter:
+                jitter = random.gauss(0, delay * self.config.jitter_factor) if delay > 0 else 0
+                delay = max(0.001, delay + jitter)  # Ensure positive
+            
+            timings.append(delay)
+        
+        return timings
+    
+    def _calculate_market_timings(self, events: List[Dict[str, Any]]) -> List[float]:
+        """Calculate timing specifically for market events"""
+        timings = []
+        
+        for event in events:
+            if event["type"] == "market_update":
+                # Regular market updates
+                delay = self.config.market_update_frequency / self.config.acceleration_factor
+            elif event["type"] == "orderbook":
+                # Orderbook updates are more frequent
+                delay = (self.config.market_update_frequency * 0.5) / self.config.acceleration_factor
+            else:
+                # Other events
+                delay = random.uniform(0.5, 2.0) / self.config.acceleration_factor
+            
+            # Add realistic variation
+            if self.config.add_timing_jitter:
+                delay *= random.uniform(0.8, 1.2)
+            
+            timings.append(delay)
+        
+        return timings
+    
+    async def _inject_event_sequence(
+        self,
+        injection_id: str,
+        events: List[Dict[str, Any]],
+        timings: List[float]
+    ) -> None:
+        """Inject a sequence of events with specified timing"""
+        try:
+            self.is_injecting = True
+            
+            for event, delay in zip(events, timings):
+                # Check backpressure
+                if self.config.enable_backpressure and self.pending_events > self.config.backpressure_threshold:
+                    await self._wait_for_backpressure()
+                
+                # Wait for timing
+                if delay > 0:
+                    await asyncio.sleep(delay)
+                
+                # Simulate missing data if configured
+                if self.config.add_missing_data and random.random() < self.config.missing_data_probability:
+                    self.logger.debug(f"Simulating missing data for event {event.get('event_id')}")
+                    continue
+                
+                # Queue event for publishing
+                await self.event_queue.put((event, injection_id))
+                self.pending_events += 1
+            
+            self.logger.info(f"Completed injection sequence {injection_id}")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to inject event sequence: {e}")
+            self.metrics.events_failed += len(events)
+        finally:
+            self.is_injecting = False
+    
+    async def _wait_for_backpressure(self) -> None:
+        """Wait for backpressure to clear"""
+        self.logger.debug("Backpressure detected, waiting...")
+        while self.pending_events > self.config.backpressure_threshold * 0.5:
+            await asyncio.sleep(0.1)
+    
+    async def _publisher_loop(self) -> None:
+        """Background loop for publishing queued events"""
+        batch = []
+        
+        while True:
+            try:
+                # Get event from queue with timeout
+                try:
+                    event, injection_id = await asyncio.wait_for(
+                        self.event_queue.get(), timeout=1.0
+                    )
+                    batch.append((event, injection_id))
+                except asyncio.TimeoutError:
+                    # Flush batch if we have events
+                    if batch:
+                        await self._publish_batch(batch)
+                        batch = []
+                    continue
+                
+                # Publish batch if full
+                if len(batch) >= self.config.batch_size:
+                    await self._publish_batch(batch)
+                    batch = []
+                    
+            except Exception as e:
+                self.logger.error(f"Publisher loop error: {e}")
+                await asyncio.sleep(1)
+    
+    async def _publish_batch(self, batch: List[Tuple[Dict[str, Any], str]]) -> None:
+        """Publish a batch of events to Redis"""
+        try:
+            start_time = datetime.now()
+            
+            for event, injection_id in batch:
+                channel = self._get_channel_for_event(event)
+                
+                # Add channel prefix if configured
+                if self.config.channel_prefix:
+                    channel = f"{self.config.channel_prefix}{channel}"
+                
+                # Prepare message
+                message = {
+                    "timestamp": event["timestamp"].isoformat() if hasattr(event["timestamp"], 'isoformat') else str(event["timestamp"]),
+                    "source": "synthetic_injector",
+                    "injection_id": injection_id,
+                    "type": event["type"],
+                    "data": event["data"]
+                }
+                
+                # Add event-specific fields
+                if "event_id" in event:
+                    message["event_id"] = event["event_id"]
+                if "game_id" in event:
+                    message["game_id"] = event["game_id"]
+                if "market_ticker" in event:
+                    message["market_ticker"] = event["market_ticker"]
+                
+                # Publish to Redis
+                await self.publisher.publish(channel, json.dumps(message))
+                
+                # Update metrics
+                self.metrics.events_injected += 1
+                self.pending_events -= 1
+            
+            # Update latency metrics
+            latency = (datetime.now() - start_time).total_seconds()
+            self.metrics.total_latency += latency
+            self.metrics.min_latency = min(self.metrics.min_latency, latency)
+            self.metrics.max_latency = max(self.metrics.max_latency, latency)
+            
+        except Exception as e:
+            self.logger.error(f"Failed to publish batch: {e}")
+            self.metrics.events_failed += len(batch)
+            self.pending_events -= len(batch)
+    
+    def _get_channel_for_event(self, event: Dict[str, Any]) -> str:
+        """Get the appropriate Redis channel for an event type"""
+        event_type = event.get("type", "unknown")
+        return self.channel_map.get(event_type, "kalshi:unknown")
+    
+    async def inject_burst(self, events: List[StandardizedEvent]) -> str:
+        """
+        Inject a burst of events as quickly as possible.
+        
+        Args:
+            events: List of standardized events to inject
+            
+        Returns:
+            Injection ID
+        """
+        try:
+            injection_id = f"burst_{datetime.now().timestamp()}"
+            
+            # Convert to injectable format
+            injectable_events = []
+            for event in events:
+                injectable = {
+                    "type": self._event_type_to_channel_type(event.event_type),
+                    "event_id": event.event_id,
+                    "timestamp": event.timestamp,
+                    "data": {
+                        "description": event.description,
+                        "metadata": event.metadata
+                    }
+                }
+                
+                if event.game_id:
+                    injectable["game_id"] = event.game_id
+                
+                injectable_events.append(injectable)
+            
+            # Queue all events immediately
+            for event in injectable_events:
+                await self.event_queue.put((event, injection_id))
+                self.pending_events += 1
+            
+            self.logger.info(f"Queued burst injection {injection_id} with {len(events)} events")
+            return injection_id
+            
+        except Exception as e:
+            self.logger.error(f"Failed to inject burst: {e}")
+            raise
+    
+    def _event_type_to_channel_type(self, event_type: str) -> str:
+        """Convert StandardizedEvent type to channel type"""
+        mapping = {
+            "score_update": "game_event",
+            "big_play": "game_event",
+            "market_update": "market_update",
+            "trade": "trade",
+            "signal": "signal"
+        }
+        return mapping.get(event_type, "game_event")
+    
+    def get_metrics(self) -> Dict[str, Any]:
+        """Get injection metrics"""
+        return {
+            "events_injected": self.metrics.events_injected,
+            "events_failed": self.metrics.events_failed,
+            "success_rate": f"{self.metrics.success_rate:.2%}",
+            "avg_latency_ms": self.metrics.avg_latency * 1000,
+            "min_latency_ms": self.metrics.min_latency * 1000 if self.metrics.min_latency != float('inf') else 0,
+            "max_latency_ms": self.metrics.max_latency * 1000,
+            "events_per_second": self.metrics.events_per_second,
+            "pending_events": self.pending_events,
+            "is_injecting": self.is_injecting
+        }
+    
+    async def shutdown(self) -> None:
+        """Shutdown the injector"""
+        try:
+            self.logger.info("Shutting down Synthetic Data Injector")
+            
+            # Cancel injection tasks
+            for task in self.injection_tasks:
+                if not task.done():
+                    task.cancel()
+            
+            # Wait for tasks to complete
+            if self.injection_tasks:
+                await asyncio.gather(*self.injection_tasks, return_exceptions=True)
+            
+            # Close Redis connections
+            if self.redis_client:
+                await self.redis_client.close()
+            if self.publisher:
+                await self.publisher.close()
+            
+            self.logger.info(f"Injector shutdown complete. Final metrics: {self.get_metrics()}")
+            
+        except Exception as e:
+            self.logger.error(f"Error during shutdown: {e}")
\ No newline at end of file
diff --git a/src/integration/training_bridge.py b/src/integration/training_bridge.py
new file mode 100644
index 00000000..c111d21a
--- /dev/null
+++ b/src/integration/training_bridge.py
@@ -0,0 +1,691 @@
+"""
+Training Bridge Module
+
+Bridges synthetic data pipeline with Redis-based agent infrastructure,
+enabling seamless training with generated scenarios.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Callable
+from datetime import datetime, timedelta
+from enum import Enum
+import asyncio
+import logging
+import json
+import redis.asyncio as redis
+from collections import defaultdict
+
+from ..sdk.core.base_adapter import StandardizedEvent
+from ..synthetic_data.generators.scenario_builder import TrainingScenarioSet
+from ..synthetic_data.generators.market_simulator import TradingScenario
+from ..training.agent_analytics import AgentAnalytics, DecisionMetrics
+from ..training.memory_system import AgentMemorySystem
+from ..confidence_calibration.calibrator import ConfidenceCalibrator
+from ..hybrid_pipeline.data_orchestrator import HybridDataOrchestrator
+
+
+class TrainingMode(Enum):
+    """Training modes for agents"""
+    EXPLORATION = "exploration"  # High randomness, learning new patterns
+    EXPLOITATION = "exploitation"  # Low randomness, refining strategies
+    VALIDATION = "validation"  # No randomness, testing performance
+    PRODUCTION_PREP = "production_prep"  # Simulate production conditions
+
+
+@dataclass
+class TrainingConfig:
+    """Configuration for training sessions"""
+    mode: TrainingMode = TrainingMode.EXPLORATION
+    time_acceleration: float = 10.0  # 10x speed
+    inject_noise: bool = True  # Add realistic noise to data
+    noise_level: float = 0.05  # 5% noise
+    track_decisions: bool = True
+    update_memory: bool = True
+    calibrate_confidence: bool = True
+    
+    # Redis configuration
+    redis_url: str = "redis://localhost:6379"
+    training_namespace: str = "training"  # Prefix for training channels
+    
+    # Performance thresholds
+    min_confidence_threshold: float = 0.3
+    max_position_size: float = 0.1  # 10% of capital
+    stop_loss_threshold: float = 0.2  # 20% drawdown stops training
+    
+    # Scenario preferences
+    edge_case_probability: float = 0.2
+    market_volatility_multiplier: float = 1.0
+
+
+@dataclass
+class TrainingSession:
+    """Active training session for an agent"""
+    session_id: str
+    agent_id: str
+    start_time: datetime
+    config: TrainingConfig
+    scenarios_completed: int = 0
+    decisions_made: int = 0
+    total_pnl: float = 0.0
+    errors_encountered: int = 0
+    end_time: Optional[datetime] = None
+    
+    @property
+    def duration(self) -> timedelta:
+        end = self.end_time or datetime.now()
+        return end - self.start_time
+    
+    @property
+    def is_active(self) -> bool:
+        return self.end_time is None
+
+
+class TrainingBridge:
+    """
+    Central bridge between synthetic data generation and agent training.
+    
+    Coordinates data flow from synthetic generators through Redis to agents,
+    while tracking performance and updating learning systems.
+    """
+    
+    def __init__(
+        self,
+        orchestrator: HybridDataOrchestrator,
+        analytics: AgentAnalytics,
+        memory_system: AgentMemorySystem,
+        calibrator: ConfidenceCalibrator,
+        config: TrainingConfig = None
+    ):
+        self.orchestrator = orchestrator
+        self.analytics = analytics
+        self.memory_system = memory_system
+        self.calibrator = calibrator
+        self.config = config or TrainingConfig()
+        self.logger = logging.getLogger(__name__)
+        
+        # Redis connections
+        self.redis_client: Optional[redis.Redis] = None
+        self.publisher: Optional[redis.Redis] = None
+        
+        # Active training sessions
+        self.active_sessions: Dict[str, TrainingSession] = {}
+        
+        # Performance tracking
+        self.agent_metrics: Dict[str, Dict[str, float]] = defaultdict(dict)
+        
+        # Event routing
+        self.channel_mappings = {
+            "game_event": "espn:games",
+            "market_update": "kalshi:markets",
+            "trade_executed": "kalshi:trades",
+            "signal_generated": "kalshi:signals",
+            "sentiment_update": "twitter:sentiment"
+        }
+        
+        # Callbacks for agent responses
+        self.response_handlers: Dict[str, Callable] = {}
+        
+    async def initialize(self) -> None:
+        """Initialize the training bridge"""
+        try:
+            self.logger.info("Initializing Training Bridge")
+            
+            # Connect to Redis
+            await self._connect_redis()
+            
+            # Initialize orchestrator
+            await self.orchestrator.initialize()
+            
+            # Set up response listeners
+            await self._setup_response_listeners()
+            
+            self.logger.info("Training Bridge initialized successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize training bridge: {e}")
+            raise
+    
+    async def _connect_redis(self) -> None:
+        """Connect to Redis for pub/sub operations"""
+        try:
+            self.redis_client = redis.from_url(self.config.redis_url)
+            self.publisher = redis.from_url(self.config.redis_url)
+            
+            # Test connection
+            await self.redis_client.ping()
+            
+            self.logger.info("Connected to Redis for training bridge")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to connect to Redis: {e}")
+            raise
+    
+    async def _setup_response_listeners(self) -> None:
+        """Set up listeners for agent responses during training"""
+        try:
+            # Subscribe to agent response channels
+            pubsub = self.redis_client.pubsub()
+            
+            response_channels = [
+                f"{self.config.training_namespace}:agent_decisions",
+                f"{self.config.training_namespace}:agent_signals",
+                f"{self.config.training_namespace}:agent_trades"
+            ]
+            
+            await pubsub.subscribe(*response_channels)
+            
+            # Start listening in background
+            asyncio.create_task(self._listen_for_responses(pubsub))
+            
+            self.logger.info(f"Listening for agent responses on {response_channels}")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to setup response listeners: {e}")
+    
+    async def _listen_for_responses(self, pubsub) -> None:
+        """Listen for agent responses and process them"""
+        try:
+            async for message in pubsub.listen():
+                if message['type'] not in ('message', 'pmessage'):
+                    continue
+                
+                try:
+                    channel = message['channel'].decode('utf-8')
+                    data = json.loads(message['data'])
+                    
+                    # Extract agent ID and process response
+                    agent_id = data.get('agent_id')
+                    if agent_id and agent_id in self.active_sessions:
+                        await self._process_agent_response(agent_id, channel, data)
+                        
+                except Exception as e:
+                    self.logger.error(f"Error processing response: {e}")
+                    
+        except Exception as e:
+            self.logger.error(f"Response listener error: {e}")
+    
+    async def _process_agent_response(self, agent_id: str, channel: str, data: Dict[str, Any]) -> None:
+        """Process an agent's response during training"""
+        try:
+            session = self.active_sessions.get(agent_id)
+            if not session:
+                return
+            
+            # Update session statistics
+            session.decisions_made += 1
+            
+            # Extract decision details
+            if 'agent_decisions' in channel:
+                await self._track_decision(agent_id, data)
+            elif 'agent_trades' in channel:
+                await self._track_trade(agent_id, data)
+            elif 'agent_signals' in channel:
+                await self._track_signal(agent_id, data)
+            
+            # Update metrics
+            if 'pnl' in data:
+                session.total_pnl += data['pnl']
+            
+            # Check for training termination conditions
+            if await self._should_stop_training(session):
+                await self.stop_training_session(agent_id)
+                
+        except Exception as e:
+            self.logger.error(f"Failed to process agent response: {e}")
+            session.errors_encountered += 1
+    
+    async def _track_decision(self, agent_id: str, decision_data: Dict[str, Any]) -> None:
+        """Track a decision made by an agent during training"""
+        try:
+            # Create decision metrics
+            decision = DecisionMetrics(
+                decision_id=decision_data.get('decision_id', f"{agent_id}_{datetime.now().timestamp()}"),
+                agent_id=agent_id,
+                scenario_id=decision_data.get('scenario_id', 'unknown'),
+                timestamp=datetime.now(),
+                market_ticker=decision_data.get('market_ticker', ''),
+                decision_type=decision_data.get('decision_type', 'hold'),
+                confidence=decision_data.get('confidence', 0.5),
+                expected_value=decision_data.get('expected_value', 0.0),
+                kelly_fraction=decision_data.get('kelly_fraction', 0.0),
+                actual_kelly_used=decision_data.get('actual_kelly_used', 0.0),
+                position_size=decision_data.get('position_size', 0.0),
+                market_efficiency=decision_data.get('market_efficiency', 0.8),
+                information_advantage=decision_data.get('information_advantage', 0.0),
+                execution_latency=decision_data.get('latency', 0.0)
+            )
+            
+            # Record in analytics
+            await self.analytics.record_decision(decision)
+            
+            # Update memory if configured
+            if self.config.update_memory:
+                await self.memory_system.store_agent_experience(
+                    agent_id=agent_id,
+                    scenario_id=decision.scenario_id,
+                    action={
+                        'type': decision.decision_type,
+                        'confidence': decision.confidence,
+                        'position_size': decision.position_size
+                    },
+                    outcome={'pending': True},  # Will be updated later
+                    context=decision_data.get('context', {})
+                )
+            
+            # Calibrate confidence if configured
+            if self.config.calibrate_confidence:
+                calibrated_score = await self.calibrator.calibrate_confidence(
+                    agent_id=agent_id,
+                    raw_confidence=decision.confidence,
+                    context=decision_data.get('context', {})
+                )
+                
+                # Store calibration result
+                self.agent_metrics[agent_id]['calibrated_confidence'] = calibrated_score.calibrated_confidence
+                self.agent_metrics[agent_id]['confidence_uncertainty'] = calibrated_score.uncertainty
+                
+        except Exception as e:
+            self.logger.error(f"Failed to track decision: {e}")
+    
+    async def _track_trade(self, agent_id: str, trade_data: Dict[str, Any]) -> None:
+        """Track a trade execution during training"""
+        try:
+            # Update agent metrics
+            self.agent_metrics[agent_id]['trades_executed'] = \
+                self.agent_metrics[agent_id].get('trades_executed', 0) + 1
+            
+            # Track trade outcome
+            if trade_data.get('status') == 'FILLED':
+                self.agent_metrics[agent_id]['successful_trades'] = \
+                    self.agent_metrics[agent_id].get('successful_trades', 0) + 1
+                    
+        except Exception as e:
+            self.logger.error(f"Failed to track trade: {e}")
+    
+    async def _track_signal(self, agent_id: str, signal_data: Dict[str, Any]) -> None:
+        """Track a signal generated during training"""
+        try:
+            # Update agent metrics
+            self.agent_metrics[agent_id]['signals_generated'] = \
+                self.agent_metrics[agent_id].get('signals_generated', 0) + 1
+            
+            # Track signal quality
+            confidence = signal_data.get('confidence', 0.5)
+            if confidence > 0.7:
+                self.agent_metrics[agent_id]['high_confidence_signals'] = \
+                    self.agent_metrics[agent_id].get('high_confidence_signals', 0) + 1
+                    
+        except Exception as e:
+            self.logger.error(f"Failed to track signal: {e}")
+    
+    async def _should_stop_training(self, session: TrainingSession) -> bool:
+        """Check if training should be stopped based on performance"""
+        try:
+            # Check drawdown threshold
+            if session.total_pnl < -self.config.stop_loss_threshold:
+                self.logger.warning(f"Stopping training for {session.agent_id}: Drawdown exceeded")
+                return True
+            
+            # Check error rate
+            if session.errors_encountered > 100:
+                self.logger.warning(f"Stopping training for {session.agent_id}: Too many errors")
+                return True
+            
+            # Check minimum decisions
+            if session.decisions_made > 10000:
+                self.logger.info(f"Stopping training for {session.agent_id}: Maximum decisions reached")
+                return True
+            
+            return False
+            
+        except Exception as e:
+            self.logger.error(f"Error checking stop conditions: {e}")
+            return False
+    
+    async def start_training_session(
+        self,
+        agent_id: str,
+        scenarios: TrainingScenarioSet,
+        config: Optional[TrainingConfig] = None
+    ) -> str:
+        """
+        Start a new training session for an agent.
+        
+        Args:
+            agent_id: Unique identifier for the agent
+            scenarios: Set of training scenarios to use
+            config: Optional training configuration override
+            
+        Returns:
+            Session ID for the training session
+        """
+        try:
+            # Use provided config or default
+            session_config = config or self.config
+            
+            # Create session
+            session_id = f"{agent_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            session = TrainingSession(
+                session_id=session_id,
+                agent_id=agent_id,
+                start_time=datetime.now(),
+                config=session_config
+            )
+            
+            self.active_sessions[agent_id] = session
+            
+            # Start scenario injection
+            asyncio.create_task(self._run_training_scenarios(session, scenarios))
+            
+            self.logger.info(f"Started training session {session_id} for agent {agent_id}")
+            return session_id
+            
+        except Exception as e:
+            self.logger.error(f"Failed to start training session: {e}")
+            raise
+    
+    async def _run_training_scenarios(self, session: TrainingSession, scenarios: TrainingScenarioSet) -> None:
+        """Run training scenarios for a session"""
+        try:
+            for scenario in scenarios.scenarios:
+                if not session.is_active:
+                    break
+                
+                # Convert scenario to events
+                events = await self._scenario_to_events(scenario)
+                
+                # Inject events into Redis with timing
+                for event in events:
+                    if not session.is_active:
+                        break
+                    
+                    # Apply time acceleration
+                    delay = event.metadata.get('delay', 0.1) / session.config.time_acceleration
+                    await asyncio.sleep(delay)
+                    
+                    # Add noise if configured
+                    if session.config.inject_noise:
+                        event = self._add_noise_to_event(event, session.config.noise_level)
+                    
+                    # Publish to appropriate channel
+                    await self._publish_training_event(event, session)
+                
+                session.scenarios_completed += 1
+                
+                # Update progress
+                await self._update_training_progress(session)
+            
+            # Session complete
+            if session.is_active:
+                await self.stop_training_session(session.agent_id)
+                
+        except Exception as e:
+            self.logger.error(f"Error running training scenarios: {e}")
+            session.errors_encountered += 1
+    
+    async def _scenario_to_events(self, scenario: Any) -> List[StandardizedEvent]:
+        """Convert a training scenario to standardized events"""
+        try:
+            events = []
+            
+            # Handle different scenario types
+            if hasattr(scenario, 'game') and scenario.game:
+                # Game scenario
+                for play in scenario.game.plays:
+                    event = StandardizedEvent(
+                        event_id=f"training_{play.play_id}",
+                        game_id=scenario.game.game_id,
+                        timestamp=play.timestamp,
+                        event_type=play.play_type,
+                        description=play.description,
+                        team_possession=play.team_possession,
+                        score_home=play.score_home,
+                        score_away=play.score_away,
+                        quarter=play.quarter,
+                        time_remaining=play.time_remaining,
+                        metadata={
+                            'training': True,
+                            'scenario_id': scenario.scenario_id,
+                            'delay': 0.1  # Default delay between events
+                        }
+                    )
+                    events.append(event)
+            
+            elif hasattr(scenario, 'market_events'):
+                # Market scenario
+                for market_event in scenario.market_events:
+                    event = StandardizedEvent(
+                        event_id=f"training_market_{market_event.event_id}",
+                        game_id=scenario.market_ticker,
+                        timestamp=market_event.timestamp,
+                        event_type="market_update",
+                        description=f"Price: {market_event.price}",
+                        metadata={
+                            'training': True,
+                            'scenario_id': scenario.scenario_id,
+                            'price': market_event.price,
+                            'volume': market_event.volume,
+                            'delay': 0.05
+                        }
+                    )
+                    events.append(event)
+            
+            return events
+            
+        except Exception as e:
+            self.logger.error(f"Failed to convert scenario to events: {e}")
+            return []
+    
+    def _add_noise_to_event(self, event: StandardizedEvent, noise_level: float) -> StandardizedEvent:
+        """Add realistic noise to training events"""
+        try:
+            import random
+            
+            # Add noise to numeric fields
+            if hasattr(event, 'score_home') and event.score_home is not None:
+                # Don't add noise to scores (they're discrete)
+                pass
+            
+            # Add noise to metadata prices
+            if 'price' in event.metadata:
+                original_price = event.metadata['price']
+                noise = random.gauss(0, noise_level * original_price)
+                event.metadata['price'] = max(0.01, min(0.99, original_price + noise))
+            
+            # Add timing jitter
+            if 'delay' in event.metadata:
+                original_delay = event.metadata['delay']
+                jitter = random.gauss(0, noise_level * original_delay)
+                event.metadata['delay'] = max(0.01, original_delay + jitter)
+            
+            return event
+            
+        except Exception as e:
+            self.logger.error(f"Failed to add noise to event: {e}")
+            return event
+    
+    async def _publish_training_event(self, event: StandardizedEvent, session: TrainingSession) -> None:
+        """Publish training event to appropriate Redis channel"""
+        try:
+            # Determine channel based on event type
+            channel = self._get_channel_for_event(event)
+            
+            # Add training namespace if configured
+            if session.config.training_namespace:
+                channel = f"{session.config.training_namespace}:{channel}"
+            
+            # Prepare message
+            message = {
+                "timestamp": event.timestamp.isoformat() if hasattr(event.timestamp, 'isoformat') else str(event.timestamp),
+                "source": "training_bridge",
+                "training_session": session.session_id,
+                "data": {
+                    "event_id": event.event_id,
+                    "game_id": event.game_id,
+                    "event_type": event.event_type,
+                    "description": event.description,
+                    "metadata": event.metadata
+                }
+            }
+            
+            # Add event-specific data
+            if event.event_type in ["score_update", "big_play"]:
+                message["data"]["score_home"] = event.score_home
+                message["data"]["score_away"] = event.score_away
+                message["data"]["quarter"] = event.quarter
+                message["data"]["time_remaining"] = event.time_remaining
+            
+            # Publish to Redis
+            await self.publisher.publish(channel, json.dumps(message))
+            
+        except Exception as e:
+            self.logger.error(f"Failed to publish training event: {e}")
+    
+    def _get_channel_for_event(self, event: StandardizedEvent) -> str:
+        """Determine the appropriate Redis channel for an event"""
+        event_type = event.event_type.lower() if event.event_type else "unknown"
+        
+        # Map event types to channels
+        if "market" in event_type or "price" in event_type:
+            return "kalshi:markets"
+        elif "trade" in event_type:
+            return "kalshi:trades"
+        elif "signal" in event_type:
+            return "kalshi:signals"
+        elif "sentiment" in event_type:
+            return "twitter:sentiment"
+        else:
+            return "espn:games"  # Default to game events
+    
+    async def _update_training_progress(self, session: TrainingSession) -> None:
+        """Update training progress metrics"""
+        try:
+            # Calculate progress metrics
+            elapsed_time = (datetime.now() - session.start_time).total_seconds()
+            scenarios_per_minute = (session.scenarios_completed / elapsed_time) * 60 if elapsed_time > 0 else 0
+            
+            # Log progress
+            self.logger.info(
+                f"Training progress for {session.agent_id}: "
+                f"{session.scenarios_completed} scenarios, "
+                f"{session.decisions_made} decisions, "
+                f"P&L: {session.total_pnl:.2f}, "
+                f"Rate: {scenarios_per_minute:.1f} scenarios/min"
+            )
+            
+            # Update agent metrics
+            self.agent_metrics[session.agent_id]['scenarios_completed'] = session.scenarios_completed
+            self.agent_metrics[session.agent_id]['training_pnl'] = session.total_pnl
+            
+        except Exception as e:
+            self.logger.error(f"Failed to update training progress: {e}")
+    
+    async def stop_training_session(self, agent_id: str) -> Dict[str, Any]:
+        """
+        Stop a training session and return final metrics.
+        
+        Args:
+            agent_id: Agent whose training session to stop
+            
+        Returns:
+            Final training metrics and summary
+        """
+        try:
+            session = self.active_sessions.get(agent_id)
+            if not session:
+                return {"error": f"No active session for agent {agent_id}"}
+            
+            # Mark session as ended
+            session.end_time = datetime.now()
+            
+            # Generate final analytics
+            final_metrics = {
+                "session_id": session.session_id,
+                "agent_id": agent_id,
+                "duration": str(session.duration),
+                "scenarios_completed": session.scenarios_completed,
+                "decisions_made": session.decisions_made,
+                "total_pnl": session.total_pnl,
+                "errors_encountered": session.errors_encountered,
+                "agent_metrics": dict(self.agent_metrics.get(agent_id, {}))
+            }
+            
+            # Trigger final calibration update if needed
+            if session.config.calibrate_confidence and session.decisions_made > 50:
+                await self._trigger_calibration_update(agent_id)
+            
+            # Clean up session
+            del self.active_sessions[agent_id]
+            
+            self.logger.info(f"Stopped training session for agent {agent_id}")
+            return final_metrics
+            
+        except Exception as e:
+            self.logger.error(f"Failed to stop training session: {e}")
+            return {"error": str(e)}
+    
+    async def _trigger_calibration_update(self, agent_id: str) -> None:
+        """Trigger confidence calibration update for an agent"""
+        try:
+            # Get recent decisions from analytics
+            recent_analytics = await self.analytics.get_agent_analytics(
+                agent_id, timedelta(hours=1)
+            )
+            
+            # Check if calibration update is needed
+            if await self.calibrator.should_update_calibration(agent_id):
+                self.logger.info(f"Triggering calibration update for agent {agent_id}")
+                # Calibration will be updated in next decision cycle
+                
+        except Exception as e:
+            self.logger.error(f"Failed to trigger calibration update: {e}")
+    
+    def register_response_handler(self, event_type: str, handler: Callable) -> None:
+        """Register a handler for specific agent response types"""
+        self.response_handlers[event_type] = handler
+        self.logger.info(f"Registered response handler for {event_type}")
+    
+    async def get_training_status(self) -> Dict[str, Any]:
+        """Get status of all active training sessions"""
+        try:
+            status = {
+                "active_sessions": len(self.active_sessions),
+                "sessions": {}
+            }
+            
+            for agent_id, session in self.active_sessions.items():
+                status["sessions"][agent_id] = {
+                    "session_id": session.session_id,
+                    "started": session.start_time.isoformat(),
+                    "duration": str(session.duration),
+                    "scenarios_completed": session.scenarios_completed,
+                    "decisions_made": session.decisions_made,
+                    "current_pnl": session.total_pnl,
+                    "mode": session.config.mode.value
+                }
+            
+            return status
+            
+        except Exception as e:
+            self.logger.error(f"Failed to get training status: {e}")
+            return {"error": str(e)}
+    
+    async def shutdown(self) -> None:
+        """Gracefully shutdown the training bridge"""
+        try:
+            self.logger.info("Shutting down Training Bridge")
+            
+            # Stop all active sessions
+            for agent_id in list(self.active_sessions.keys()):
+                await self.stop_training_session(agent_id)
+            
+            # Close Redis connections
+            if self.redis_client:
+                await self.redis_client.close()
+            if self.publisher:
+                await self.publisher.close()
+            
+            self.logger.info("Training Bridge shutdown complete")
+            
+        except Exception as e:
+            self.logger.error(f"Error during shutdown: {e}")
\ No newline at end of file
diff --git a/src/integration/training_harness.py b/src/integration/training_harness.py
new file mode 100644
index 00000000..aa9c0aec
--- /dev/null
+++ b/src/integration/training_harness.py
@@ -0,0 +1,845 @@
+"""
+Agent Training Harness
+
+Orchestrates complete training sessions for agents, coordinating
+between synthetic data generation, agent execution, and performance monitoring.
+"""
+
+import asyncio
+import json
+import logging
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import Dict, List, Optional, Any, Set, Tuple
+from dataclasses import dataclass, field
+import redis.asyncio as redis
+
+from ..synthetic_data.generators.game_engine import SyntheticGameEngine, SyntheticGame
+from ..synthetic_data.generators.market_simulator import MarketSimulator
+from ..synthetic_data.generators.scenario_builder import TrainingScenarioSet
+from ..training.memory_system import AgentMemorySystem
+from ..confidence_calibration.calibrator import ConfidenceCalibrator
+from ..training.agent_analytics import AgentAnalytics
+from .synthetic_injector import SyntheticDataInjector, InjectionConfig, EventTiming
+from .training_bridge import TrainingBridge, TrainingConfig, TrainingMode
+
+logger = logging.getLogger(__name__)
+
+
+class TrainingScenario(Enum):
+    """Pre-defined training scenarios"""
+    BASIC_GAME = "basic_game"
+    CLOSE_GAME = "close_game"
+    BLOWOUT = "blowout"
+    COMEBACK = "comeback"
+    HIGH_VOLATILITY = "high_volatility"
+    LOW_LIQUIDITY = "low_liquidity"
+    NEWS_DRIVEN = "news_driven"
+    INJURY_SCENARIO = "injury_scenario"
+    WEATHER_IMPACT = "weather_impact"
+    MOMENTUM_SHIFT = "momentum_shift"
+
+
+@dataclass
+class HarnessConfig:
+    """Configuration for training harness"""
+    redis_url: str = "redis://localhost:6379"
+    
+    # Training parameters
+    scenarios_per_session: int = 10
+    warmup_scenarios: int = 2
+    evaluation_scenarios: int = 3
+    
+    # Timing configuration
+    scenario_spacing_seconds: float = 5.0
+    decision_timeout_seconds: float = 30.0
+    between_session_delay: float = 60.0
+    
+    # Performance thresholds
+    min_accuracy_threshold: float = 0.6
+    min_profit_threshold: float = -0.1
+    max_drawdown_threshold: float = 0.2
+    
+    # Adaptive training
+    enable_adaptive_difficulty: bool = True
+    difficulty_adjustment_rate: float = 0.1
+    performance_window_size: int = 5
+    
+    # Monitoring
+    enable_real_time_monitoring: bool = True
+    checkpoint_frequency: int = 5
+    performance_report_frequency: int = 10
+
+
+@dataclass
+class TrainingMetrics:
+    """Metrics tracked during training"""
+    scenario_count: int = 0
+    decision_count: int = 0
+    successful_trades: int = 0
+    failed_trades: int = 0
+    
+    total_profit: float = 0.0
+    max_drawdown: float = 0.0
+    sharpe_ratio: float = 0.0
+    win_rate: float = 0.0
+    
+    avg_decision_time: float = 0.0
+    avg_confidence: float = 0.0
+    confidence_calibration_error: float = 0.0
+    
+    exploration_rate: float = 0.0
+    learning_rate: float = 0.0
+    
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+
+
+@dataclass
+class ScenarioResult:
+    """Result from running a single scenario"""
+    scenario_id: str
+    scenario_type: TrainingScenario
+    start_time: datetime
+    end_time: datetime
+    
+    decisions_made: int
+    profit_loss: float
+    accuracy: float
+    avg_confidence: float
+    
+    events_processed: int
+    errors: List[str]
+    
+    agent_state: Dict[str, Any]
+    market_conditions: Dict[str, Any]
+
+
+class AgentTrainingHarness:
+    """
+    Orchestrates complete training sessions for agents.
+    
+    Coordinates between synthetic data generation, agent execution,
+    and performance monitoring to provide comprehensive training.
+    """
+    
+    def __init__(self, config: HarnessConfig):
+        self.config = config
+        self.redis_client: Optional[redis.Redis] = None
+        
+        # Core components
+        self.training_bridge = TrainingBridge()
+        self.data_injector = SyntheticDataInjector(InjectionConfig())
+        self.memory_system = AgentMemorySystem()
+        self.calibrator = ConfidenceCalibrator()
+        self.analytics = AgentAnalytics()
+        
+        # Generators
+        self.game_engine = SyntheticGameEngine()
+        self.market_sim = MarketSimulator()
+        
+        # State tracking
+        self.active_sessions: Dict[str, Dict[str, Any]] = {}
+        self.scenario_queue: List[TrainingScenario] = []
+        self.metrics: Dict[str, TrainingMetrics] = {}
+        
+        # Performance tracking
+        self.performance_history: List[ScenarioResult] = []
+        self.current_difficulty: float = 0.5
+        
+    async def initialize(self):
+        """Initialize harness components"""
+        self.redis_client = redis.from_url(self.config.redis_url)
+        
+        # Initialize components
+        await self.training_bridge.initialize()
+        await self.data_injector.initialize()
+        
+        # Set up monitoring
+        if self.config.enable_real_time_monitoring:
+            asyncio.create_task(self._monitor_performance())
+            
+        logger.info("Training harness initialized")
+        
+    async def run_training_session(
+        self,
+        agent_id: str,
+        scenarios: List[TrainingScenario],
+        training_mode: TrainingMode = TrainingMode.EXPLORATION
+    ) -> Dict[str, Any]:
+        """
+        Run a complete training session for an agent.
+        
+        Args:
+            agent_id: ID of agent to train
+            scenarios: List of scenarios to run
+            training_mode: Training mode to use
+            
+        Returns:
+            Session results and metrics
+        """
+        session_id = f"session_{agent_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        
+        # Initialize session
+        self.active_sessions[session_id] = {
+            'agent_id': agent_id,
+            'start_time': datetime.now(),
+            'scenarios': scenarios,
+            'mode': training_mode,
+            'results': []
+        }
+        
+        self.metrics[session_id] = TrainingMetrics()
+        
+        try:
+            # Run warmup scenarios
+            if self.config.warmup_scenarios > 0:
+                warmup_scenarios = scenarios[:self.config.warmup_scenarios]
+                await self._run_warmup(session_id, agent_id, warmup_scenarios)
+            
+            # Run training scenarios
+            training_scenarios = scenarios[self.config.warmup_scenarios:]
+            results = []
+            
+            for i, scenario in enumerate(training_scenarios):
+                # Adjust difficulty if adaptive training enabled
+                if self.config.enable_adaptive_difficulty:
+                    await self._adjust_difficulty(session_id)
+                
+                # Run scenario
+                result = await self._run_scenario(
+                    session_id,
+                    agent_id,
+                    scenario,
+                    training_mode
+                )
+                
+                results.append(result)
+                self.performance_history.append(result)
+                
+                # Update metrics
+                await self._update_metrics(session_id, result)
+                
+                # Checkpoint if needed
+                if (i + 1) % self.config.checkpoint_frequency == 0:
+                    await self._create_checkpoint(session_id, agent_id)
+                
+                # Performance report
+                if (i + 1) % self.config.performance_report_frequency == 0:
+                    await self._generate_performance_report(session_id)
+                
+                # Delay between scenarios
+                await asyncio.sleep(self.config.scenario_spacing_seconds)
+            
+            # Run evaluation scenarios
+            if self.config.evaluation_scenarios > 0:
+                eval_results = await self._run_evaluation(
+                    session_id,
+                    agent_id,
+                    scenarios[-self.config.evaluation_scenarios:]
+                )
+                results.extend(eval_results)
+            
+            # Generate final report
+            report = await self._generate_final_report(session_id, results)
+            
+            # Clean up session
+            self.active_sessions[session_id]['end_time'] = datetime.now()
+            self.active_sessions[session_id]['results'] = results
+            
+            return report
+            
+        except Exception as e:
+            logger.error(f"Training session failed: {e}")
+            self.metrics[session_id].errors.append(str(e))
+            raise
+            
+    async def _run_scenario(
+        self,
+        session_id: str,
+        agent_id: str,
+        scenario: TrainingScenario,
+        mode: TrainingMode
+    ) -> ScenarioResult:
+        """Run a single training scenario"""
+        scenario_id = f"{session_id}_{scenario.value}_{datetime.now().timestamp()}"
+        start_time = datetime.now()
+        
+        try:
+            # Generate scenario data
+            if scenario in [TrainingScenario.BASIC_GAME, TrainingScenario.CLOSE_GAME,
+                           TrainingScenario.BLOWOUT, TrainingScenario.COMEBACK]:
+                # Game scenario
+                game_data = await self._generate_game_scenario(scenario)
+                await self.data_injector.inject_game_scenario(
+                    game_data['game'],
+                    game_data['plays'],
+                    timing=EventTiming.ACCELERATED
+                )
+                
+            else:
+                # Trading scenario
+                trading_data = await self._generate_trading_scenario(scenario)
+                await self.data_injector.inject_trading_scenario(
+                    trading_data['events'],
+                    timing=EventTiming.ACCELERATED
+                )
+            
+            # Wait for agent decisions
+            decisions = await self._collect_agent_decisions(
+                agent_id,
+                scenario_id,
+                timeout=self.config.decision_timeout_seconds
+            )
+            
+            # Calculate performance metrics
+            metrics = await self._calculate_scenario_metrics(
+                decisions,
+                scenario
+            )
+            
+            end_time = datetime.now()
+            
+            return ScenarioResult(
+                scenario_id=scenario_id,
+                scenario_type=scenario,
+                start_time=start_time,
+                end_time=end_time,
+                decisions_made=len(decisions),
+                profit_loss=metrics['profit_loss'],
+                accuracy=metrics['accuracy'],
+                avg_confidence=metrics['avg_confidence'],
+                events_processed=metrics['events_processed'],
+                errors=[],
+                agent_state=await self._get_agent_state(agent_id),
+                market_conditions=metrics.get('market_conditions', {})
+            )
+            
+        except Exception as e:
+            logger.error(f"Scenario {scenario_id} failed: {e}")
+            return ScenarioResult(
+                scenario_id=scenario_id,
+                scenario_type=scenario,
+                start_time=start_time,
+                end_time=datetime.now(),
+                decisions_made=0,
+                profit_loss=0.0,
+                accuracy=0.0,
+                avg_confidence=0.0,
+                events_processed=0,
+                errors=[str(e)],
+                agent_state={},
+                market_conditions={}
+            )
+            
+    async def _generate_game_scenario(
+        self,
+        scenario: TrainingScenario
+    ) -> Dict[str, Any]:
+        """Generate game scenario data"""
+        if scenario == TrainingScenario.BASIC_GAME:
+            game = await self.game_engine.generate_game(
+                home_team="Team A",
+                away_team="Team B",
+                home_strength=0.5,
+                away_strength=0.5
+            )
+            plays = await self.game_engine.generate_plays(game, num_plays=50)
+            
+        elif scenario == TrainingScenario.CLOSE_GAME:
+            game = await self.game_engine.generate_game(
+                home_team="Team A",
+                away_team="Team B",
+                home_strength=0.52,
+                away_strength=0.48
+            )
+            plays = await self.game_engine.generate_plays(game, num_plays=60)
+            
+        elif scenario == TrainingScenario.BLOWOUT:
+            game = await self.game_engine.generate_game(
+                home_team="Team A",
+                away_team="Team B",
+                home_strength=0.7,
+                away_strength=0.3
+            )
+            plays = await self.game_engine.generate_plays(game, num_plays=45)
+            
+        elif scenario == TrainingScenario.COMEBACK:
+            game = await self.game_engine.generate_game(
+                home_team="Team A",
+                away_team="Team B",
+                home_strength=0.4,
+                away_strength=0.6
+            )
+            plays = await self.game_engine.generate_plays(game, num_plays=70)
+            # Simulate comeback in second half
+            for play in plays[35:]:
+                if hasattr(play, 'scoring_play'):
+                    play.scoring_play = play.scoring_play and play.quarter >= 3
+                    
+        else:
+            raise ValueError(f"Unknown game scenario: {scenario}")
+            
+        return {'game': game, 'plays': plays}
+        
+    async def _generate_trading_scenario(
+        self,
+        scenario: TrainingScenario
+    ) -> Dict[str, Any]:
+        """Generate trading scenario data"""
+        # First generate a game for the trading scenario
+        if scenario == TrainingScenario.HIGH_VOLATILITY:
+            # Close game with high volatility
+            game = await self.game_engine.generate_game(
+                home_team="Team A",
+                away_team="Team B",
+                home_strength=0.51,
+                away_strength=0.49
+            )
+            trading_scenario = self.market_sim.create_trading_scenario(
+                game=game,
+                scenario_type="high_volatility",
+                market_efficiency=0.6
+            )
+            
+        elif scenario == TrainingScenario.LOW_LIQUIDITY:
+            # Low-profile game
+            game = await self.game_engine.generate_game(
+                home_team="Team C",
+                away_team="Team D",
+                home_strength=0.45,
+                away_strength=0.55
+            )
+            trading_scenario = self.market_sim.create_trading_scenario(
+                game=game,
+                scenario_type="low_liquidity",
+                market_efficiency=0.4
+            )
+            
+        elif scenario == TrainingScenario.NEWS_DRIVEN:
+            # Game with injury/news events
+            game = await self.game_engine.generate_game(
+                home_team="Team E",
+                away_team="Team F",
+                home_strength=0.6,
+                away_strength=0.4
+            )
+            trading_scenario = self.market_sim.create_trading_scenario(
+                game=game,
+                scenario_type="news_driven",
+                information_delay=0.3,
+                market_efficiency=0.7
+            )
+            
+        elif scenario == TrainingScenario.MOMENTUM_SHIFT:
+            # Game with momentum shifts
+            game = await self.game_engine.generate_game(
+                home_team="Team G",
+                away_team="Team H",
+                home_strength=0.48,
+                away_strength=0.52
+            )
+            trading_scenario = self.market_sim.create_trading_scenario(
+                game=game,
+                scenario_type="momentum_shift",
+                market_efficiency=0.75
+            )
+            
+        else:
+            # Default trading scenario
+            game = await self.game_engine.generate_game(
+                home_team="Team X",
+                away_team="Team Y",
+                home_strength=0.5,
+                away_strength=0.5
+            )
+            trading_scenario = self.market_sim.create_trading_scenario(
+                game=game,
+                scenario_type="regular"
+            )
+            
+        # Convert to standardized events
+        events = self.market_sim.convert_to_standardized_events(trading_scenario)
+        
+        return {'events': events}
+        
+    async def _collect_agent_decisions(
+        self,
+        agent_id: str,
+        scenario_id: str,
+        timeout: float
+    ) -> List[Dict[str, Any]]:
+        """Collect decisions made by agent during scenario"""
+        decisions = []
+        start_time = datetime.now()
+        
+        # Subscribe to agent decision channel
+        pubsub = self.redis_client.pubsub()
+        await pubsub.subscribe(f"agent:{agent_id}:decisions")
+        
+        try:
+            while (datetime.now() - start_time).total_seconds() < timeout:
+                message = await pubsub.get_message(timeout=1.0)
+                
+                if message and message['type'] == 'message':
+                    try:
+                        decision = json.loads(message['data'])
+                        decision['scenario_id'] = scenario_id
+                        decision['timestamp'] = datetime.now().isoformat()
+                        decisions.append(decision)
+                    except json.JSONDecodeError:
+                        logger.warning(f"Invalid decision data: {message['data']}")
+                        
+        finally:
+            await pubsub.unsubscribe(f"agent:{agent_id}:decisions")
+            await pubsub.close()
+            
+        return decisions
+        
+    async def _calculate_scenario_metrics(
+        self,
+        decisions: List[Dict[str, Any]],
+        scenario: TrainingScenario
+    ) -> Dict[str, Any]:
+        """Calculate performance metrics for scenario"""
+        if not decisions:
+            return {
+                'profit_loss': 0.0,
+                'accuracy': 0.0,
+                'avg_confidence': 0.0,
+                'events_processed': 0,
+                'market_conditions': {}
+            }
+            
+        # Calculate P&L
+        profit_loss = sum(d.get('profit_loss', 0.0) for d in decisions)
+        
+        # Calculate accuracy (correct predictions)
+        correct = sum(1 for d in decisions if d.get('correct', False))
+        accuracy = correct / len(decisions) if decisions else 0.0
+        
+        # Calculate average confidence
+        confidences = [d.get('confidence', 0.5) for d in decisions]
+        avg_confidence = sum(confidences) / len(confidences) if confidences else 0.5
+        
+        # Count events
+        events_processed = len(set(d.get('event_id') for d in decisions if d.get('event_id')))
+        
+        # Extract market conditions
+        market_conditions = {
+            'volatility': self._estimate_volatility(decisions),
+            'trend': self._estimate_trend(decisions),
+            'liquidity': self._estimate_liquidity(decisions)
+        }
+        
+        return {
+            'profit_loss': profit_loss,
+            'accuracy': accuracy,
+            'avg_confidence': avg_confidence,
+            'events_processed': events_processed,
+            'market_conditions': market_conditions
+        }
+        
+    async def _update_metrics(self, session_id: str, result: ScenarioResult):
+        """Update session metrics with scenario result"""
+        metrics = self.metrics[session_id]
+        
+        metrics.scenario_count += 1
+        metrics.decision_count += result.decisions_made
+        
+        if result.profit_loss > 0:
+            metrics.successful_trades += 1
+        else:
+            metrics.failed_trades += 1
+            
+        metrics.total_profit += result.profit_loss
+        
+        # Update running averages
+        alpha = 0.1  # Exponential moving average factor
+        metrics.avg_confidence = (1 - alpha) * metrics.avg_confidence + alpha * result.avg_confidence
+        
+        # Calculate win rate
+        total_trades = metrics.successful_trades + metrics.failed_trades
+        metrics.win_rate = metrics.successful_trades / total_trades if total_trades > 0 else 0.0
+        
+        # Track errors
+        metrics.errors.extend(result.errors)
+        
+    async def _adjust_difficulty(self, session_id: str):
+        """Adjust scenario difficulty based on performance"""
+        metrics = self.metrics[session_id]
+        
+        # Get recent performance
+        recent_results = self.performance_history[-self.config.performance_window_size:]
+        if not recent_results:
+            return
+            
+        # Calculate performance score
+        avg_accuracy = sum(r.accuracy for r in recent_results) / len(recent_results)
+        avg_profit = sum(r.profit_loss for r in recent_results) / len(recent_results)
+        
+        performance_score = 0.6 * avg_accuracy + 0.4 * (1.0 if avg_profit > 0 else 0.0)
+        
+        # Adjust difficulty
+        if performance_score > 0.7:
+            # Increase difficulty
+            self.current_difficulty = min(1.0, self.current_difficulty + self.config.difficulty_adjustment_rate)
+        elif performance_score < 0.4:
+            # Decrease difficulty
+            self.current_difficulty = max(0.0, self.current_difficulty - self.config.difficulty_adjustment_rate)
+            
+        logger.info(f"Adjusted difficulty to {self.current_difficulty:.2f} (performance: {performance_score:.2f})")
+        
+    async def _create_checkpoint(self, session_id: str, agent_id: str):
+        """Create training checkpoint"""
+        checkpoint = {
+            'session_id': session_id,
+            'agent_id': agent_id,
+            'timestamp': datetime.now().isoformat(),
+            'metrics': self.metrics[session_id].__dict__,
+            'difficulty': self.current_difficulty,
+            'scenario_count': len(self.performance_history)
+        }
+        
+        # Save to Redis
+        await self.redis_client.hset(
+            f"training:checkpoints:{session_id}",
+            datetime.now().isoformat(),
+            json.dumps(checkpoint)
+        )
+        
+        logger.info(f"Created checkpoint for session {session_id}")
+        
+    async def _generate_performance_report(self, session_id: str):
+        """Generate intermediate performance report"""
+        metrics = self.metrics[session_id]
+        
+        report = {
+            'session_id': session_id,
+            'timestamp': datetime.now().isoformat(),
+            'scenarios_completed': metrics.scenario_count,
+            'total_decisions': metrics.decision_count,
+            'win_rate': metrics.win_rate,
+            'total_profit': metrics.total_profit,
+            'avg_confidence': metrics.avg_confidence,
+            'current_difficulty': self.current_difficulty
+        }
+        
+        # Publish report
+        await self.redis_client.publish(
+            f"training:reports:{session_id}",
+            json.dumps(report)
+        )
+        
+        logger.info(f"Performance report: Win rate={metrics.win_rate:.2%}, Profit={metrics.total_profit:.2f}")
+        
+    async def _generate_final_report(
+        self,
+        session_id: str,
+        results: List[ScenarioResult]
+    ) -> Dict[str, Any]:
+        """Generate final training report"""
+        metrics = self.metrics[session_id]
+        session = self.active_sessions[session_id]
+        
+        # Calculate final statistics
+        total_profit = sum(r.profit_loss for r in results)
+        avg_accuracy = sum(r.accuracy for r in results) / len(results) if results else 0.0
+        
+        # Calculate Sharpe ratio
+        if len(results) > 1:
+            returns = [r.profit_loss for r in results]
+            avg_return = sum(returns) / len(returns)
+            std_return = (sum((r - avg_return) ** 2 for r in returns) / len(returns)) ** 0.5
+            sharpe_ratio = avg_return / std_return if std_return > 0 else 0.0
+        else:
+            sharpe_ratio = 0.0
+            
+        report = {
+            'session_id': session_id,
+            'agent_id': session['agent_id'],
+            'start_time': session['start_time'].isoformat(),
+            'end_time': datetime.now().isoformat(),
+            'duration_minutes': (datetime.now() - session['start_time']).total_seconds() / 60,
+            
+            'scenarios_run': len(results),
+            'total_decisions': sum(r.decisions_made for r in results),
+            
+            'performance': {
+                'total_profit': total_profit,
+                'avg_accuracy': avg_accuracy,
+                'win_rate': metrics.win_rate,
+                'sharpe_ratio': sharpe_ratio,
+                'max_drawdown': metrics.max_drawdown,
+                'avg_confidence': metrics.avg_confidence
+            },
+            
+            'training_progress': {
+                'starting_difficulty': 0.5,
+                'ending_difficulty': self.current_difficulty,
+                'exploration_rate': metrics.exploration_rate,
+                'learning_rate': metrics.learning_rate
+            },
+            
+            'errors': metrics.errors,
+            'warnings': metrics.warnings,
+            
+            'recommendations': self._generate_recommendations(metrics, results)
+        }
+        
+        # Save final report
+        await self.redis_client.set(
+            f"training:final_report:{session_id}",
+            json.dumps(report),
+            ex=86400  # Expire after 24 hours
+        )
+        
+        return report
+        
+    def _generate_recommendations(
+        self,
+        metrics: TrainingMetrics,
+        results: List[ScenarioResult]
+    ) -> List[str]:
+        """Generate training recommendations based on performance"""
+        recommendations = []
+        
+        if metrics.win_rate < 0.5:
+            recommendations.append("Consider additional training on market prediction")
+            
+        if metrics.avg_confidence > 0.8 and metrics.win_rate < 0.6:
+            recommendations.append("Agent may be overconfident - adjust calibration")
+            
+        if metrics.max_drawdown > self.config.max_drawdown_threshold:
+            recommendations.append("Implement stricter risk management")
+            
+        if metrics.exploration_rate < 0.1:
+            recommendations.append("Increase exploration to discover new strategies")
+            
+        # Scenario-specific recommendations
+        scenario_performance = {}
+        for result in results:
+            if result.scenario_type not in scenario_performance:
+                scenario_performance[result.scenario_type] = []
+            scenario_performance[result.scenario_type].append(result.accuracy)
+            
+        for scenario, accuracies in scenario_performance.items():
+            avg_accuracy = sum(accuracies) / len(accuracies)
+            if avg_accuracy < 0.5:
+                recommendations.append(f"Focus training on {scenario.value} scenarios")
+                
+        return recommendations
+        
+    async def _run_warmup(
+        self,
+        session_id: str,
+        agent_id: str,
+        scenarios: List[TrainingScenario]
+    ):
+        """Run warmup scenarios"""
+        logger.info(f"Running {len(scenarios)} warmup scenarios")
+        
+        for scenario in scenarios:
+            result = await self._run_scenario(
+                session_id,
+                agent_id,
+                scenario,
+                TrainingMode.EXPLORATION
+            )
+            # Don't count warmup in metrics
+            logger.debug(f"Warmup scenario {scenario.value}: accuracy={result.accuracy:.2%}")
+            
+    async def _run_evaluation(
+        self,
+        session_id: str,
+        agent_id: str,
+        scenarios: List[TrainingScenario]
+    ) -> List[ScenarioResult]:
+        """Run evaluation scenarios"""
+        logger.info(f"Running {len(scenarios)} evaluation scenarios")
+        
+        results = []
+        for scenario in scenarios:
+            result = await self._run_scenario(
+                session_id,
+                agent_id,
+                scenario,
+                TrainingMode.VALIDATION
+            )
+            results.append(result)
+            
+        return results
+        
+    async def _get_agent_state(self, agent_id: str) -> Dict[str, Any]:
+        """Get current agent state"""
+        # Retrieve agent state from Redis
+        state_key = f"agent:{agent_id}:state"
+        state_data = await self.redis_client.get(state_key)
+        
+        if state_data:
+            return json.loads(state_data)
+        return {}
+        
+    def _estimate_volatility(self, decisions: List[Dict[str, Any]]) -> float:
+        """Estimate market volatility from decisions"""
+        if len(decisions) < 2:
+            return 0.02
+            
+        prices = [d.get('price', 0.5) for d in decisions if 'price' in d]
+        if len(prices) < 2:
+            return 0.02
+            
+        # Calculate standard deviation of price changes
+        changes = [abs(prices[i] - prices[i-1]) for i in range(1, len(prices))]
+        return sum(changes) / len(changes) if changes else 0.02
+        
+    def _estimate_trend(self, decisions: List[Dict[str, Any]]) -> float:
+        """Estimate market trend from decisions"""
+        if len(decisions) < 2:
+            return 0.0
+            
+        prices = [d.get('price', 0.5) for d in decisions if 'price' in d]
+        if len(prices) < 2:
+            return 0.0
+            
+        # Simple linear trend
+        return (prices[-1] - prices[0]) / len(prices)
+        
+    def _estimate_liquidity(self, decisions: List[Dict[str, Any]]) -> float:
+        """Estimate market liquidity from decisions"""
+        volumes = [d.get('volume', 0) for d in decisions if 'volume' in d]
+        if not volumes:
+            return 0.5
+            
+        avg_volume = sum(volumes) / len(volumes)
+        # Normalize to 0-1 scale (assuming max volume of 10000)
+        return min(1.0, avg_volume / 10000)
+        
+    async def _monitor_performance(self):
+        """Real-time performance monitoring"""
+        while True:
+            try:
+                for session_id, session in self.active_sessions.items():
+                    if 'end_time' not in session:
+                        # Session still active
+                        metrics = self.metrics.get(session_id)
+                        if metrics:
+                            logger.info(
+                                f"Session {session_id}: "
+                                f"Scenarios={metrics.scenario_count}, "
+                                f"Win rate={metrics.win_rate:.2%}, "
+                                f"Profit={metrics.total_profit:.2f}"
+                            )
+                            
+                await asyncio.sleep(30)  # Monitor every 30 seconds
+                
+            except Exception as e:
+                logger.error(f"Monitoring error: {e}")
+                await asyncio.sleep(30)
+                
+    async def cleanup(self):
+        """Clean up resources"""
+        if self.redis_client:
+            await self.redis_client.close()
+            
+        logger.info("Training harness cleaned up")
\ No newline at end of file
diff --git a/src/sdk/README.md b/src/sdk/README.md
deleted file mode 100644
index 2fd4c4e9..00000000
--- a/src/sdk/README.md
+++ /dev/null
@@ -1,257 +0,0 @@
-# Data Source SDK
-
-The Data Source SDK provides a plug-and-play framework for integrating real-time data feeds into the Neural Trading Platform.
-
-## Architecture
-
-```
-Your Data Source → Adapter → StandardizedEvent → Redis Pub/Sub → Trading Agents
-```
-
-## Quick Example
-
-```python
-from src.sdk import SDKManager
-
-# Initialize and start streaming
-sdk = SDKManager(config_path="config/data_sources.yaml")
-await sdk.initialize()
-await sdk.start()
-
-# Process events
-async for event in sdk.get_events():
-    if event.confidence > 0.8 and event.impact == "high":
-        # High confidence event detected
-        await process_trading_signal(event)
-```
-
-## Core Components
-
-### 1. DataSourceAdapter (Base Class)
-
-All adapters inherit from this abstract base class:
-
-```python
-class DataSourceAdapter(ABC):
-    @abstractmethod
-    async def connect() -> bool
-    
-    @abstractmethod
-    async def stream() -> AsyncGenerator[StandardizedEvent, None]
-    
-    @abstractmethod
-    def transform(raw_data) -> StandardizedEvent
-```
-
-### 2. StandardizedEvent
-
-Unified event format across all sources:
-
-```python
-@dataclass
-class StandardizedEvent:
-    source: str              # "DraftKings", "Weather", etc.
-    event_type: EventType    # ODDS_CHANGE, WEATHER_UPDATE, etc.
-    timestamp: datetime
-    game_id: Optional[str]
-    data: Dict[str, Any]
-    confidence: float        # 0.0 to 1.0
-    impact: str             # "low", "medium", "high", "critical"
-    metadata: Dict
-```
-
-### 3. SDKManager
-
-Orchestrates multiple adapters:
-
-```python
-sdk = SDKManager()
-sdk.add_adapter("draftkings", DraftKingsAdapter(config))
-sdk.add_adapter("weather", WeatherAdapter(config))
-await sdk.start()
-```
-
-## Built-in Adapters
-
-### DraftKings (`adapters/draftkings.py`)
-- **Purpose**: Track professional sportsbook odds
-- **Events**: ODDS_CHANGE when lines move >3%
-- **Config**: `poll_interval`, `min_odds_change`
-
-### Weather (`adapters/weather.py`)
-- **Purpose**: Monitor weather conditions at venues
-- **Events**: WEATHER_UPDATE for wind/rain/visibility
-- **Config**: `api_key`, `stadiums`, `thresholds`
-- **API**: OpenWeatherMap (free tier: 60 calls/min)
-
-### Reddit (`adapters/reddit.py`)
-- **Purpose**: Analyze game thread sentiment
-- **Events**: SENTIMENT_SHIFT, VOLUME_SPIKE
-- **Config**: `client_id`, `client_secret`, `subreddits`
-
-## Creating Custom Adapters
-
-### Step 1: Create Adapter Class
-
-```python
-# src/sdk/adapters/my_source.py
-from ..core.base_adapter import DataSourceAdapter, StandardizedEvent
-
-class MySourceAdapter(DataSourceAdapter):
-    def get_metadata(self):
-        return DataSourceMetadata(
-            name="MySource",
-            version="1.0.0",
-            source_type="api",
-            latency_ms=100
-        )
-    
-    async def connect(self):
-        self.client = MyAPIClient(self.config['api_key'])
-        return await self.client.connect()
-    
-    async def stream(self):
-        while self.is_connected:
-            data = await self.client.fetch()
-            if self.is_significant(data):
-                yield self.transform(data)
-            await asyncio.sleep(self.config['interval'])
-    
-    def transform(self, raw_data):
-        return StandardizedEvent(
-            source="MySource",
-            event_type=EventType.CUSTOM,
-            data=raw_data,
-            confidence=0.85
-        )
-```
-
-### Step 2: Add to Configuration
-
-```yaml
-# config/data_sources.yaml
-sources:
-  - name: my_source
-    enabled: true
-    class: MySourceAdapter
-    module: src.sdk.adapters.my_source
-    config:
-      api_key: ${MY_API_KEY}
-      interval: 5
-```
-
-### Step 3: Test
-
-```python
-# Test your adapter
-adapter = MySourceAdapter(config)
-await adapter.connect()
-
-async for event in adapter.stream():
-    print(f"Event: {event.data}")
-```
-
-## Event Types
-
-```python
-class EventType(Enum):
-    # Market events
-    ODDS_CHANGE = "odds_change"
-    MARKET_MOVEMENT = "market_movement"
-    
-    # Game events
-    GAME_EVENT = "game_event"
-    SCORE_UPDATE = "score_update"
-    
-    # Environmental
-    WEATHER_UPDATE = "weather_update"
-    
-    # Social
-    SENTIMENT_SHIFT = "sentiment_shift"
-    VOLUME_SPIKE = "volume_spike"
-    
-    # News
-    NEWS_ALERT = "news_alert"
-    INJURY_UPDATE = "injury_update"
-```
-
-## Configuration
-
-### Environment Variables
-
-```bash
-# .env file
-OPENWEATHER_API_KEY=your_key
-REDDIT_CLIENT_ID=your_id
-REDDIT_CLIENT_SECRET=your_secret
-```
-
-### YAML Configuration
-
-```yaml
-sources:
-  - name: weather
-    enabled: true
-    priority: 1  # Higher = processed first
-    config:
-      api_key: ${OPENWEATHER_API_KEY}
-      update_interval: 300
-      thresholds:
-        wind_speed: 15
-        precipitation: 0.1
-```
-
-## Testing
-
-### Unit Test Template
-
-```python
-import pytest
-from src.sdk.adapters.my_source import MySourceAdapter
-
-@pytest.mark.asyncio
-async def test_adapter():
-    adapter = MySourceAdapter({"api_key": "test"})
-    assert await adapter.connect()
-    
-    events = []
-    async for event in adapter.stream():
-        events.append(event)
-        if len(events) >= 5:
-            break
-    
-    assert len(events) == 5
-    assert all(e.confidence > 0 for e in events)
-```
-
-### Performance Testing
-
-```python
-sdk = SDKManager()
-results = await sdk.test_adapter("my_source", duration=60)
-
-print(f"Events/sec: {results['events_per_second']}")
-print(f"Avg latency: {results['avg_latency_ms']}ms")
-print(f"Errors: {results['errors']}")
-```
-
-## Best Practices
-
-1. **Error Handling**: Always wrap external calls in try/except
-2. **Rate Limiting**: Respect API limits with built-in rate limiter
-3. **Caching**: Cache responses when appropriate (30s default)
-4. **Validation**: Validate data before creating events
-5. **Logging**: Use adapter's logger for debugging
-
-## Performance Metrics
-
-- **Target Latency**: <500ms for critical sources
-- **Event Rate**: Support 1000+ events/second
-- **Reliability**: 99%+ uptime with auto-reconnect
-- **Memory**: <100MB per adapter
-
-## Support
-
-- Full documentation: [docs/SDK_DOCUMENTATION.md](../../docs/SDK_DOCUMENTATION.md)
-- Examples: [scripts/demo_sdk.py](../../scripts/demo_sdk.py)
-- Tests: [scripts/test_weather_adapter.py](../../scripts/test_weather_adapter.py)
\ No newline at end of file
diff --git a/src/sdk/__init__.py b/src/sdk/__init__.py
deleted file mode 100644
index dedace2e..00000000
--- a/src/sdk/__init__.py
+++ /dev/null
@@ -1,39 +0,0 @@
-"""
-Neural Trading Platform SDK
-Easy integration of custom data sources
-"""
-
-from .core.base_adapter import (
-    DataSourceAdapter,
-    DataSourceMetadata,
-    StandardizedEvent,
-    EventType,
-    SignalStrength,
-    DataSourceError,
-    AuthenticationError,
-    RateLimitError,
-    DataValidationError
-)
-
-from .core.sdk_manager import (
-    SDKManager,
-    AdapterConfig
-)
-
-# Version
-__version__ = "1.0.0"
-
-# Expose main classes
-__all__ = [
-    "DataSourceAdapter",
-    "DataSourceMetadata",
-    "StandardizedEvent",
-    "EventType",
-    "SignalStrength",
-    "SDKManager",
-    "AdapterConfig",
-    "DataSourceError",
-    "AuthenticationError",
-    "RateLimitError",
-    "DataValidationError"
-]
\ No newline at end of file
diff --git a/src/sdk/adapters/__init__.py b/src/sdk/adapters/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/sdk/adapters/draftkings.py b/src/sdk/adapters/draftkings.py
deleted file mode 100644
index 4f43b32f..00000000
--- a/src/sdk/adapters/draftkings.py
+++ /dev/null
@@ -1,374 +0,0 @@
-"""
-DraftKings Sportsbook Adapter
-Fetches live odds from DraftKings to identify pricing discrepancies
-"""
-
-import aiohttp
-import asyncio
-import json
-from typing import Dict, Any, Optional, AsyncGenerator, List
-from datetime import datetime
-import logging
-
-from ..core.base_adapter import (
-    DataSourceAdapter,
-    DataSourceMetadata,
-    StandardizedEvent,
-    EventType,
-    SignalStrength
-)
-
-logger = logging.getLogger(__name__)
-
-
-class DraftKingsAdapter(DataSourceAdapter):
-    """
-    DraftKings sportsbook odds adapter
-    Monitors live odds and line movements for sports events
-    """
-    
-    BASE_URL = "https://sportsbook-us-nh.draftkings.com/sites/US-NH-SB/api/v5"
-    
-    def __init__(self, config: Dict[str, Any]):
-        """
-        Initialize DraftKings adapter
-        
-        Config should include:
-        - sports: List of sports to monitor (NFL, NBA, etc.)
-        - poll_interval: Seconds between API calls
-        - min_odds_change: Minimum odds change to trigger event (e.g., 0.03)
-        """
-        super().__init__(config)
-        self.session: Optional[aiohttp.ClientSession] = None
-        self.sports = config.get('sports', ['NFL', 'NBA', 'MLB'])
-        self.poll_interval = config.get('poll_interval', 5)
-        self.min_odds_change = config.get('min_odds_change', 0.03)
-        
-        # Track previous odds to detect changes
-        self.previous_odds: Dict[str, Dict] = {}
-        
-    def get_metadata(self) -> DataSourceMetadata:
-        """Return DraftKings adapter metadata"""
-        return DataSourceMetadata(
-            name="DraftKings",
-            version="1.0.0",
-            author="Neural Trading Platform",
-            description="Live odds from DraftKings Sportsbook",
-            source_type="sportsbook",
-            latency_ms=500,
-            reliability=0.95,
-            requires_auth=False,
-            rate_limits={"requests_per_second": 10},
-            supported_sports=["NFL", "NBA", "MLB", "NHL", "NCAAF", "NCAAB"],
-            supported_markets=["moneyline", "spread", "total"]
-        )
-    
-    async def connect(self) -> bool:
-        """Establish connection to DraftKings API"""
-        try:
-            # Create HTTP session
-            self.session = aiohttp.ClientSession(
-                headers={
-                    "User-Agent": "Mozilla/5.0 (compatible; NeuralTradingPlatform/1.0)"
-                }
-            )
-            
-            # Test connection
-            async with self.session.get(f"{self.BASE_URL}/eventgroups") as response:
-                if response.status == 200:
-                    self.logger.info("Connected to DraftKings API")
-                    return True
-                else:
-                    self.logger.error(f"DraftKings API returned status {response.status}")
-                    return False
-                    
-        except Exception as e:
-            self.logger.error(f"Failed to connect to DraftKings: {e}")
-            return False
-    
-    async def disconnect(self) -> None:
-        """Close connection to DraftKings"""
-        if self.session:
-            await self.session.close()
-            self.session = None
-        self.logger.info("Disconnected from DraftKings")
-    
-    async def validate_connection(self) -> bool:
-        """Check if connection is still valid"""
-        if not self.session:
-            return False
-        
-        try:
-            async with self.session.get(
-                f"{self.BASE_URL}/eventgroups",
-                timeout=aiohttp.ClientTimeout(total=5)
-            ) as response:
-                return response.status == 200
-        except:
-            return False
-    
-    async def stream(self) -> AsyncGenerator[StandardizedEvent, None]:
-        """Stream odds updates from DraftKings"""
-        while self.is_connected:
-            try:
-                # Fetch current odds for all sports
-                for sport in self.sports:
-                    events = await self._fetch_sport_events(sport)
-                    
-                    # Process each event
-                    for event in events:
-                        # Check for odds changes
-                        odds_event = self._check_odds_change(event)
-                        if odds_event:
-                            yield odds_event
-                            self._increment_event_count()
-                
-                # Wait before next poll
-                await asyncio.sleep(self.poll_interval)
-                
-            except Exception as e:
-                self.logger.error(f"Error in DraftKings stream: {e}")
-                self._increment_error_count()
-                await asyncio.sleep(self.poll_interval)
-    
-    async def _fetch_sport_events(self, sport: str) -> List[Dict]:
-        """
-        Fetch live events for a specific sport
-        
-        Args:
-            sport: Sport identifier (NFL, NBA, etc.)
-            
-        Returns:
-            List of event dictionaries
-        """
-        try:
-            # Get event group ID for sport
-            group_id = await self._get_event_group_id(sport)
-            if not group_id:
-                return []
-            
-            # Fetch events
-            url = f"{self.BASE_URL}/eventgroups/{group_id}/events"
-            async with self.session.get(url) as response:
-                if response.status == 200:
-                    data = await response.json()
-                    return data.get('events', [])
-                    
-        except Exception as e:
-            self.logger.error(f"Error fetching {sport} events: {e}")
-        
-        return []
-    
-    async def _get_event_group_id(self, sport: str) -> Optional[str]:
-        """Get DraftKings event group ID for a sport"""
-        # Simplified - in production would cache these
-        sport_map = {
-            "NFL": "88808",
-            "NBA": "42648",
-            "MLB": "84240",
-            "NHL": "42133",
-            "NCAAF": "87637",
-            "NCAAB": "92483"
-        }
-        return sport_map.get(sport)
-    
-    def _check_odds_change(self, event: Dict) -> Optional[StandardizedEvent]:
-        """
-        Check if odds have changed significantly
-        
-        Args:
-            event: DraftKings event data
-            
-        Returns:
-            StandardizedEvent if significant change detected
-        """
-        event_id = event.get('eventId')
-        if not event_id:
-            return None
-        
-        # Extract current odds
-        current_odds = self._extract_odds(event)
-        if not current_odds:
-            return None
-        
-        # Check against previous odds
-        if event_id in self.previous_odds:
-            prev_odds = self.previous_odds[event_id]
-            
-            # Calculate change
-            for market_type, current_value in current_odds.items():
-                prev_value = prev_odds.get(market_type, 0)
-                change = abs(current_value - prev_value)
-                
-                # Significant change detected
-                if change >= self.min_odds_change:
-                    # Update stored odds
-                    self.previous_odds[event_id] = current_odds
-                    
-                    # Create event
-                    return self._create_odds_event(
-                        event, 
-                        market_type,
-                        prev_value,
-                        current_value,
-                        change
-                    )
-        
-        # Store odds for future comparison
-        self.previous_odds[event_id] = current_odds
-        return None
-    
-    def _extract_odds(self, event: Dict) -> Dict[str, float]:
-        """Extract odds from DraftKings event data"""
-        odds = {}
-        
-        # Get offers (markets)
-        for offer in event.get('offers', []):
-            # Get outcomes (sides of the bet)
-            for outcome in offer.get('outcomes', []):
-                # Convert American odds to decimal probability
-                american_odds = outcome.get('oddsAmerican')
-                if american_odds:
-                    decimal_prob = self._american_to_probability(american_odds)
-                    
-                    # Store by market type and team
-                    market_key = f"{offer.get('label', 'unknown')}_{outcome.get('label', 'unknown')}"
-                    odds[market_key] = decimal_prob
-        
-        return odds
-    
-    def _american_to_probability(self, american_odds: str) -> float:
-        """
-        Convert American odds to implied probability
-        
-        Args:
-            american_odds: American odds string (e.g., "-110", "+150")
-            
-        Returns:
-            Implied probability (0.0 to 1.0)
-        """
-        try:
-            odds = int(american_odds)
-            
-            if odds > 0:
-                # Positive odds
-                return 100 / (odds + 100)
-            else:
-                # Negative odds
-                return abs(odds) / (abs(odds) + 100)
-                
-        except:
-            return 0.0
-    
-    def _create_odds_event(
-        self,
-        event: Dict,
-        market_type: str,
-        prev_value: float,
-        current_value: float,
-        change: float
-    ) -> StandardizedEvent:
-        """Create standardized event for odds change"""
-        
-        # Calculate confidence based on change magnitude
-        confidence = min(1.0, change / 0.10)  # 10% change = max confidence
-        
-        # Determine impact
-        if change >= 0.08:
-            impact = "critical"
-        elif change >= 0.05:
-            impact = "high"
-        elif change >= 0.03:
-            impact = "medium"
-        else:
-            impact = "low"
-        
-        return StandardizedEvent(
-            source="DraftKings",
-            event_type=EventType.ODDS_CHANGE,
-            timestamp=datetime.now(),
-            game_id=str(event.get('eventId')),
-            data={
-                "event_name": event.get('name', 'Unknown'),
-                "market_type": market_type,
-                "previous_odds": prev_value,
-                "current_odds": current_value,
-                "change": change,
-                "direction": "up" if current_value > prev_value else "down",
-                "sport": event.get('eventGroupName'),
-                "start_time": event.get('startDate')
-            },
-            confidence=confidence,
-            impact=impact,
-            metadata={
-                "teams": event.get('teamName1', '') + ' vs ' + event.get('teamName2', ''),
-                "event_status": event.get('eventStatus', {}).get('state')
-            }
-        )
-    
-    def transform(self, raw_data: Any) -> Optional[StandardizedEvent]:
-        """
-        Transform raw DraftKings data to standardized event
-        
-        Args:
-            raw_data: Raw data from DraftKings
-            
-        Returns:
-            StandardizedEvent or None
-        """
-        # This would be used if we had a different data flow
-        # For now, transformation happens in _create_odds_event
-        return None
-
-
-class DraftKingsMonitor:
-    """
-    Helper class for monitoring specific games
-    """
-    
-    def __init__(self, adapter: DraftKingsAdapter):
-        self.adapter = adapter
-        self.tracked_games: Dict[str, Dict] = {}
-    
-    async def track_game(self, game_id: str, kalshi_market_id: str):
-        """
-        Track a specific game and correlate with Kalshi market
-        
-        Args:
-            game_id: DraftKings game ID
-            kalshi_market_id: Corresponding Kalshi market ID
-        """
-        self.tracked_games[game_id] = {
-            "kalshi_market": kalshi_market_id,
-            "start_time": datetime.now(),
-            "events_count": 0
-        }
-    
-    async def analyze_divergence(
-        self, 
-        dk_odds: float, 
-        kalshi_price: float
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Analyze divergence between DraftKings and Kalshi
-        
-        Args:
-            dk_odds: DraftKings implied probability
-            kalshi_price: Kalshi market price
-            
-        Returns:
-            Trading signal if divergence is significant
-        """
-        divergence = abs(dk_odds - kalshi_price)
-        
-        if divergence > 0.05:  # 5% divergence threshold
-            return {
-                "signal": "DIVERGENCE",
-                "dk_odds": dk_odds,
-                "kalshi_price": kalshi_price,
-                "divergence": divergence,
-                "action": "BUY" if dk_odds > kalshi_price else "SELL",
-                "confidence": min(1.0, divergence / 0.10)
-            }
-        
-        return None
\ No newline at end of file
diff --git a/src/sdk/adapters/reddit.py b/src/sdk/adapters/reddit.py
deleted file mode 100644
index de67cbb3..00000000
--- a/src/sdk/adapters/reddit.py
+++ /dev/null
@@ -1,465 +0,0 @@
-"""
-Reddit Game Thread Adapter
-Monitors Reddit game threads for real-time sentiment and reactions
-"""
-
-import asyncio
-import aiohttp
-import asyncpraw
-import json
-import re
-from typing import Dict, Any, Optional, AsyncGenerator, List, Set
-from datetime import datetime, timedelta
-import logging
-from collections import deque
-from textblob import TextBlob
-
-from ..core.base_adapter import (
-    DataSourceAdapter,
-    DataSourceMetadata,
-    StandardizedEvent,
-    EventType,
-    SignalStrength
-)
-
-logger = logging.getLogger(__name__)
-
-
-class RedditAdapter(DataSourceAdapter):
-    """
-    Reddit game thread monitor
-    Analyzes real-time comments for sentiment and significant events
-    """
-    
-    def __init__(self, config: Dict[str, Any]):
-        """
-        Initialize Reddit adapter
-        
-        Config should include:
-        - client_id: Reddit API client ID
-        - client_secret: Reddit API client secret
-        - user_agent: User agent string
-        - subreddits: List of subreddits to monitor
-        - keywords: Keywords to track for events
-        - min_comment_karma: Minimum karma for comment to be considered
-        """
-        super().__init__(config)
-        
-        self.reddit = None
-        self.subreddits = config.get('subreddits', ['nfl', 'nba', 'baseball'])
-        self.keywords = config.get('keywords', self._get_default_keywords())
-        self.min_karma = config.get('min_comment_karma', 5)
-        
-        # Sentiment tracking
-        self.sentiment_window = deque(maxlen=100)  # Last 100 comments
-        self.baseline_sentiment = 0.0
-        
-        # Rate tracking
-        self.comment_rate_window = deque(maxlen=60)  # Last 60 seconds
-        self.baseline_rate = 0.0
-        
-        # Tracked threads
-        self.active_threads: Dict[str, Dict] = {}
-        
-    def get_metadata(self) -> DataSourceMetadata:
-        """Return Reddit adapter metadata"""
-        return DataSourceMetadata(
-            name="Reddit",
-            version="1.0.0",
-            author="Neural Trading Platform",
-            description="Real-time sentiment from Reddit game threads",
-            source_type="social",
-            latency_ms=1000,
-            reliability=0.85,
-            requires_auth=True,
-            rate_limits={"requests_per_minute": 60},
-            supported_sports=["NFL", "NBA", "MLB", "NHL", "Soccer"],
-            supported_markets=["sentiment", "momentum"]
-        )
-    
-    def _get_default_keywords(self) -> Dict[str, List[str]]:
-        """Get default keywords for event detection"""
-        return {
-            "touchdown": ["touchdown", "td", "score", "scored"],
-            "injury": ["injury", "injured", "hurt", "down", "limping"],
-            "turnover": ["interception", "fumble", "turnover", "picked", "strip"],
-            "big_play": ["holy shit", "wow", "omg", "incredible", "amazing"],
-            "momentum": ["momentum", "turning point", "game changer", "tide turning"],
-            "referee": ["ref", "referee", "flag", "penalty", "bullshit call", "rigged"]
-        }
-    
-    async def connect(self) -> bool:
-        """Connect to Reddit API"""
-        try:
-            # Initialize async Reddit client
-            self.reddit = asyncpraw.Reddit(
-                client_id=self.config['client_id'],
-                client_secret=self.config['client_secret'],
-                user_agent=self.config.get('user_agent', 'NeuralTradingPlatform/1.0')
-            )
-            
-            # Test connection
-            subreddit = await self.reddit.subreddit('nfl')
-            async for submission in subreddit.hot(limit=1):
-                pass  # Just checking we can fetch
-            
-            self.logger.info("Connected to Reddit API")
-            return True
-            
-        except Exception as e:
-            self.logger.error(f"Failed to connect to Reddit: {e}")
-            return False
-    
-    async def disconnect(self) -> None:
-        """Disconnect from Reddit"""
-        if self.reddit:
-            await self.reddit.close()
-            self.reddit = None
-        self.logger.info("Disconnected from Reddit")
-    
-    async def validate_connection(self) -> bool:
-        """Validate Reddit connection"""
-        if not self.reddit:
-            return False
-        
-        try:
-            # Try to fetch user info
-            await self.reddit.user.me()
-            return True
-        except:
-            return False
-    
-    async def stream(self) -> AsyncGenerator[StandardizedEvent, None]:
-        """Stream events from Reddit game threads"""
-        while self.is_connected:
-            try:
-                # Find and monitor game threads
-                await self._update_game_threads()
-                
-                # Stream comments from active threads
-                for thread_id, thread_info in self.active_threads.items():
-                    async for event in self._monitor_thread(thread_id, thread_info):
-                        yield event
-                        self._increment_event_count()
-                
-                # Brief pause between checks
-                await asyncio.sleep(2)
-                
-            except Exception as e:
-                self.logger.error(f"Error in Reddit stream: {e}")
-                self._increment_error_count()
-                await asyncio.sleep(5)
-    
-    async def _update_game_threads(self):
-        """Find and update active game threads"""
-        for subreddit_name in self.subreddits:
-            try:
-                subreddit = await self.reddit.subreddit(subreddit_name)
-                
-                # Look for game threads in hot and new
-                async for submission in subreddit.hot(limit=25):
-                    if self._is_game_thread(submission.title):
-                        if submission.id not in self.active_threads:
-                            self.active_threads[submission.id] = {
-                                "title": submission.title,
-                                "subreddit": subreddit_name,
-                                "created": datetime.fromtimestamp(submission.created_utc),
-                                "last_checked": datetime.now(),
-                                "comment_count": 0,
-                                "teams": self._extract_teams(submission.title)
-                            }
-                            self.logger.info(f"Tracking game thread: {submission.title}")
-                            
-            except Exception as e:
-                self.logger.error(f"Error updating threads for r/{subreddit_name}: {e}")
-    
-    def _is_game_thread(self, title: str) -> bool:
-        """Check if a post title indicates a game thread"""
-        game_indicators = [
-            "game thread", "game day thread", "match thread",
-            "gamethread", "[game thread]", "gdt", "gdthread"
-        ]
-        title_lower = title.lower()
-        return any(indicator in title_lower for indicator in game_indicators)
-    
-    def _extract_teams(self, title: str) -> Dict[str, str]:
-        """Extract team names from thread title"""
-        # Simple pattern matching for "Team1 vs Team2" or "Team1 @ Team2"
-        pattern = r'([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\s+(?:vs\.?|@|at)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)'
-        match = re.search(pattern, title)
-        
-        if match:
-            return {
-                "away": match.group(1),
-                "home": match.group(2)
-            }
-        return {}
-    
-    async def _monitor_thread(
-        self, 
-        thread_id: str, 
-        thread_info: Dict
-    ) -> AsyncGenerator[StandardizedEvent, None]:
-        """
-        Monitor a specific game thread for events
-        
-        Args:
-            thread_id: Reddit submission ID
-            thread_info: Thread metadata
-            
-        Yields:
-            StandardizedEvent objects
-        """
-        try:
-            submission = await self.reddit.submission(thread_id)
-            
-            # Get new comments
-            submission.comments.replace_more(limit=0)
-            await submission.comments.fetch_async()
-            
-            # Process recent comments
-            recent_comments = []
-            for comment in submission.comments.list():
-                # Skip low-karma comments
-                if comment.score < self.min_karma:
-                    continue
-                
-                # Skip old comments
-                comment_time = datetime.fromtimestamp(comment.created_utc)
-                if datetime.now() - comment_time > timedelta(minutes=2):
-                    continue
-                
-                recent_comments.append({
-                    "text": comment.body,
-                    "score": comment.score,
-                    "time": comment_time,
-                    "author": str(comment.author) if comment.author else "deleted"
-                })
-            
-            # Analyze comments for events
-            if recent_comments:
-                # Check for sentiment shifts
-                sentiment_event = self._analyze_sentiment_shift(recent_comments, thread_info)
-                if sentiment_event:
-                    yield sentiment_event
-                
-                # Check for keyword events
-                for keyword_event in self._detect_keyword_events(recent_comments, thread_info):
-                    yield keyword_event
-                
-                # Check for volume spikes
-                volume_event = self._detect_volume_spike(recent_comments, thread_info)
-                if volume_event:
-                    yield volume_event
-                    
-        except Exception as e:
-            self.logger.error(f"Error monitoring thread {thread_id}: {e}")
-    
-    def _analyze_sentiment_shift(
-        self, 
-        comments: List[Dict], 
-        thread_info: Dict
-    ) -> Optional[StandardizedEvent]:
-        """Detect significant sentiment shifts"""
-        
-        # Calculate current sentiment
-        sentiments = []
-        for comment in comments:
-            blob = TextBlob(comment['text'])
-            sentiments.append(blob.sentiment.polarity)
-        
-        if not sentiments:
-            return None
-        
-        current_sentiment = sum(sentiments) / len(sentiments)
-        
-        # Update rolling window
-        self.sentiment_window.append(current_sentiment)
-        
-        # Need enough history
-        if len(self.sentiment_window) < 10:
-            return None
-        
-        # Calculate baseline (older half of window)
-        window_list = list(self.sentiment_window)
-        baseline = sum(window_list[:len(window_list)//2]) / (len(window_list)//2)
-        recent = sum(window_list[len(window_list)//2:]) / (len(window_list) - len(window_list)//2)
-        
-        # Detect significant shift
-        shift = recent - baseline
-        if abs(shift) > 0.3:  # 0.3 sentiment shift threshold
-            return StandardizedEvent(
-                source="Reddit",
-                event_type=EventType.SENTIMENT_SHIFT,
-                timestamp=datetime.now(),
-                game_id=thread_info.get('title', 'unknown'),
-                data={
-                    "baseline_sentiment": baseline,
-                    "current_sentiment": recent,
-                    "shift": shift,
-                    "direction": "positive" if shift > 0 else "negative",
-                    "comment_sample": [c['text'][:100] for c in comments[:3]],
-                    "thread_title": thread_info['title']
-                },
-                confidence=min(1.0, abs(shift) / 0.5),
-                impact="high" if abs(shift) > 0.5 else "medium",
-                metadata={
-                    "subreddit": thread_info['subreddit'],
-                    "teams": thread_info.get('teams', {})
-                }
-            )
-        
-        return None
-    
-    def _detect_keyword_events(
-        self, 
-        comments: List[Dict], 
-        thread_info: Dict
-    ) -> List[StandardizedEvent]:
-        """Detect events based on keyword mentions"""
-        events = []
-        
-        # Count keyword mentions
-        keyword_counts = {category: 0 for category in self.keywords}
-        
-        for comment in comments:
-            text_lower = comment['text'].lower()
-            for category, keywords in self.keywords.items():
-                if any(keyword in text_lower for keyword in keywords):
-                    keyword_counts[category] += 1
-        
-        # Generate events for significant mentions
-        for category, count in keyword_counts.items():
-            if count >= 3:  # At least 3 mentions
-                events.append(StandardizedEvent(
-                    source="Reddit",
-                    event_type=EventType.SOCIAL_MENTION,
-                    timestamp=datetime.now(),
-                    game_id=thread_info.get('title', 'unknown'),
-                    data={
-                        "event_category": category,
-                        "mention_count": count,
-                        "total_comments": len(comments),
-                        "mention_rate": count / max(len(comments), 1),
-                        "thread_title": thread_info['title']
-                    },
-                    confidence=min(1.0, count / 10),
-                    impact="high" if category in ["injury", "big_play"] else "medium",
-                    metadata={
-                        "subreddit": thread_info['subreddit'],
-                        "teams": thread_info.get('teams', {})
-                    }
-                ))
-        
-        return events
-    
-    def _detect_volume_spike(
-        self, 
-        comments: List[Dict], 
-        thread_info: Dict
-    ) -> Optional[StandardizedEvent]:
-        """Detect unusual comment volume (indicates something happened)"""
-        
-        # Update comment rate
-        current_rate = len(comments)
-        self.comment_rate_window.append(current_rate)
-        
-        # Need history
-        if len(self.comment_rate_window) < 10:
-            return None
-        
-        # Calculate baseline and current rate
-        rates = list(self.comment_rate_window)
-        baseline_rate = sum(rates[:-5]) / (len(rates) - 5)
-        current_rate = sum(rates[-5:]) / 5
-        
-        # Detect spike (2x normal rate)
-        if current_rate > baseline_rate * 2 and current_rate > 10:
-            return StandardizedEvent(
-                source="Reddit",
-                event_type=EventType.VOLUME_SPIKE,
-                timestamp=datetime.now(),
-                game_id=thread_info.get('title', 'unknown'),
-                data={
-                    "baseline_rate": baseline_rate,
-                    "current_rate": current_rate,
-                    "spike_ratio": current_rate / max(baseline_rate, 1),
-                    "thread_title": thread_info['title'],
-                    "sample_comments": [c['text'][:100] for c in comments[:5]]
-                },
-                confidence=min(1.0, (current_rate / baseline_rate - 1) / 3),
-                impact="high",
-                metadata={
-                    "subreddit": thread_info['subreddit'],
-                    "teams": thread_info.get('teams', {})
-                }
-            )
-        
-        return None
-    
-    def transform(self, raw_data: Any) -> Optional[StandardizedEvent]:
-        """Transform raw Reddit data to standardized event"""
-        # Transformation happens in the monitoring methods
-        return None
-
-
-class RedditSentimentAnalyzer:
-    """
-    Advanced sentiment analysis for Reddit comments
-    """
-    
-    def __init__(self):
-        self.emoji_sentiments = {
-            "🔥": 1.0, "💪": 0.8, "🎉": 1.0, "😭": -0.8,
-            "😤": -0.5, "🤦": -0.7, "💀": -0.9, "🐐": 1.0
-        }
-        
-        self.intensity_words = {
-            "insane": 2.0, "incredible": 2.0, "horrible": 2.0,
-            "amazing": 1.8, "terrible": 1.8, "perfect": 1.5
-        }
-    
-    def analyze(self, text: str) -> Dict[str, float]:
-        """
-        Analyze sentiment with sports context
-        
-        Args:
-            text: Comment text
-            
-        Returns:
-            Sentiment scores
-        """
-        # Base sentiment from TextBlob
-        blob = TextBlob(text)
-        base_sentiment = blob.sentiment.polarity
-        
-        # Adjust for emojis
-        emoji_score = 0
-        emoji_count = 0
-        for emoji, score in self.emoji_sentiments.items():
-            if emoji in text:
-                emoji_score += score
-                emoji_count += 1
-        
-        if emoji_count > 0:
-            emoji_sentiment = emoji_score / emoji_count
-            # Weight emojis heavily in sports context
-            base_sentiment = (base_sentiment + emoji_sentiment * 2) / 3
-        
-        # Adjust for intensity
-        intensity = 1.0
-        text_lower = text.lower()
-        for word, multiplier in self.intensity_words.items():
-            if word in text_lower:
-                intensity = max(intensity, multiplier)
-        
-        final_sentiment = base_sentiment * intensity
-        
-        # Clip to [-1, 1]
-        final_sentiment = max(-1.0, min(1.0, final_sentiment))
-        
-        return {
-            "sentiment": final_sentiment,
-            "intensity": intensity,
-            "confidence": blob.sentiment.subjectivity
-        }
\ No newline at end of file
diff --git a/src/sdk/adapters/weather.py b/src/sdk/adapters/weather.py
deleted file mode 100644
index cb7a90ac..00000000
--- a/src/sdk/adapters/weather.py
+++ /dev/null
@@ -1,495 +0,0 @@
-"""
-Weather Data Adapter
-Monitors weather conditions at game venues for impact on gameplay
-"""
-
-import aiohttp
-import asyncio
-from typing import Dict, Any, Optional, AsyncGenerator, List
-from datetime import datetime, timedelta
-import logging
-import math
-
-from ..core.base_adapter import (
-    DataSourceAdapter,
-    DataSourceMetadata,
-    StandardizedEvent,
-    EventType
-)
-
-logger = logging.getLogger(__name__)
-
-
-class WeatherAdapter(DataSourceAdapter):
-    """
-    Weather conditions monitor for sports venues
-    Tracks wind, precipitation, temperature that affect game outcomes
-    """
-    
-    # OpenWeatherMap API (free tier available)
-    BASE_URL = "https://api.openweathermap.org/data/2.5"
-    
-    def __init__(self, config: Dict[str, Any]):
-        """
-        Initialize Weather adapter
-        
-        Config should include:
-        - api_key: OpenWeatherMap API key
-        - stadiums: List of stadium locations to monitor
-        - update_interval: Seconds between weather checks
-        - thresholds: Weather thresholds for alerts
-        """
-        super().__init__(config)
-        
-        self.api_key = config.get('api_key')
-        self.stadiums = config.get('stadiums', self._get_default_stadiums())
-        self.update_interval = config.get('update_interval', 300)  # 5 minutes
-        
-        # Weather thresholds for significant events
-        self.thresholds = config.get('thresholds', {
-            'wind_speed': 15,  # mph - affects passing game
-            'precipitation': 0.1,  # inches/hour - affects ball handling
-            'temperature_change': 10,  # degrees F - rapid change
-            'visibility': 1  # miles - affects deep passes
-        })
-        
-        self.session: Optional[aiohttp.ClientSession] = None
-        self.previous_conditions: Dict[str, Dict] = {}
-        
-    def get_metadata(self) -> DataSourceMetadata:
-        """Return Weather adapter metadata"""
-        return DataSourceMetadata(
-            name="Weather",
-            version="1.0.0",
-            author="Neural Trading Platform",
-            description="Real-time weather conditions at sports venues",
-            source_type="environmental",
-            latency_ms=2000,
-            reliability=0.99,
-            requires_auth=True,
-            rate_limits={"requests_per_minute": 60},
-            supported_sports=["NFL", "MLB", "Soccer", "NCAAF"],
-            supported_markets=["weather_impact"]
-        )
-    
-    def _get_default_stadiums(self) -> List[Dict[str, Any]]:
-        """Get default NFL stadium locations"""
-        return [
-            {"name": "Arrowhead Stadium", "team": "KC", "lat": 39.0489, "lon": -94.4839, "outdoor": True},
-            {"name": "Highmark Stadium", "team": "BUF", "lat": 42.7738, "lon": -78.7870, "outdoor": True},
-            {"name": "Lambeau Field", "team": "GB", "lat": 44.5013, "lon": -88.0622, "outdoor": True},
-            {"name": "Soldier Field", "team": "CHI", "lat": 41.8623, "lon": -87.6167, "outdoor": True},
-            {"name": "MetLife Stadium", "team": "NYG/NYJ", "lat": 40.8135, "lon": -74.0745, "outdoor": True},
-            {"name": "Gillette Stadium", "team": "NE", "lat": 42.0909, "lon": -71.2643, "outdoor": True},
-            {"name": "Mile High", "team": "DEN", "lat": 39.7439, "lon": -105.0201, "outdoor": True},
-            {"name": "Lumen Field", "team": "SEA", "lat": 47.5952, "lon": -122.3316, "outdoor": True}
-        ]
-    
-    async def connect(self) -> bool:
-        """Connect to Weather API"""
-        try:
-            self.session = aiohttp.ClientSession()
-            
-            # Test API key with a sample request
-            test_url = f"{self.BASE_URL}/weather"
-            params = {
-                "lat": 40.7128,
-                "lon": -74.0060,
-                "appid": self.api_key,
-                "units": "imperial"
-            }
-            
-            async with self.session.get(test_url, params=params) as response:
-                if response.status == 200:
-                    self.logger.info("Connected to Weather API")
-                    return True
-                else:
-                    self.logger.error(f"Weather API error: {response.status}")
-                    return False
-                    
-        except Exception as e:
-            self.logger.error(f"Failed to connect to Weather API: {e}")
-            return False
-    
-    async def disconnect(self) -> None:
-        """Disconnect from Weather API"""
-        if self.session:
-            await self.session.close()
-            self.session = None
-        self.logger.info("Disconnected from Weather API")
-    
-    async def validate_connection(self) -> bool:
-        """Validate Weather API connection"""
-        if not self.session:
-            return False
-        
-        try:
-            # Simple API test
-            test_url = f"{self.BASE_URL}/weather"
-            params = {
-                "q": "London",
-                "appid": self.api_key
-            }
-            
-            async with self.session.get(
-                test_url, 
-                params=params,
-                timeout=aiohttp.ClientTimeout(total=5)
-            ) as response:
-                return response.status == 200
-        except:
-            return False
-    
-    async def stream(self) -> AsyncGenerator[StandardizedEvent, None]:
-        """Stream weather updates for tracked stadiums"""
-        while self.is_connected:
-            try:
-                # Check weather for each stadium
-                for stadium in self.stadiums:
-                    # Skip indoor stadiums
-                    if not stadium.get('outdoor', True):
-                        continue
-                    
-                    # Get current conditions
-                    conditions = await self._fetch_weather(stadium)
-                    if not conditions:
-                        continue
-                    
-                    # Check for significant changes
-                    events = self._analyze_conditions(stadium, conditions)
-                    for event in events:
-                        yield event
-                        self._increment_event_count()
-                
-                # Wait before next update
-                await asyncio.sleep(self.update_interval)
-                
-            except Exception as e:
-                self.logger.error(f"Error in weather stream: {e}")
-                self._increment_error_count()
-                await asyncio.sleep(self.update_interval)
-    
-    async def _fetch_weather(self, stadium: Dict) -> Optional[Dict]:
-        """
-        Fetch weather data for a stadium location
-        
-        Args:
-            stadium: Stadium information with lat/lon
-            
-        Returns:
-            Weather conditions dictionary
-        """
-        try:
-            # Current weather
-            current_url = f"{self.BASE_URL}/weather"
-            params = {
-                "lat": stadium['lat'],
-                "lon": stadium['lon'],
-                "appid": self.api_key,
-                "units": "imperial"  # Fahrenheit, mph
-            }
-            
-            async with self.session.get(current_url, params=params) as response:
-                if response.status != 200:
-                    return None
-                
-                data = await response.json()
-                
-                # Extract relevant conditions
-                conditions = {
-                    "temperature": data['main']['temp'],
-                    "feels_like": data['main']['feels_like'],
-                    "humidity": data['main']['humidity'],
-                    "wind_speed": data['wind']['speed'],
-                    "wind_direction": data['wind'].get('deg', 0),
-                    "wind_gust": data['wind'].get('gust', data['wind']['speed']),
-                    "precipitation": self._calculate_precipitation(data),
-                    "visibility": data.get('visibility', 10000) / 1609.34,  # Convert to miles
-                    "pressure": data['main']['pressure'],
-                    "weather": data['weather'][0]['main'] if data.get('weather') else "Clear",
-                    "description": data['weather'][0]['description'] if data.get('weather') else "",
-                    "timestamp": datetime.now()
-                }
-                
-                return conditions
-                
-        except Exception as e:
-            self.logger.error(f"Error fetching weather for {stadium['name']}: {e}")
-            return None
-    
-    def _calculate_precipitation(self, data: Dict) -> float:
-        """Calculate precipitation rate from weather data"""
-        # Check for rain
-        if 'rain' in data:
-            return data['rain'].get('1h', 0) / 25.4  # Convert mm to inches
-        # Check for snow
-        if 'snow' in data:
-            return data['snow'].get('1h', 0) / 25.4 * 0.1  # Snow to water ratio
-        return 0.0
-    
-    def _analyze_conditions(
-        self, 
-        stadium: Dict, 
-        conditions: Dict
-    ) -> List[StandardizedEvent]:
-        """
-        Analyze weather conditions for significant events
-        
-        Args:
-            stadium: Stadium information
-            conditions: Current weather conditions
-            
-        Returns:
-            List of weather events
-        """
-        events = []
-        stadium_id = stadium['name']
-        
-        # Get previous conditions
-        previous = self.previous_conditions.get(stadium_id, {})
-        
-        # Check wind impact
-        if conditions['wind_speed'] > self.thresholds['wind_speed']:
-            impact = self._calculate_wind_impact(conditions['wind_speed'])
-            events.append(StandardizedEvent(
-                source="Weather",
-                event_type=EventType.WEATHER_UPDATE,
-                timestamp=datetime.now(),
-                game_id=f"{stadium['team']}_home",
-                data={
-                    "condition": "high_wind",
-                    "wind_speed": conditions['wind_speed'],
-                    "wind_gust": conditions['wind_gust'],
-                    "wind_direction": conditions['wind_direction'],
-                    "impact": impact,
-                    "stadium": stadium['name'],
-                    "team": stadium['team']
-                },
-                confidence=0.95,
-                impact="high" if conditions['wind_speed'] > 25 else "medium",
-                metadata={
-                    "affects": ["passing_game", "field_goals", "punts"],
-                    "advantage": "running_game"
-                }
-            ))
-        
-        # Check precipitation
-        if conditions['precipitation'] > self.thresholds['precipitation']:
-            events.append(StandardizedEvent(
-                source="Weather",
-                event_type=EventType.WEATHER_UPDATE,
-                timestamp=datetime.now(),
-                game_id=f"{stadium['team']}_home",
-                data={
-                    "condition": "precipitation",
-                    "rate": conditions['precipitation'],
-                    "type": conditions['weather'],
-                    "description": conditions['description'],
-                    "stadium": stadium['name'],
-                    "team": stadium['team']
-                },
-                confidence=0.95,
-                impact="high",
-                metadata={
-                    "affects": ["ball_handling", "footing", "visibility"],
-                    "advantage": "defense"
-                }
-            ))
-        
-        # Check temperature changes
-        if previous:
-            temp_change = abs(conditions['temperature'] - previous.get('temperature', conditions['temperature']))
-            if temp_change > self.thresholds['temperature_change']:
-                events.append(StandardizedEvent(
-                    source="Weather",
-                    event_type=EventType.WEATHER_UPDATE,
-                    timestamp=datetime.now(),
-                    game_id=f"{stadium['team']}_home",
-                    data={
-                        "condition": "temperature_change",
-                        "current_temp": conditions['temperature'],
-                        "previous_temp": previous.get('temperature'),
-                        "change": temp_change,
-                        "stadium": stadium['name'],
-                        "team": stadium['team']
-                    },
-                    confidence=0.90,
-                    impact="medium",
-                    metadata={
-                        "affects": ["player_stamina", "ball_pressure"],
-                        "direction": "cooling" if conditions['temperature'] < previous.get('temperature', 0) else "warming"
-                    }
-                ))
-        
-        # Check visibility (fog, heavy rain/snow)
-        if conditions['visibility'] < self.thresholds['visibility']:
-            events.append(StandardizedEvent(
-                source="Weather",
-                event_type=EventType.WEATHER_UPDATE,
-                timestamp=datetime.now(),
-                game_id=f"{stadium['team']}_home",
-                data={
-                    "condition": "low_visibility",
-                    "visibility": conditions['visibility'],
-                    "weather": conditions['weather'],
-                    "stadium": stadium['name'],
-                    "team": stadium['team']
-                },
-                confidence=0.85,
-                impact="high",
-                metadata={
-                    "affects": ["passing_game", "deep_routes"],
-                    "advantage": "short_passing_running"
-                }
-            ))
-        
-        # Store current conditions for next comparison
-        self.previous_conditions[stadium_id] = conditions
-        
-        return events
-    
-    def _calculate_wind_impact(self, wind_speed: float) -> Dict[str, Any]:
-        """
-        Calculate impact of wind on game elements
-        
-        Args:
-            wind_speed: Wind speed in mph
-            
-        Returns:
-            Impact analysis
-        """
-        # Based on research about wind effects on football
-        passing_reduction = min(wind_speed * 1.5, 40)  # Up to 40% reduction
-        fg_accuracy_reduction = min(wind_speed * 2, 50)  # Up to 50% reduction
-        punt_variance = wind_speed * 0.5  # Yards of variance
-        
-        return {
-            "passing_yards_reduction": f"{passing_reduction:.0f}%",
-            "field_goal_accuracy_reduction": f"{fg_accuracy_reduction:.0f}%",
-            "punt_distance_variance": f"±{punt_variance:.0f} yards",
-            "recommended_strategy": "establish_run" if wind_speed > 20 else "balanced"
-        }
-    
-    def transform(self, raw_data: Any) -> Optional[StandardizedEvent]:
-        """Transform raw weather data to standardized event"""
-        # Transformation happens in _analyze_conditions
-        return None
-
-
-class WeatherImpactAnalyzer:
-    """
-    Analyzes weather impact on specific game scenarios
-    """
-    
-    def __init__(self):
-        self.sport_impacts = {
-            "NFL": {
-                "wind": {"threshold": 15, "impact": "high"},
-                "rain": {"threshold": 0.1, "impact": "medium"},
-                "snow": {"threshold": 0.05, "impact": "high"},
-                "temperature": {"threshold": 32, "impact": "low"}
-            },
-            "MLB": {
-                "wind": {"threshold": 10, "impact": "medium"},
-                "rain": {"threshold": 0.05, "impact": "high"},
-                "temperature": {"threshold": 95, "impact": "low"},
-                "humidity": {"threshold": 70, "impact": "medium"}
-            }
-        }
-    
-    def calculate_total_impact(
-        self, 
-        conditions: Dict, 
-        sport: str
-    ) -> Dict[str, Any]:
-        """
-        Calculate total weather impact on game
-        
-        Args:
-            conditions: Weather conditions
-            sport: Sport type
-            
-        Returns:
-            Impact assessment
-        """
-        if sport not in self.sport_impacts:
-            return {"impact": "unknown", "score": 0}
-        
-        impacts = self.sport_impacts[sport]
-        total_score = 0
-        factors = []
-        
-        # Check each weather factor
-        if conditions.get('wind_speed', 0) > impacts['wind']['threshold']:
-            score = self._score_impact(
-                conditions['wind_speed'], 
-                impacts['wind']['threshold'],
-                impacts['wind']['impact']
-            )
-            total_score += score
-            factors.append(f"Wind: {score:.1f}")
-        
-        if conditions.get('precipitation', 0) > impacts.get('rain', {}).get('threshold', 1):
-            score = self._score_impact(
-                conditions['precipitation'],
-                impacts['rain']['threshold'],
-                impacts['rain']['impact']
-            )
-            total_score += score
-            factors.append(f"Rain: {score:.1f}")
-        
-        # Determine overall impact
-        if total_score > 7:
-            overall = "severe"
-        elif total_score > 4:
-            overall = "significant"
-        elif total_score > 2:
-            overall = "moderate"
-        else:
-            overall = "minimal"
-        
-        return {
-            "overall_impact": overall,
-            "impact_score": total_score,
-            "factors": factors,
-            "betting_recommendation": self._get_betting_recommendation(overall, sport)
-        }
-    
-    def _score_impact(
-        self, 
-        value: float, 
-        threshold: float, 
-        impact_level: str
-    ) -> float:
-        """Calculate impact score"""
-        multiplier = {
-            "high": 3.0,
-            "medium": 2.0,
-            "low": 1.0
-        }.get(impact_level, 1.0)
-        
-        return (value / threshold) * multiplier
-    
-    def _get_betting_recommendation(
-        self, 
-        impact: str, 
-        sport: str
-    ) -> str:
-        """Get betting recommendation based on weather impact"""
-        if sport == "NFL":
-            if impact == "severe":
-                return "Strong UNDER, favor running teams"
-            elif impact == "significant":
-                return "Lean UNDER, watch for adjustments"
-            else:
-                return "Weather neutral"
-        
-        elif sport == "MLB":
-            if impact == "severe":
-                return "Game likely postponed"
-            elif impact == "significant":
-                return "UNDER, reduced scoring"
-            else:
-                return "Minimal impact"
-        
-        return "Assess individually"
\ No newline at end of file
diff --git a/src/sdk/core/__init__.py b/src/sdk/core/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/sdk/core/base_adapter.py b/src/sdk/core/base_adapter.py
deleted file mode 100644
index b037179c..00000000
--- a/src/sdk/core/base_adapter.py
+++ /dev/null
@@ -1,325 +0,0 @@
-"""
-Base Data Source Adapter for Neural Trading Platform SDK
-Provides standardized interface for all data source integrations
-"""
-
-from abc import ABC, abstractmethod
-from typing import Dict, Any, AsyncGenerator, Optional, List
-from dataclasses import dataclass, field
-from datetime import datetime
-from enum import Enum
-import asyncio
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class EventType(Enum):
-    """Standardized event types across all data sources"""
-    ODDS_CHANGE = "odds_change"
-    SENTIMENT_SHIFT = "sentiment_shift"
-    GAME_EVENT = "game_event"
-    WEATHER_UPDATE = "weather_update"
-    VOLUME_SPIKE = "volume_spike"
-    NEWS_ALERT = "news_alert"
-    SOCIAL_MENTION = "social_mention"
-    MARKET_MOVEMENT = "market_movement"
-
-
-class SignalStrength(Enum):
-    """Signal strength classification"""
-    WEAK = "weak"        # <60% confidence
-    MEDIUM = "medium"    # 60-80% confidence
-    STRONG = "strong"    # >80% confidence
-
-
-@dataclass
-class DataSourceMetadata:
-    """Metadata describing a data source"""
-    name: str
-    version: str
-    author: str
-    description: str
-    source_type: str  # 'sportsbook', 'social', 'weather', 'news', etc.
-    latency_ms: int  # Expected latency in milliseconds
-    reliability: float  # 0.0 to 1.0
-    requires_auth: bool
-    rate_limits: Optional[Dict[str, int]] = None
-    supported_sports: List[str] = field(default_factory=list)
-    supported_markets: List[str] = field(default_factory=list)
-
-
-@dataclass
-class StandardizedEvent:
-    """Standardized event format for all data sources"""
-    # Core fields
-    source: str  # Name of data source
-    event_type: EventType
-    timestamp: datetime
-    game_id: Optional[str] = None
-    market_id: Optional[str] = None
-    
-    # Event data
-    data: Dict[str, Any] = field(default_factory=dict)
-    
-    # Signal quality
-    confidence: float = 0.0  # 0.0 to 1.0
-    signal_strength: SignalStrength = SignalStrength.WEAK
-    impact: str = "low"  # 'low', 'medium', 'high', 'critical'
-    
-    # Optional metadata
-    metadata: Dict[str, Any] = field(default_factory=dict)
-    raw_data: Optional[Any] = None  # Original data for debugging
-    
-    def __post_init__(self):
-        """Calculate signal strength based on confidence"""
-        if self.confidence >= 0.8:
-            self.signal_strength = SignalStrength.STRONG
-        elif self.confidence >= 0.6:
-            self.signal_strength = SignalStrength.MEDIUM
-        else:
-            self.signal_strength = SignalStrength.WEAK
-
-
-class DataSourceAdapter(ABC):
-    """
-    Base adapter class for all data sources
-    Inherit from this to create new data source integrations
-    """
-    
-    def __init__(self, config: Dict[str, Any]):
-        """
-        Initialize adapter with configuration
-        
-        Args:
-            config: Configuration dictionary for the adapter
-        """
-        self.config = config
-        self.is_connected = False
-        self.metadata = self.get_metadata()
-        self._rate_limiter = None
-        self._error_count = 0
-        self._event_count = 0
-        self._last_event_time = None
-        
-        # Set up logging
-        self.logger = logging.getLogger(f"{__name__}.{self.metadata.name}")
-        
-    @abstractmethod
-    def get_metadata(self) -> DataSourceMetadata:
-        """
-        Return metadata describing this data source
-        
-        Returns:
-            DataSourceMetadata object with source information
-        """
-        pass
-    
-    @abstractmethod
-    async def connect(self) -> bool:
-        """
-        Establish connection to data source
-        
-        Returns:
-            True if connection successful, False otherwise
-        """
-        pass
-    
-    @abstractmethod
-    async def disconnect(self) -> None:
-        """
-        Close connection to data source
-        """
-        pass
-    
-    @abstractmethod
-    async def validate_connection(self) -> bool:
-        """
-        Validate that connection is still active
-        
-        Returns:
-            True if connection is valid, False otherwise
-        """
-        pass
-    
-    @abstractmethod
-    async def stream(self) -> AsyncGenerator[StandardizedEvent, None]:
-        """
-        Stream standardized events from data source
-        
-        Yields:
-            StandardizedEvent objects
-        """
-        pass
-    
-    @abstractmethod
-    def transform(self, raw_data: Any) -> Optional[StandardizedEvent]:
-        """
-        Transform raw data from source into standardized event
-        
-        Args:
-            raw_data: Raw data from the source
-            
-        Returns:
-            StandardizedEvent or None if data cannot be transformed
-        """
-        pass
-    
-    async def start(self) -> None:
-        """
-        Start the adapter (connect and begin streaming)
-        """
-        try:
-            self.logger.info(f"Starting {self.metadata.name} adapter...")
-            
-            # Connect with retry logic
-            connected = await self._connect_with_retry()
-            if not connected:
-                raise ConnectionError(f"Failed to connect to {self.metadata.name}")
-            
-            self.is_connected = True
-            self.logger.info(f"{self.metadata.name} adapter started successfully")
-            
-        except Exception as e:
-            self.logger.error(f"Failed to start {self.metadata.name}: {e}")
-            raise
-    
-    async def stop(self) -> None:
-        """
-        Stop the adapter (disconnect and cleanup)
-        """
-        try:
-            self.logger.info(f"Stopping {self.metadata.name} adapter...")
-            await self.disconnect()
-            self.is_connected = False
-            self.logger.info(f"{self.metadata.name} adapter stopped")
-            
-        except Exception as e:
-            self.logger.error(f"Error stopping {self.metadata.name}: {e}")
-    
-    async def _connect_with_retry(self, max_retries: int = 3) -> bool:
-        """
-        Connect with exponential backoff retry
-        
-        Args:
-            max_retries: Maximum number of connection attempts
-            
-        Returns:
-            True if connected, False otherwise
-        """
-        for attempt in range(max_retries):
-            try:
-                if await self.connect():
-                    return True
-                    
-            except Exception as e:
-                self.logger.warning(
-                    f"Connection attempt {attempt + 1} failed: {e}"
-                )
-                
-            if attempt < max_retries - 1:
-                wait_time = 2 ** attempt  # Exponential backoff
-                self.logger.info(f"Retrying in {wait_time} seconds...")
-                await asyncio.sleep(wait_time)
-        
-        return False
-    
-    async def health_check(self) -> Dict[str, Any]:
-        """
-        Perform health check on the adapter
-        
-        Returns:
-            Dictionary with health status information
-        """
-        is_healthy = await self.validate_connection()
-        
-        return {
-            "adapter": self.metadata.name,
-            "healthy": is_healthy,
-            "connected": self.is_connected,
-            "error_count": self._error_count,
-            "event_count": self._event_count,
-            "last_event": self._last_event_time.isoformat() if self._last_event_time else None,
-            "uptime_seconds": self._calculate_uptime(),
-            "events_per_minute": self._calculate_event_rate()
-        }
-    
-    def _calculate_uptime(self) -> float:
-        """Calculate adapter uptime in seconds"""
-        # Implementation would track start time
-        return 0.0
-    
-    def _calculate_event_rate(self) -> float:
-        """Calculate events per minute"""
-        # Implementation would track event timestamps
-        return 0.0
-    
-    def _increment_event_count(self) -> None:
-        """Track event statistics"""
-        self._event_count += 1
-        self._last_event_time = datetime.now()
-    
-    def _increment_error_count(self) -> None:
-        """Track error statistics"""
-        self._error_count += 1
-    
-    @property
-    def statistics(self) -> Dict[str, Any]:
-        """
-        Get adapter statistics
-        
-        Returns:
-            Dictionary with adapter statistics
-        """
-        return {
-            "events_processed": self._event_count,
-            "errors_encountered": self._error_count,
-            "error_rate": self._error_count / max(self._event_count, 1),
-            "last_event": self._last_event_time,
-            "is_connected": self.is_connected
-        }
-
-
-class RateLimiter:
-    """Rate limiting for API calls"""
-    
-    def __init__(self, calls_per_second: float):
-        """
-        Initialize rate limiter
-        
-        Args:
-            calls_per_second: Maximum calls per second
-        """
-        self.calls_per_second = calls_per_second
-        self.min_interval = 1.0 / calls_per_second
-        self.last_call = 0
-    
-    async def acquire(self) -> None:
-        """Wait if necessary to respect rate limit"""
-        now = asyncio.get_event_loop().time()
-        time_since_last = now - self.last_call
-        
-        if time_since_last < self.min_interval:
-            await asyncio.sleep(self.min_interval - time_since_last)
-        
-        self.last_call = asyncio.get_event_loop().time()
-
-
-class AuthenticationError(Exception):
-    """Raised when authentication fails"""
-    pass
-
-
-class DataSourceError(Exception):
-    """Base exception for data source errors"""
-    pass
-
-
-class RateLimitError(DataSourceError):
-    """Raised when rate limit is exceeded"""
-    pass
-
-
-class DataValidationError(DataSourceError):
-    """Raised when data validation fails"""
-    pass
\ No newline at end of file
diff --git a/src/sdk/core/sdk_manager.py b/src/sdk/core/sdk_manager.py
deleted file mode 100644
index 5fb7dae6..00000000
--- a/src/sdk/core/sdk_manager.py
+++ /dev/null
@@ -1,439 +0,0 @@
-"""
-SDK Manager for Neural Trading Platform
-Handles adapter discovery, loading, and orchestration
-"""
-
-import asyncio
-import importlib
-import importlib.util
-import sys
-import yaml
-import os
-from pathlib import Path
-from typing import Dict, List, Optional, Type, AsyncGenerator, Any
-from dataclasses import dataclass
-import logging
-from concurrent.futures import ThreadPoolExecutor
-
-from .base_adapter import DataSourceAdapter, StandardizedEvent, DataSourceMetadata
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class AdapterConfig:
-    """Configuration for a data source adapter"""
-    name: str
-    enabled: bool
-    class_name: str
-    module_path: str
-    config: Dict[str, Any]
-    priority: int = 0  # Higher priority sources get processed first
-    
-
-class SDKManager:
-    """
-    Central manager for all data source adapters
-    Handles discovery, loading, and orchestration
-    """
-    
-    def __init__(self, config_path: Optional[str] = None):
-        """
-        Initialize SDK Manager
-        
-        Args:
-            config_path: Path to configuration file
-        """
-        self.adapters: Dict[str, DataSourceAdapter] = {}
-        self.adapter_configs: Dict[str, AdapterConfig] = {}
-        self.config_path = config_path or "config/data_sources.yaml"
-        self._running = False
-        self._tasks: List[asyncio.Task] = []
-        self._event_queue = asyncio.Queue()
-        self._executor = ThreadPoolExecutor(max_workers=4)
-        
-        logger.info("SDK Manager initialized")
-    
-    def discover_adapters(self, adapter_dir: str = "src/sdk/adapters") -> List[str]:
-        """
-        Discover available adapters in directory
-        
-        Args:
-            adapter_dir: Directory to search for adapters
-            
-        Returns:
-            List of discovered adapter names
-        """
-        adapter_path = Path(adapter_dir)
-        discovered = []
-        
-        if not adapter_path.exists():
-            logger.warning(f"Adapter directory does not exist: {adapter_dir}")
-            return discovered
-        
-        for file_path in adapter_path.glob("*.py"):
-            if file_path.name.startswith("_"):
-                continue
-                
-            # Try to load and validate the module
-            module_name = file_path.stem
-            try:
-                spec = importlib.util.spec_from_file_location(
-                    f"adapters.{module_name}", 
-                    file_path
-                )
-                module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(module)
-                
-                # Find adapter classes
-                for item_name in dir(module):
-                    item = getattr(module, item_name)
-                    if (isinstance(item, type) and 
-                        issubclass(item, DataSourceAdapter) and 
-                        item != DataSourceAdapter):
-                        discovered.append(module_name)
-                        logger.info(f"Discovered adapter: {module_name}")
-                        break
-                        
-            except Exception as e:
-                logger.error(f"Error discovering adapter {module_name}: {e}")
-        
-        return discovered
-    
-    def load_config(self) -> Dict[str, AdapterConfig]:
-        """
-        Load adapter configuration from YAML file
-        
-        Returns:
-            Dictionary of adapter configurations
-        """
-        configs = {}
-        
-        try:
-            with open(self.config_path, 'r') as f:
-                config_data = yaml.safe_load(f)
-            
-            for source in config_data.get('sources', []):
-                # Handle environment variables in config
-                self._substitute_env_vars(source.get('config', {}))
-                
-                adapter_config = AdapterConfig(
-                    name=source['name'],
-                    enabled=source.get('enabled', True),
-                    class_name=source.get('class', f"{source['name'].title()}Adapter"),
-                    module_path=source.get('module', f"src.sdk.adapters.{source['name']}"),
-                    config=source.get('config', {}),
-                    priority=source.get('priority', 0)
-                )
-                
-                configs[source['name']] = adapter_config
-                
-        except FileNotFoundError:
-            logger.warning(f"Config file not found: {self.config_path}")
-        except Exception as e:
-            logger.error(f"Error loading config: {e}")
-        
-        return configs
-    
-    def _substitute_env_vars(self, config: Dict[str, Any]) -> None:
-        """
-        Substitute environment variables in configuration
-        Format: ${ENV_VAR_NAME}
-        
-        Args:
-            config: Configuration dictionary to modify in place
-        """
-        for key, value in config.items():
-            if isinstance(value, str) and value.startswith("${") and value.endswith("}"):
-                env_var = value[2:-1]
-                config[key] = os.getenv(env_var, value)
-            elif isinstance(value, dict):
-                self._substitute_env_vars(value)
-    
-    async def load_adapter(self, adapter_config: AdapterConfig) -> Optional[DataSourceAdapter]:
-        """
-        Load and initialize a single adapter
-        
-        Args:
-            adapter_config: Adapter configuration
-            
-        Returns:
-            Initialized adapter or None if loading fails
-        """
-        try:
-            # Import the module
-            module = importlib.import_module(adapter_config.module_path)
-            
-            # Get the adapter class
-            adapter_class = getattr(module, adapter_config.class_name)
-            
-            # Validate it's a proper adapter
-            if not issubclass(adapter_class, DataSourceAdapter):
-                raise ValueError(f"{adapter_config.class_name} is not a DataSourceAdapter")
-            
-            # Instantiate the adapter
-            adapter = adapter_class(adapter_config.config)
-            
-            # Start the adapter
-            await adapter.start()
-            
-            logger.info(f"Loaded adapter: {adapter_config.name}")
-            return adapter
-            
-        except Exception as e:
-            logger.error(f"Failed to load adapter {adapter_config.name}: {e}")
-            return None
-    
-    async def initialize(self) -> None:
-        """
-        Initialize all configured adapters
-        """
-        # Load configuration
-        self.adapter_configs = self.load_config()
-        
-        # Load enabled adapters
-        for name, config in self.adapter_configs.items():
-            if not config.enabled:
-                logger.info(f"Skipping disabled adapter: {name}")
-                continue
-            
-            adapter = await self.load_adapter(config)
-            if adapter:
-                self.adapters[name] = adapter
-        
-        logger.info(f"Initialized {len(self.adapters)} adapters")
-    
-    async def start(self) -> None:
-        """
-        Start all adapters and begin streaming
-        """
-        if self._running:
-            logger.warning("SDK Manager already running")
-            return
-        
-        self._running = True
-        
-        # Start streaming from each adapter
-        for name, adapter in self.adapters.items():
-            task = asyncio.create_task(
-                self._stream_adapter(name, adapter)
-            )
-            self._tasks.append(task)
-        
-        # Start event processor
-        processor_task = asyncio.create_task(self._process_events())
-        self._tasks.append(processor_task)
-        
-        logger.info(f"Started streaming from {len(self.adapters)} adapters")
-    
-    async def stop(self) -> None:
-        """
-        Stop all adapters and cleanup
-        """
-        self._running = False
-        
-        # Cancel all tasks
-        for task in self._tasks:
-            task.cancel()
-        
-        # Wait for tasks to complete
-        await asyncio.gather(*self._tasks, return_exceptions=True)
-        
-        # Stop all adapters
-        for adapter in self.adapters.values():
-            await adapter.stop()
-        
-        self._tasks.clear()
-        logger.info("SDK Manager stopped")
-    
-    async def _stream_adapter(self, name: str, adapter: DataSourceAdapter) -> None:
-        """
-        Stream events from a single adapter
-        
-        Args:
-            name: Adapter name
-            adapter: Adapter instance
-        """
-        while self._running:
-            try:
-                async for event in adapter.stream():
-                    # Add adapter name to event
-                    event.source = name
-                    
-                    # Put event in queue for processing
-                    await self._event_queue.put(event)
-                    
-                    # Update adapter statistics
-                    adapter._increment_event_count()
-                    
-            except Exception as e:
-                logger.error(f"Error streaming from {name}: {e}")
-                adapter._increment_error_count()
-                
-                # Reconnect after error
-                if self._running:
-                    await asyncio.sleep(5)
-                    try:
-                        await adapter.start()
-                    except Exception as reconnect_error:
-                        logger.error(f"Failed to reconnect {name}: {reconnect_error}")
-    
-    async def _process_events(self) -> None:
-        """
-        Process events from all adapters
-        """
-        while self._running:
-            try:
-                # Get event with timeout to allow checking _running flag
-                event = await asyncio.wait_for(
-                    self._event_queue.get(), 
-                    timeout=1.0
-                )
-                
-                # Process event (this is where you'd send to trading logic)
-                await self._handle_event(event)
-                
-            except asyncio.TimeoutError:
-                continue
-            except Exception as e:
-                logger.error(f"Error processing event: {e}")
-    
-    async def _handle_event(self, event: StandardizedEvent) -> None:
-        """
-        Handle a standardized event
-        
-        Args:
-            event: Event to process
-        """
-        # Log high-impact events
-        if event.impact in ["high", "critical"]:
-            logger.info(
-                f"High impact event from {event.source}: "
-                f"{event.event_type.value} (confidence: {event.confidence:.2f})"
-            )
-        
-        # This is where events would be sent to trading strategies
-        # For now, just track them
-        pass
-    
-    async def get_events(self) -> AsyncGenerator[StandardizedEvent, None]:
-        """
-        Get standardized events from all adapters
-        
-        Yields:
-            StandardizedEvent objects from all sources
-        """
-        while self._running:
-            try:
-                event = await asyncio.wait_for(
-                    self._event_queue.get(),
-                    timeout=1.0
-                )
-                yield event
-            except asyncio.TimeoutError:
-                continue
-    
-    def get_adapter(self, name: str) -> Optional[DataSourceAdapter]:
-        """
-        Get a specific adapter by name
-        
-        Args:
-            name: Adapter name
-            
-        Returns:
-            Adapter instance or None
-        """
-        return self.adapters.get(name)
-    
-    async def health_check(self) -> Dict[str, Any]:
-        """
-        Perform health check on all adapters
-        
-        Returns:
-            Health status for all adapters
-        """
-        health_status = {
-            "manager_running": self._running,
-            "adapters": {}
-        }
-        
-        for name, adapter in self.adapters.items():
-            health_status["adapters"][name] = await adapter.health_check()
-        
-        return health_status
-    
-    def get_statistics(self) -> Dict[str, Any]:
-        """
-        Get statistics for all adapters
-        
-        Returns:
-            Statistics dictionary
-        """
-        stats = {
-            "total_adapters": len(self.adapters),
-            "running": self._running,
-            "queue_size": self._event_queue.qsize(),
-            "adapters": {}
-        }
-        
-        for name, adapter in self.adapters.items():
-            stats["adapters"][name] = adapter.statistics
-        
-        return stats
-    
-    async def test_adapter(self, name: str, duration: int = 60) -> Dict[str, Any]:
-        """
-        Test a specific adapter
-        
-        Args:
-            name: Adapter name
-            duration: Test duration in seconds
-            
-        Returns:
-            Test results
-        """
-        adapter = self.adapters.get(name)
-        if not adapter:
-            return {"error": f"Adapter {name} not found"}
-        
-        results = {
-            "adapter": name,
-            "duration": duration,
-            "events_received": 0,
-            "errors": 0,
-            "latency_samples": [],
-            "event_types": {}
-        }
-        
-        start_time = asyncio.get_event_loop().time()
-        
-        try:
-            async for event in adapter.stream():
-                results["events_received"] += 1
-                
-                # Track event types
-                event_type = event.event_type.value
-                results["event_types"][event_type] = results["event_types"].get(event_type, 0) + 1
-                
-                # Sample latency
-                if results["events_received"] % 10 == 0:
-                    latency = (datetime.now() - event.timestamp).total_seconds() * 1000
-                    results["latency_samples"].append(latency)
-                
-                # Check if duration exceeded
-                if asyncio.get_event_loop().time() - start_time > duration:
-                    break
-                    
-        except Exception as e:
-            results["errors"] += 1
-            results["error_message"] = str(e)
-        
-        # Calculate statistics
-        if results["latency_samples"]:
-            results["avg_latency_ms"] = sum(results["latency_samples"]) / len(results["latency_samples"])
-            results["max_latency_ms"] = max(results["latency_samples"])
-            results["min_latency_ms"] = min(results["latency_samples"])
-        
-        results["events_per_second"] = results["events_received"] / duration
-        
-        return results
\ No newline at end of file
diff --git a/src/sdk/utils/__init__.py b/src/sdk/utils/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/trading/llm_client.py b/src/trading/llm_client.py
deleted file mode 100644
index 203acadf..00000000
--- a/src/trading/llm_client.py
+++ /dev/null
@@ -1,166 +0,0 @@
-"""
-OpenRouter LLM Client
-Direct API integration without Agno wrapper
-"""
-
-import os
-import aiohttp
-import logging
-from typing import Dict, Any, Optional, List
-
-logger = logging.getLogger(__name__)
-
-
-class LLMClient:
-    """Direct OpenRouter API client for LLM interactions"""
-    
-    def __init__(self, api_key: Optional[str] = None):
-        """
-        Initialize LLM client
-        
-        Args:
-            api_key: OpenRouter API key (or from environment)
-        """
-        self.api_key = api_key or os.getenv("OPENROUTER_API_KEY")
-        if not self.api_key:
-            raise ValueError("OpenRouter API key required")
-        
-        self.base_url = "https://openrouter.ai/api/v1"
-        self.default_model = "google/gemini-2.5-flash"
-    
-    async def complete(
-        self,
-        prompt: str,
-        model: Optional[str] = None,
-        temperature: float = 0.3,
-        max_tokens: int = 2000,
-        system_prompt: Optional[str] = None
-    ) -> str:
-        """
-        Get completion from OpenRouter API
-        
-        Args:
-            prompt: User prompt
-            model: Model to use (default: gemini-2.5-flash)
-            temperature: Sampling temperature
-            max_tokens: Maximum tokens to generate
-            system_prompt: Optional system prompt
-            
-        Returns:
-            Generated text response
-        """
-        messages = []
-        if system_prompt:
-            messages.append({"role": "system", "content": system_prompt})
-        messages.append({"role": "user", "content": prompt})
-        
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                f"{self.base_url}/chat/completions",
-                headers={
-                    "Authorization": f"Bearer {self.api_key}",
-                    "Content-Type": "application/json",
-                    "HTTP-Referer": "https://github.com/kalshi-agent",
-                    "X-Title": "Kalshi Trading Agent"
-                },
-                json={
-                    "model": model or self.default_model,
-                    "messages": messages,
-                    "temperature": temperature,
-                    "max_tokens": max_tokens
-                }
-            ) as resp:
-                if resp.status != 200:
-                    error = await resp.text()
-                    logger.error(f"OpenRouter API error: {error}")
-                    raise Exception(f"API error: {resp.status}")
-                
-                result = await resp.json()
-                return result["choices"][0]["message"]["content"]
-    
-    async def complete_json(
-        self,
-        prompt: str,
-        model: Optional[str] = None,
-        temperature: float = 0.1
-    ) -> Dict[str, Any]:
-        """
-        Get JSON response from LLM
-        
-        Args:
-            prompt: User prompt (should request JSON format)
-            model: Model to use
-            temperature: Lower temperature for structured output
-            
-        Returns:
-            Parsed JSON response
-        """
-        import json
-        
-        # Add JSON instruction to prompt
-        json_prompt = f"{prompt}\n\nRespond with valid JSON only."
-        
-        response = await self.complete(
-            prompt=json_prompt,
-            model=model,
-            temperature=temperature
-        )
-        
-        # Try to extract JSON from response
-        try:
-            # Handle markdown code blocks
-            if "```json" in response:
-                response = response.split("```json")[1].split("```")[0]
-            elif "```" in response:
-                response = response.split("```")[1].split("```")[0]
-            
-            return json.loads(response.strip())
-        except json.JSONDecodeError as e:
-            logger.error(f"Failed to parse JSON response: {e}")
-            logger.error(f"Response: {response}")
-            return {"error": "Failed to parse JSON", "raw": response}
-    
-    async def analyze_market(
-        self,
-        market_data: Dict[str, Any],
-        sentiment_data: Optional[Dict[str, Any]] = None,
-        game_data: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
-        """
-        Analyze market opportunity using LLM
-        
-        Args:
-            market_data: Kalshi market data
-            sentiment_data: Twitter sentiment data
-            game_data: ESPN game data
-            
-        Returns:
-            Analysis with trading recommendation
-        """
-        prompt = f"""
-        Analyze this trading opportunity:
-        
-        Market Data: {market_data}
-        Sentiment Data: {sentiment_data or 'N/A'}
-        Game Data: {game_data or 'N/A'}
-        
-        Provide analysis as JSON with:
-        - signal: BUY_YES, BUY_NO, or HOLD
-        - confidence: 0-1 score
-        - reasoning: brief explanation
-        - risk_level: low, medium, or high
-        - suggested_size: percentage of capital (0-25)
-        """
-        
-        return await self.complete_json(prompt, temperature=0.2)
-
-
-# Singleton instance for easy import
-llm_client = None
-
-def get_llm_client() -> LLMClient:
-    """Get or create LLM client singleton"""
-    global llm_client
-    if llm_client is None:
-        llm_client = LLMClient()
-    return llm_client
\ No newline at end of file
diff --git a/uv.lock b/uv.lock
deleted file mode 100644
index 411670cf..00000000
--- a/uv.lock
+++ /dev/null
@@ -1,2593 +0,0 @@
-version = 1
-revision = 3
-requires-python = ">=3.10, <3.13"
-resolution-markers = [
-    "python_full_version >= '3.12'",
-    "python_full_version == '3.11.*'",
-    "python_full_version < '3.11'",
-]
-
-[[package]]
-name = "agentuity"
-version = "0.0.103"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "aiohttp" },
-    { name = "aiohttp-sse" },
-    { name = "asyncio" },
-    { name = "httpx" },
-    { name = "mail-parser" },
-    { name = "openai-agents" },
-    { name = "openlit" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-exporter-otlp" },
-    { name = "opentelemetry-exporter-otlp-proto-http" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-httpx" },
-    { name = "opentelemetry-sdk" },
-    { name = "pyyaml" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ee/7c/d83125c30e1a3e137c2c7f056f2a29db158ef1df7af23f9ae92e155c1986/agentuity-0.0.103.tar.gz", hash = "sha256:d1e16e9b08d4b3e4997f8e439814df7bfa77ee1ffa410f2fd4865a1044a7a3d1", size = 159055, upload-time = "2025-08-08T14:23:23.518Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/8d/568f60127e4306e36a0fb3a83c9101e8262613fbcf52b2b6fb8e12e13dd0/agentuity-0.0.103-py3-none-any.whl", hash = "sha256:e40f5a8f6453800f12dfc8ea7ccc222eafcbcb0d43ebf086cfeb2878b4deed67", size = 51793, upload-time = "2025-08-08T14:23:21.964Z" },
-]
-
-[[package]]
-name = "aiohappyeyeballs"
-version = "2.6.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
-]
-
-[[package]]
-name = "aiohttp"
-version = "3.12.15"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "aiohappyeyeballs" },
-    { name = "aiosignal" },
-    { name = "async-timeout", marker = "python_full_version < '3.11'" },
-    { name = "attrs" },
-    { name = "frozenlist" },
-    { name = "multidict" },
-    { name = "propcache" },
-    { name = "yarl" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9b/e7/d92a237d8802ca88483906c388f7c201bbe96cd80a165ffd0ac2f6a8d59f/aiohttp-3.12.15.tar.gz", hash = "sha256:4fc61385e9c98d72fcdf47e6dd81833f47b2f77c114c29cd64a361be57a763a2", size = 7823716, upload-time = "2025-07-29T05:52:32.215Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/dc/ef9394bde9080128ad401ac7ede185267ed637df03b51f05d14d1c99ad67/aiohttp-3.12.15-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b6fc902bff74d9b1879ad55f5404153e2b33a82e72a95c89cec5eb6cc9e92fbc", size = 703921, upload-time = "2025-07-29T05:49:43.584Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/42/63fccfc3a7ed97eb6e1a71722396f409c46b60a0552d8a56d7aad74e0df5/aiohttp-3.12.15-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:098e92835b8119b54c693f2f88a1dec690e20798ca5f5fe5f0520245253ee0af", size = 480288, upload-time = "2025-07-29T05:49:47.851Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/a2/7b8a020549f66ea2a68129db6960a762d2393248f1994499f8ba9728bbed/aiohttp-3.12.15-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:40b3fee496a47c3b4a39a731954c06f0bd9bd3e8258c059a4beb76ac23f8e421", size = 468063, upload-time = "2025-07-29T05:49:49.789Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/f5/d11e088da9176e2ad8220338ae0000ed5429a15f3c9dfd983f39105399cd/aiohttp-3.12.15-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ce13fcfb0bb2f259fb42106cdc63fa5515fb85b7e87177267d89a771a660b79", size = 1650122, upload-time = "2025-07-29T05:49:51.874Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/6b/b60ce2757e2faed3d70ed45dafee48cee7bfb878785a9423f7e883f0639c/aiohttp-3.12.15-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3beb14f053222b391bf9cf92ae82e0171067cc9c8f52453a0f1ec7c37df12a77", size = 1624176, upload-time = "2025-07-29T05:49:53.805Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/de/8c9fde2072a1b72c4fadecf4f7d4be7a85b1d9a4ab333d8245694057b4c6/aiohttp-3.12.15-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c39e87afe48aa3e814cac5f535bc6199180a53e38d3f51c5e2530f5aa4ec58c", size = 1696583, upload-time = "2025-07-29T05:49:55.338Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/ad/07f863ca3d895a1ad958a54006c6dafb4f9310f8c2fdb5f961b8529029d3/aiohttp-3.12.15-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5f1b4ce5bc528a6ee38dbf5f39bbf11dd127048726323b72b8e85769319ffc4", size = 1738896, upload-time = "2025-07-29T05:49:57.045Z" },
-    { url = "https://files.pythonhosted.org/packages/20/43/2bd482ebe2b126533e8755a49b128ec4e58f1a3af56879a3abdb7b42c54f/aiohttp-3.12.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1004e67962efabbaf3f03b11b4c43b834081c9e3f9b32b16a7d97d4708a9abe6", size = 1643561, upload-time = "2025-07-29T05:49:58.762Z" },
-    { url = "https://files.pythonhosted.org/packages/23/40/2fa9f514c4cf4cbae8d7911927f81a1901838baf5e09a8b2c299de1acfe5/aiohttp-3.12.15-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8faa08fcc2e411f7ab91d1541d9d597d3a90e9004180edb2072238c085eac8c2", size = 1583685, upload-time = "2025-07-29T05:50:00.375Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/c3/94dc7357bc421f4fb978ca72a201a6c604ee90148f1181790c129396ceeb/aiohttp-3.12.15-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fe086edf38b2222328cdf89af0dde2439ee173b8ad7cb659b4e4c6f385b2be3d", size = 1627533, upload-time = "2025-07-29T05:50:02.306Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/3f/1f8911fe1844a07001e26593b5c255a685318943864b27b4e0267e840f95/aiohttp-3.12.15-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:79b26fe467219add81d5e47b4a4ba0f2394e8b7c7c3198ed36609f9ba161aecb", size = 1638319, upload-time = "2025-07-29T05:50:04.282Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/46/27bf57a99168c4e145ffee6b63d0458b9c66e58bb70687c23ad3d2f0bd17/aiohttp-3.12.15-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b761bac1192ef24e16706d761aefcb581438b34b13a2f069a6d343ec8fb693a5", size = 1613776, upload-time = "2025-07-29T05:50:05.863Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/7e/1d2d9061a574584bb4ad3dbdba0da90a27fdc795bc227def3a46186a8bc1/aiohttp-3.12.15-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:e153e8adacfe2af562861b72f8bc47f8a5c08e010ac94eebbe33dc21d677cd5b", size = 1693359, upload-time = "2025-07-29T05:50:07.563Z" },
-    { url = "https://files.pythonhosted.org/packages/08/98/bee429b52233c4a391980a5b3b196b060872a13eadd41c3a34be9b1469ed/aiohttp-3.12.15-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:fc49c4de44977aa8601a00edbf157e9a421f227aa7eb477d9e3df48343311065", size = 1716598, upload-time = "2025-07-29T05:50:09.33Z" },
-    { url = "https://files.pythonhosted.org/packages/57/39/b0314c1ea774df3392751b686104a3938c63ece2b7ce0ba1ed7c0b4a934f/aiohttp-3.12.15-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2776c7ec89c54a47029940177e75c8c07c29c66f73464784971d6a81904ce9d1", size = 1644940, upload-time = "2025-07-29T05:50:11.334Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/83/3dacb8d3f8f512c8ca43e3fa8a68b20583bd25636ffa4e56ee841ffd79ae/aiohttp-3.12.15-cp310-cp310-win32.whl", hash = "sha256:2c7d81a277fa78b2203ab626ced1487420e8c11a8e373707ab72d189fcdad20a", size = 429239, upload-time = "2025-07-29T05:50:12.803Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/f9/470b5daba04d558c9673ca2034f28d067f3202a40e17804425f0c331c89f/aiohttp-3.12.15-cp310-cp310-win_amd64.whl", hash = "sha256:83603f881e11f0f710f8e2327817c82e79431ec976448839f3cd05d7afe8f830", size = 452297, upload-time = "2025-07-29T05:50:14.266Z" },
-    { url = "https://files.pythonhosted.org/packages/20/19/9e86722ec8e835959bd97ce8c1efa78cf361fa4531fca372551abcc9cdd6/aiohttp-3.12.15-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d3ce17ce0220383a0f9ea07175eeaa6aa13ae5a41f30bc61d84df17f0e9b1117", size = 711246, upload-time = "2025-07-29T05:50:15.937Z" },
-    { url = "https://files.pythonhosted.org/packages/71/f9/0a31fcb1a7d4629ac9d8f01f1cb9242e2f9943f47f5d03215af91c3c1a26/aiohttp-3.12.15-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:010cc9bbd06db80fe234d9003f67e97a10fe003bfbedb40da7d71c1008eda0fe", size = 483515, upload-time = "2025-07-29T05:50:17.442Z" },
-    { url = "https://files.pythonhosted.org/packages/62/6c/94846f576f1d11df0c2e41d3001000527c0fdf63fce7e69b3927a731325d/aiohttp-3.12.15-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3f9d7c55b41ed687b9d7165b17672340187f87a773c98236c987f08c858145a9", size = 471776, upload-time = "2025-07-29T05:50:19.568Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/6c/f766d0aaafcee0447fad0328da780d344489c042e25cd58fde566bf40aed/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc4fbc61bb3548d3b482f9ac7ddd0f18c67e4225aaa4e8552b9f1ac7e6bda9e5", size = 1741977, upload-time = "2025-07-29T05:50:21.665Z" },
-    { url = "https://files.pythonhosted.org/packages/17/e5/fb779a05ba6ff44d7bc1e9d24c644e876bfff5abe5454f7b854cace1b9cc/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbc8a7c410bb3ad5d595bb7118147dfbb6449d862cc1125cf8867cb337e8728", size = 1690645, upload-time = "2025-07-29T05:50:23.333Z" },
-    { url = "https://files.pythonhosted.org/packages/37/4e/a22e799c2035f5d6a4ad2cf8e7c1d1bd0923192871dd6e367dafb158b14c/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:74dad41b3458dbb0511e760fb355bb0b6689e0630de8a22b1b62a98777136e16", size = 1789437, upload-time = "2025-07-29T05:50:25.007Z" },
-    { url = "https://files.pythonhosted.org/packages/28/e5/55a33b991f6433569babb56018b2fb8fb9146424f8b3a0c8ecca80556762/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b6f0af863cf17e6222b1735a756d664159e58855da99cfe965134a3ff63b0b0", size = 1828482, upload-time = "2025-07-29T05:50:26.693Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/82/1ddf0ea4f2f3afe79dffed5e8a246737cff6cbe781887a6a170299e33204/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5b7fe4972d48a4da367043b8e023fb70a04d1490aa7d68800e465d1b97e493b", size = 1730944, upload-time = "2025-07-29T05:50:28.382Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/96/784c785674117b4cb3877522a177ba1b5e4db9ce0fd519430b5de76eec90/aiohttp-3.12.15-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6443cca89553b7a5485331bc9bedb2342b08d073fa10b8c7d1c60579c4a7b9bd", size = 1668020, upload-time = "2025-07-29T05:50:30.032Z" },
-    { url = "https://files.pythonhosted.org/packages/12/8a/8b75f203ea7e5c21c0920d84dd24a5c0e971fe1e9b9ebbf29ae7e8e39790/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c5f40ec615e5264f44b4282ee27628cea221fcad52f27405b80abb346d9f3f8", size = 1716292, upload-time = "2025-07-29T05:50:31.983Z" },
-    { url = "https://files.pythonhosted.org/packages/47/0b/a1451543475bb6b86a5cfc27861e52b14085ae232896a2654ff1231c0992/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:2abbb216a1d3a2fe86dbd2edce20cdc5e9ad0be6378455b05ec7f77361b3ab50", size = 1711451, upload-time = "2025-07-29T05:50:33.989Z" },
-    { url = "https://files.pythonhosted.org/packages/55/fd/793a23a197cc2f0d29188805cfc93aa613407f07e5f9da5cd1366afd9d7c/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:db71ce547012a5420a39c1b744d485cfb823564d01d5d20805977f5ea1345676", size = 1691634, upload-time = "2025-07-29T05:50:35.846Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/bf/23a335a6670b5f5dfc6d268328e55a22651b440fca341a64fccf1eada0c6/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:ced339d7c9b5030abad5854aa5413a77565e5b6e6248ff927d3e174baf3badf7", size = 1785238, upload-time = "2025-07-29T05:50:37.597Z" },
-    { url = "https://files.pythonhosted.org/packages/57/4f/ed60a591839a9d85d40694aba5cef86dde9ee51ce6cca0bb30d6eb1581e7/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:7c7dd29c7b5bda137464dc9bfc738d7ceea46ff70309859ffde8c022e9b08ba7", size = 1805701, upload-time = "2025-07-29T05:50:39.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/e0/444747a9455c5de188c0f4a0173ee701e2e325d4b2550e9af84abb20cdba/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:421da6fd326460517873274875c6c5a18ff225b40da2616083c5a34a7570b685", size = 1718758, upload-time = "2025-07-29T05:50:41.292Z" },
-    { url = "https://files.pythonhosted.org/packages/36/ab/1006278d1ffd13a698e5dd4bfa01e5878f6bddefc296c8b62649753ff249/aiohttp-3.12.15-cp311-cp311-win32.whl", hash = "sha256:4420cf9d179ec8dfe4be10e7d0fe47d6d606485512ea2265b0d8c5113372771b", size = 428868, upload-time = "2025-07-29T05:50:43.063Z" },
-    { url = "https://files.pythonhosted.org/packages/10/97/ad2b18700708452400278039272032170246a1bf8ec5d832772372c71f1a/aiohttp-3.12.15-cp311-cp311-win_amd64.whl", hash = "sha256:edd533a07da85baa4b423ee8839e3e91681c7bfa19b04260a469ee94b778bf6d", size = 453273, upload-time = "2025-07-29T05:50:44.613Z" },
-    { url = "https://files.pythonhosted.org/packages/63/97/77cb2450d9b35f517d6cf506256bf4f5bda3f93a66b4ad64ba7fc917899c/aiohttp-3.12.15-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:802d3868f5776e28f7bf69d349c26fc0efadb81676d0afa88ed00d98a26340b7", size = 702333, upload-time = "2025-07-29T05:50:46.507Z" },
-    { url = "https://files.pythonhosted.org/packages/83/6d/0544e6b08b748682c30b9f65640d006e51f90763b41d7c546693bc22900d/aiohttp-3.12.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2800614cd560287be05e33a679638e586a2d7401f4ddf99e304d98878c29444", size = 476948, upload-time = "2025-07-29T05:50:48.067Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/1d/c8c40e611e5094330284b1aea8a4b02ca0858f8458614fa35754cab42b9c/aiohttp-3.12.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8466151554b593909d30a0a125d638b4e5f3836e5aecde85b66b80ded1cb5b0d", size = 469787, upload-time = "2025-07-29T05:50:49.669Z" },
-    { url = "https://files.pythonhosted.org/packages/38/7d/b76438e70319796bfff717f325d97ce2e9310f752a267bfdf5192ac6082b/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e5a495cb1be69dae4b08f35a6c4579c539e9b5706f606632102c0f855bcba7c", size = 1716590, upload-time = "2025-07-29T05:50:51.368Z" },
-    { url = "https://files.pythonhosted.org/packages/79/b1/60370d70cdf8b269ee1444b390cbd72ce514f0d1cd1a715821c784d272c9/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6404dfc8cdde35c69aaa489bb3542fb86ef215fc70277c892be8af540e5e21c0", size = 1699241, upload-time = "2025-07-29T05:50:53.628Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/2b/4968a7b8792437ebc12186db31523f541943e99bda8f30335c482bea6879/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3ead1c00f8521a5c9070fcb88f02967b1d8a0544e6d85c253f6968b785e1a2ab", size = 1754335, upload-time = "2025-07-29T05:50:55.394Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/c1/49524ed553f9a0bec1a11fac09e790f49ff669bcd14164f9fab608831c4d/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6990ef617f14450bc6b34941dba4f12d5613cbf4e33805932f853fbd1cf18bfb", size = 1800491, upload-time = "2025-07-29T05:50:57.202Z" },
-    { url = "https://files.pythonhosted.org/packages/de/5e/3bf5acea47a96a28c121b167f5ef659cf71208b19e52a88cdfa5c37f1fcc/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd736ed420f4db2b8148b52b46b88ed038d0354255f9a73196b7bbce3ea97545", size = 1719929, upload-time = "2025-07-29T05:50:59.192Z" },
-    { url = "https://files.pythonhosted.org/packages/39/94/8ae30b806835bcd1cba799ba35347dee6961a11bd507db634516210e91d8/aiohttp-3.12.15-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c5092ce14361a73086b90c6efb3948ffa5be2f5b6fbcf52e8d8c8b8848bb97c", size = 1635733, upload-time = "2025-07-29T05:51:01.394Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/46/06cdef71dd03acd9da7f51ab3a9107318aee12ad38d273f654e4f981583a/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aaa2234bb60c4dbf82893e934d8ee8dea30446f0647e024074237a56a08c01bd", size = 1696790, upload-time = "2025-07-29T05:51:03.657Z" },
-    { url = "https://files.pythonhosted.org/packages/02/90/6b4cfaaf92ed98d0ec4d173e78b99b4b1a7551250be8937d9d67ecb356b4/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6d86a2fbdd14192e2f234a92d3b494dd4457e683ba07e5905a0b3ee25389ac9f", size = 1718245, upload-time = "2025-07-29T05:51:05.911Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/e6/2593751670fa06f080a846f37f112cbe6f873ba510d070136a6ed46117c6/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a041e7e2612041a6ddf1c6a33b883be6a421247c7afd47e885969ee4cc58bd8d", size = 1658899, upload-time = "2025-07-29T05:51:07.753Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/28/c15bacbdb8b8eb5bf39b10680d129ea7410b859e379b03190f02fa104ffd/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5015082477abeafad7203757ae44299a610e89ee82a1503e3d4184e6bafdd519", size = 1738459, upload-time = "2025-07-29T05:51:09.56Z" },
-    { url = "https://files.pythonhosted.org/packages/00/de/c269cbc4faa01fb10f143b1670633a8ddd5b2e1ffd0548f7aa49cb5c70e2/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:56822ff5ddfd1b745534e658faba944012346184fbfe732e0d6134b744516eea", size = 1766434, upload-time = "2025-07-29T05:51:11.423Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b0/4ff3abd81aa7d929b27d2e1403722a65fc87b763e3a97b3a2a494bfc63bc/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b2acbbfff69019d9014508c4ba0401822e8bae5a5fdc3b6814285b71231b60f3", size = 1726045, upload-time = "2025-07-29T05:51:13.689Z" },
-    { url = "https://files.pythonhosted.org/packages/71/16/949225a6a2dd6efcbd855fbd90cf476052e648fb011aa538e3b15b89a57a/aiohttp-3.12.15-cp312-cp312-win32.whl", hash = "sha256:d849b0901b50f2185874b9a232f38e26b9b3d4810095a7572eacea939132d4e1", size = 423591, upload-time = "2025-07-29T05:51:15.452Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/d8/fa65d2a349fe938b76d309db1a56a75c4fb8cc7b17a398b698488a939903/aiohttp-3.12.15-cp312-cp312-win_amd64.whl", hash = "sha256:b390ef5f62bb508a9d67cb3bba9b8356e23b3996da7062f1a57ce1a79d2b3d34", size = 450266, upload-time = "2025-07-29T05:51:17.239Z" },
-]
-
-[[package]]
-name = "aiohttp-sse"
-version = "2.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "aiohttp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/80/df/4ddb30e689695fd91cf41c072e154061120ed166e8baf6c9a0020f27dffc/aiohttp-sse-2.2.0.tar.gz", hash = "sha256:a48dd5774031d3f41a29e159ebdbb93e89c8f37c1e9e83e196296be51885a5c2", size = 9432, upload-time = "2024-02-29T18:43:48.118Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/b8/bf448b1d2dbe6cf16c3be0b92230a8f032f2f0ed159a2299284c709819c8/aiohttp_sse-2.2.0-py3-none-any.whl", hash = "sha256:339f9803bcf4682a2060e75548760d86abe4424a0d92ba66ff4985de3bd743dc", size = 6740, upload-time = "2024-02-29T18:43:46.423Z" },
-]
-
-[[package]]
-name = "aiosignal"
-version = "1.4.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "frozenlist" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
-]
-
-[[package]]
-name = "annotated-types"
-version = "0.7.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
-]
-
-[[package]]
-name = "anthropic"
-version = "0.64.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "distro" },
-    { name = "httpx" },
-    { name = "jiter" },
-    { name = "pydantic" },
-    { name = "sniffio" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d8/4f/f2b880cba1a76f3acc7d5eb2ae217632eac1b8cef5ed3027493545c59eba/anthropic-0.64.0.tar.gz", hash = "sha256:3d496c91a63dff64f451b3e8e4b238a9640bf87b0c11d0b74ddc372ba5a3fe58", size = 427893, upload-time = "2025-08-13T17:09:49.915Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a9/b2/2d268bcd5d6441df9dc0ebebc67107657edb8b0150d3fda1a5b81d1bec45/anthropic-0.64.0-py3-none-any.whl", hash = "sha256:6f5f7d913a6a95eb7f8e1bda4e75f76670e8acd8d4cd965e02e2a256b0429dd1", size = 297244, upload-time = "2025-08-13T17:09:47.908Z" },
-]
-
-[[package]]
-name = "anyio"
-version = "4.10.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
-    { name = "idna" },
-    { name = "sniffio" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f1/b4/636b3b65173d3ce9a38ef5f0522789614e590dab6a8d505340a4efe4c567/anyio-4.10.0.tar.gz", hash = "sha256:3f3fae35c96039744587aa5b8371e7e8e603c0702999535961dd336026973ba6", size = 213252, upload-time = "2025-08-04T08:54:26.451Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6f/12/e5e0282d673bb9746bacfb6e2dba8719989d3660cdb2ea79aee9a9651afb/anyio-4.10.0-py3-none-any.whl", hash = "sha256:60e474ac86736bbfd6f210f7a61218939c318f43f9972497381f1c5e930ed3d1", size = 107213, upload-time = "2025-08-04T08:54:24.882Z" },
-]
-
-[[package]]
-name = "asgiref"
-version = "3.9.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/90/61/0aa957eec22ff70b830b22ff91f825e70e1ef732c06666a805730f28b36b/asgiref-3.9.1.tar.gz", hash = "sha256:a5ab6582236218e5ef1648f242fd9f10626cfd4de8dc377db215d5d5098e3142", size = 36870, upload-time = "2025-07-08T09:07:43.344Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7c/3c/0464dcada90d5da0e71018c04a140ad6349558afb30b3051b4264cc5b965/asgiref-3.9.1-py3-none-any.whl", hash = "sha256:f3bba7092a48005b5f5bacd747d36ee4a5a61f4a269a6df590b43144355ebd2c", size = 23790, upload-time = "2025-07-08T09:07:41.548Z" },
-]
-
-[[package]]
-name = "async-timeout"
-version = "4.0.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/87/d6/21b30a550dafea84b1b8eee21b5e23fa16d010ae006011221f33dcd8d7f8/async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f", size = 8345, upload-time = "2023-08-10T16:35:56.907Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/fa/e01228c2938de91d47b307831c62ab9e4001e747789d0b05baf779a6488c/async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028", size = 5721, upload-time = "2023-08-10T16:35:55.203Z" },
-]
-
-[[package]]
-name = "asyncio"
-version = "4.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/71/ea/26c489a11f7ca862d5705db67683a7361ce11c23a7b98fc6c2deaeccede2/asyncio-4.0.0.tar.gz", hash = "sha256:570cd9e50db83bc1629152d4d0b7558d6451bb1bfd5dfc2e935d96fc2f40329b", size = 5371, upload-time = "2025-08-05T02:51:46.605Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/57/64/eff2564783bd650ca25e15938d1c5b459cda997574a510f7de69688cb0b4/asyncio-4.0.0-py3-none-any.whl", hash = "sha256:c1eddb0659231837046809e68103969b2bef8b0400d59cfa6363f6b5ed8cc88b", size = 5555, upload-time = "2025-08-05T02:51:45.767Z" },
-]
-
-[[package]]
-name = "attrs"
-version = "25.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032, upload-time = "2025-03-13T11:10:22.779Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815, upload-time = "2025-03-13T11:10:21.14Z" },
-]
-
-[[package]]
-name = "boto3"
-version = "1.40.16"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "botocore" },
-    { name = "jmespath" },
-    { name = "s3transfer" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/d4/ad261cb17f202082ba8598fd6d1d27eac5d11307ce99e3f5867bc9e376ee/boto3-1.40.16.tar.gz", hash = "sha256:667bc3a9bd1f26579957d95a2612359103c343dd74d44f202d09a155ed4189c6", size = 111944, upload-time = "2025-08-22T19:28:30.643Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f1/ce/6030ebcde6a19920c36d633643811a80e53d2b92a4a125ddf07520b2da66/boto3-1.40.16-py3-none-any.whl", hash = "sha256:4b7fbd2b469d5fa6325f0e90310b2d430c9a35e8a984a9919103e6d248422537", size = 140076, upload-time = "2025-08-22T19:28:28.656Z" },
-]
-
-[[package]]
-name = "botocore"
-version = "1.40.16"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "jmespath" },
-    { name = "python-dateutil" },
-    { name = "urllib3" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/25/4c/7087a282f10dc2258a107e4a29645678b5d3fa7cbabed05d540370aa8c57/botocore-1.40.16.tar.gz", hash = "sha256:522a8b7e3837667aca978b5b2dd2d12c3834f58f13df3c8d3369070d883d608d", size = 14368291, upload-time = "2025-08-22T19:28:20.227Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/5c/81ff55d99c0f38fdcaee693228a6af61486f368fe7e49bc27da1317682b9/botocore-1.40.16-py3-none-any.whl", hash = "sha256:0296a245cb349431279d825522ae70270edf8d8be7b91108fdcc086ea347c0b6", size = 14030380, upload-time = "2025-08-22T19:28:14.793Z" },
-]
-
-[[package]]
-name = "certifi"
-version = "2025.8.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/dc/67/960ebe6bf230a96cda2e0abcf73af550ec4f090005363542f0765df162e0/certifi-2025.8.3.tar.gz", hash = "sha256:e564105f78ded564e3ae7c923924435e1daa7463faeab5bb932bc53ffae63407", size = 162386, upload-time = "2025-08-03T03:07:47.08Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/48/1549795ba7742c948d2ad169c1c8cdbae65bc450d6cd753d124b17c8cd32/certifi-2025.8.3-py3-none-any.whl", hash = "sha256:f6c12493cfb1b06ba2ff328595af9350c65d6644968e5d3a2ffd78699af217a5", size = 161216, upload-time = "2025-08-03T03:07:45.777Z" },
-]
-
-[[package]]
-name = "cffi"
-version = "1.17.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pycparser" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload-time = "2024-09-04T20:45:21.852Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191, upload-time = "2024-09-04T20:43:30.027Z" },
-    { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592, upload-time = "2024-09-04T20:43:32.108Z" },
-    { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024, upload-time = "2024-09-04T20:43:34.186Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188, upload-time = "2024-09-04T20:43:36.286Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571, upload-time = "2024-09-04T20:43:38.586Z" },
-    { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687, upload-time = "2024-09-04T20:43:40.084Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211, upload-time = "2024-09-04T20:43:41.526Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325, upload-time = "2024-09-04T20:43:43.117Z" },
-    { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784, upload-time = "2024-09-04T20:43:45.256Z" },
-    { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564, upload-time = "2024-09-04T20:43:46.779Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804, upload-time = "2024-09-04T20:43:48.186Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299, upload-time = "2024-09-04T20:43:49.812Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264, upload-time = "2024-09-04T20:43:51.124Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651, upload-time = "2024-09-04T20:43:52.872Z" },
-    { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259, upload-time = "2024-09-04T20:43:56.123Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200, upload-time = "2024-09-04T20:43:57.891Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235, upload-time = "2024-09-04T20:44:00.18Z" },
-    { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721, upload-time = "2024-09-04T20:44:01.585Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242, upload-time = "2024-09-04T20:44:03.467Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999, upload-time = "2024-09-04T20:44:05.023Z" },
-    { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242, upload-time = "2024-09-04T20:44:06.444Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604, upload-time = "2024-09-04T20:44:08.206Z" },
-    { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727, upload-time = "2024-09-04T20:44:09.481Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400, upload-time = "2024-09-04T20:44:10.873Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178, upload-time = "2024-09-04T20:44:12.232Z" },
-    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840, upload-time = "2024-09-04T20:44:13.739Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803, upload-time = "2024-09-04T20:44:15.231Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850, upload-time = "2024-09-04T20:44:17.188Z" },
-    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729, upload-time = "2024-09-04T20:44:18.688Z" },
-    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256, upload-time = "2024-09-04T20:44:20.248Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424, upload-time = "2024-09-04T20:44:21.673Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568, upload-time = "2024-09-04T20:44:23.245Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736, upload-time = "2024-09-04T20:44:24.757Z" },
-    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload-time = "2024-09-04T20:44:26.208Z" },
-    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload-time = "2024-09-04T20:44:27.578Z" },
-]
-
-[[package]]
-name = "charset-normalizer"
-version = "3.4.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/83/2d/5fd176ceb9b2fc619e63405525573493ca23441330fcdaee6bef9460e924/charset_normalizer-3.4.3.tar.gz", hash = "sha256:6fce4b8500244f6fcb71465d4a4930d132ba9ab8e71a7859e6a5d59851068d14", size = 122371, upload-time = "2025-08-09T07:57:28.46Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d6/98/f3b8013223728a99b908c9344da3aa04ee6e3fa235f19409033eda92fb78/charset_normalizer-3.4.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:fb7f67a1bfa6e40b438170ebdc8158b78dc465a5a67b6dde178a46987b244a72", size = 207695, upload-time = "2025-08-09T07:55:36.452Z" },
-    { url = "https://files.pythonhosted.org/packages/21/40/5188be1e3118c82dcb7c2a5ba101b783822cfb413a0268ed3be0468532de/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc9370a2da1ac13f0153780040f465839e6cccb4a1e44810124b4e22483c93fe", size = 147153, upload-time = "2025-08-09T07:55:38.467Z" },
-    { url = "https://files.pythonhosted.org/packages/37/60/5d0d74bc1e1380f0b72c327948d9c2aca14b46a9efd87604e724260f384c/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:07a0eae9e2787b586e129fdcbe1af6997f8d0e5abaa0bc98c0e20e124d67e601", size = 160428, upload-time = "2025-08-09T07:55:40.072Z" },
-    { url = "https://files.pythonhosted.org/packages/85/9a/d891f63722d9158688de58d050c59dc3da560ea7f04f4c53e769de5140f5/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:74d77e25adda8581ffc1c720f1c81ca082921329452eba58b16233ab1842141c", size = 157627, upload-time = "2025-08-09T07:55:41.706Z" },
-    { url = "https://files.pythonhosted.org/packages/65/1a/7425c952944a6521a9cfa7e675343f83fd82085b8af2b1373a2409c683dc/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0e909868420b7049dafd3a31d45125b31143eec59235311fc4c57ea26a4acd2", size = 152388, upload-time = "2025-08-09T07:55:43.262Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/c9/a2c9c2a355a8594ce2446085e2ec97fd44d323c684ff32042e2a6b718e1d/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c6f162aabe9a91a309510d74eeb6507fab5fff92337a15acbe77753d88d9dcf0", size = 150077, upload-time = "2025-08-09T07:55:44.903Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/38/20a1f44e4851aa1c9105d6e7110c9d020e093dfa5836d712a5f074a12bf7/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca4c094de7771a98d7fbd67d9e5dbf1eb73efa4f744a730437d8a3a5cf994f0", size = 161631, upload-time = "2025-08-09T07:55:46.346Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/fa/384d2c0f57edad03d7bec3ebefb462090d8905b4ff5a2d2525f3bb711fac/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:02425242e96bcf29a49711b0ca9f37e451da7c70562bc10e8ed992a5a7a25cc0", size = 159210, upload-time = "2025-08-09T07:55:47.539Z" },
-    { url = "https://files.pythonhosted.org/packages/33/9e/eca49d35867ca2db336b6ca27617deed4653b97ebf45dfc21311ce473c37/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:78deba4d8f9590fe4dae384aeff04082510a709957e968753ff3c48399f6f92a", size = 153739, upload-time = "2025-08-09T07:55:48.744Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/91/26c3036e62dfe8de8061182d33be5025e2424002125c9500faff74a6735e/charset_normalizer-3.4.3-cp310-cp310-win32.whl", hash = "sha256:d79c198e27580c8e958906f803e63cddb77653731be08851c7df0b1a14a8fc0f", size = 99825, upload-time = "2025-08-09T07:55:50.305Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/c6/f05db471f81af1fa01839d44ae2a8bfeec8d2a8b4590f16c4e7393afd323/charset_normalizer-3.4.3-cp310-cp310-win_amd64.whl", hash = "sha256:c6e490913a46fa054e03699c70019ab869e990270597018cef1d8562132c2669", size = 107452, upload-time = "2025-08-09T07:55:51.461Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/b5/991245018615474a60965a7c9cd2b4efbaabd16d582a5547c47ee1c7730b/charset_normalizer-3.4.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b256ee2e749283ef3ddcff51a675ff43798d92d746d1a6e4631bf8c707d22d0b", size = 204483, upload-time = "2025-08-09T07:55:53.12Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/2a/ae245c41c06299ec18262825c1569c5d3298fc920e4ddf56ab011b417efd/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13faeacfe61784e2559e690fc53fa4c5ae97c6fcedb8eb6fb8d0a15b475d2c64", size = 145520, upload-time = "2025-08-09T07:55:54.712Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/a4/b3b6c76e7a635748c4421d2b92c7b8f90a432f98bda5082049af37ffc8e3/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:00237675befef519d9af72169d8604a067d92755e84fe76492fef5441db05b91", size = 158876, upload-time = "2025-08-09T07:55:56.024Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/e6/63bb0e10f90a8243c5def74b5b105b3bbbfb3e7bb753915fe333fb0c11ea/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:585f3b2a80fbd26b048a0be90c5aae8f06605d3c92615911c3a2b03a8a3b796f", size = 156083, upload-time = "2025-08-09T07:55:57.582Z" },
-    { url = "https://files.pythonhosted.org/packages/87/df/b7737ff046c974b183ea9aa111b74185ac8c3a326c6262d413bd5a1b8c69/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e78314bdc32fa80696f72fa16dc61168fda4d6a0c014e0380f9d02f0e5d8a07", size = 150295, upload-time = "2025-08-09T07:55:59.147Z" },
-    { url = "https://files.pythonhosted.org/packages/61/f1/190d9977e0084d3f1dc169acd060d479bbbc71b90bf3e7bf7b9927dec3eb/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:96b2b3d1a83ad55310de8c7b4a2d04d9277d5591f40761274856635acc5fcb30", size = 148379, upload-time = "2025-08-09T07:56:00.364Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/92/27dbe365d34c68cfe0ca76f1edd70e8705d82b378cb54ebbaeabc2e3029d/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:939578d9d8fd4299220161fdd76e86c6a251987476f5243e8864a7844476ba14", size = 160018, upload-time = "2025-08-09T07:56:01.678Z" },
-    { url = "https://files.pythonhosted.org/packages/99/04/baae2a1ea1893a01635d475b9261c889a18fd48393634b6270827869fa34/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:fd10de089bcdcd1be95a2f73dbe6254798ec1bda9f450d5828c96f93e2536b9c", size = 157430, upload-time = "2025-08-09T07:56:02.87Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/36/77da9c6a328c54d17b960c89eccacfab8271fdaaa228305330915b88afa9/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1e8ac75d72fa3775e0b7cb7e4629cec13b7514d928d15ef8ea06bca03ef01cae", size = 151600, upload-time = "2025-08-09T07:56:04.089Z" },
-    { url = "https://files.pythonhosted.org/packages/64/d4/9eb4ff2c167edbbf08cdd28e19078bf195762e9bd63371689cab5ecd3d0d/charset_normalizer-3.4.3-cp311-cp311-win32.whl", hash = "sha256:6cf8fd4c04756b6b60146d98cd8a77d0cdae0e1ca20329da2ac85eed779b6849", size = 99616, upload-time = "2025-08-09T07:56:05.658Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/9c/996a4a028222e7761a96634d1820de8a744ff4327a00ada9c8942033089b/charset_normalizer-3.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:31a9a6f775f9bcd865d88ee350f0ffb0e25936a7f930ca98995c05abf1faf21c", size = 107108, upload-time = "2025-08-09T07:56:07.176Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/5e/14c94999e418d9b87682734589404a25854d5f5d0408df68bc15b6ff54bb/charset_normalizer-3.4.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e28e334d3ff134e88989d90ba04b47d84382a828c061d0d1027b1b12a62b39b1", size = 205655, upload-time = "2025-08-09T07:56:08.475Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/a8/c6ec5d389672521f644505a257f50544c074cf5fc292d5390331cd6fc9c3/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0cacf8f7297b0c4fcb74227692ca46b4a5852f8f4f24b3c766dd94a1075c4884", size = 146223, upload-time = "2025-08-09T07:56:09.708Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/eb/a2ffb08547f4e1e5415fb69eb7db25932c52a52bed371429648db4d84fb1/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c6fd51128a41297f5409deab284fecbe5305ebd7e5a1f959bee1c054622b7018", size = 159366, upload-time = "2025-08-09T07:56:11.326Z" },
-    { url = "https://files.pythonhosted.org/packages/82/10/0fd19f20c624b278dddaf83b8464dcddc2456cb4b02bb902a6da126b87a1/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cfb2aad70f2c6debfbcb717f23b7eb55febc0bb23dcffc0f076009da10c6392", size = 157104, upload-time = "2025-08-09T07:56:13.014Z" },
-    { url = "https://files.pythonhosted.org/packages/16/ab/0233c3231af734f5dfcf0844aa9582d5a1466c985bbed6cedab85af9bfe3/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1606f4a55c0fd363d754049cdf400175ee96c992b1f8018b993941f221221c5f", size = 151830, upload-time = "2025-08-09T07:56:14.428Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/02/e29e22b4e02839a0e4a06557b1999d0a47db3567e82989b5bb21f3fbbd9f/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:027b776c26d38b7f15b26a5da1044f376455fb3766df8fc38563b4efbc515154", size = 148854, upload-time = "2025-08-09T07:56:16.051Z" },
-    { url = "https://files.pythonhosted.org/packages/05/6b/e2539a0a4be302b481e8cafb5af8792da8093b486885a1ae4d15d452bcec/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:42e5088973e56e31e4fa58eb6bd709e42fc03799c11c42929592889a2e54c491", size = 160670, upload-time = "2025-08-09T07:56:17.314Z" },
-    { url = "https://files.pythonhosted.org/packages/31/e7/883ee5676a2ef217a40ce0bffcc3d0dfbf9e64cbcfbdf822c52981c3304b/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cc34f233c9e71701040d772aa7490318673aa7164a0efe3172b2981218c26d93", size = 158501, upload-time = "2025-08-09T07:56:18.641Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/35/6525b21aa0db614cf8b5792d232021dca3df7f90a1944db934efa5d20bb1/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:320e8e66157cc4e247d9ddca8e21f427efc7a04bbd0ac8a9faf56583fa543f9f", size = 153173, upload-time = "2025-08-09T07:56:20.289Z" },
-    { url = "https://files.pythonhosted.org/packages/50/ee/f4704bad8201de513fdc8aac1cabc87e38c5818c93857140e06e772b5892/charset_normalizer-3.4.3-cp312-cp312-win32.whl", hash = "sha256:fb6fecfd65564f208cbf0fba07f107fb661bcd1a7c389edbced3f7a493f70e37", size = 99822, upload-time = "2025-08-09T07:56:21.551Z" },
-    { url = "https://files.pythonhosted.org/packages/39/f5/3b3836ca6064d0992c58c7561c6b6eee1b3892e9665d650c803bd5614522/charset_normalizer-3.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:86df271bf921c2ee3818f0522e9a5b8092ca2ad8b065ece5d7d9d0e9f4849bcc", size = 107543, upload-time = "2025-08-09T07:56:23.115Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1f/f041989e93b001bc4e44bb1669ccdcf54d3f00e628229a85b08d330615c5/charset_normalizer-3.4.3-py3-none-any.whl", hash = "sha256:ce571ab16d890d23b5c278547ba694193a45011ff86a9162a71307ed9f86759a", size = 53175, upload-time = "2025-08-09T07:57:26.864Z" },
-]
-
-[[package]]
-name = "click"
-version = "8.2.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/60/6c/8ca2efa64cf75a977a0d7fac081354553ebe483345c734fb6b6515d96bbc/click-8.2.1.tar.gz", hash = "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202", size = 286342, upload-time = "2025-05-20T23:19:49.832Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215, upload-time = "2025-05-20T23:19:47.796Z" },
-]
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
-]
-
-[[package]]
-name = "cryptography"
-version = "45.0.6"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d6/0d/d13399c94234ee8f3df384819dc67e0c5ce215fb751d567a55a1f4b028c7/cryptography-45.0.6.tar.gz", hash = "sha256:5c966c732cf6e4a276ce83b6e4c729edda2df6929083a952cc7da973c539c719", size = 744949, upload-time = "2025-08-05T23:59:27.93Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8c/29/2793d178d0eda1ca4a09a7c4e09a5185e75738cc6d526433e8663b460ea6/cryptography-45.0.6-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:048e7ad9e08cf4c0ab07ff7f36cc3115924e22e2266e034450a890d9e312dd74", size = 7042702, upload-time = "2025-08-05T23:58:23.464Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/b6/cabd07410f222f32c8d55486c464f432808abaa1f12af9afcbe8f2f19030/cryptography-45.0.6-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:44647c5d796f5fc042bbc6d61307d04bf29bccb74d188f18051b635f20a9c75f", size = 4206483, upload-time = "2025-08-05T23:58:27.132Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/9e/f9c7d36a38b1cfeb1cc74849aabe9bf817990f7603ff6eb485e0d70e0b27/cryptography-45.0.6-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e40b80ecf35ec265c452eea0ba94c9587ca763e739b8e559c128d23bff7ebbbf", size = 4429679, upload-time = "2025-08-05T23:58:29.152Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/2a/4434c17eb32ef30b254b9e8b9830cee4e516f08b47fdd291c5b1255b8101/cryptography-45.0.6-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:00e8724bdad672d75e6f069b27970883179bd472cd24a63f6e620ca7e41cc0c5", size = 4210553, upload-time = "2025-08-05T23:58:30.596Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/1d/09a5df8e0c4b7970f5d1f3aff1b640df6d4be28a64cae970d56c6cf1c772/cryptography-45.0.6-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a3085d1b319d35296176af31c90338eeb2ddac8104661df79f80e1d9787b8b2", size = 3894499, upload-time = "2025-08-05T23:58:32.03Z" },
-    { url = "https://files.pythonhosted.org/packages/79/62/120842ab20d9150a9d3a6bdc07fe2870384e82f5266d41c53b08a3a96b34/cryptography-45.0.6-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1b7fa6a1c1188c7ee32e47590d16a5a0646270921f8020efc9a511648e1b2e08", size = 4458484, upload-time = "2025-08-05T23:58:33.526Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/80/1bc3634d45ddfed0871bfba52cf8f1ad724761662a0c792b97a951fb1b30/cryptography-45.0.6-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:275ba5cc0d9e320cd70f8e7b96d9e59903c815ca579ab96c1e37278d231fc402", size = 4210281, upload-time = "2025-08-05T23:58:35.445Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/fe/ffb12c2d83d0ee625f124880a1f023b5878f79da92e64c37962bbbe35f3f/cryptography-45.0.6-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:f4028f29a9f38a2025abedb2e409973709c660d44319c61762202206ed577c42", size = 4456890, upload-time = "2025-08-05T23:58:36.923Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/8e/b3f3fe0dc82c77a0deb5f493b23311e09193f2268b77196ec0f7a36e3f3e/cryptography-45.0.6-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ee411a1b977f40bd075392c80c10b58025ee5c6b47a822a33c1198598a7a5f05", size = 4333247, upload-time = "2025-08-05T23:58:38.781Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/a6/c3ef2ab9e334da27a1d7b56af4a2417d77e7806b2e0f90d6267ce120d2e4/cryptography-45.0.6-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e2a21a8eda2d86bb604934b6b37691585bd095c1f788530c1fcefc53a82b3453", size = 4565045, upload-time = "2025-08-05T23:58:40.415Z" },
-    { url = "https://files.pythonhosted.org/packages/31/c3/77722446b13fa71dddd820a5faab4ce6db49e7e0bf8312ef4192a3f78e2f/cryptography-45.0.6-cp311-abi3-win32.whl", hash = "sha256:d063341378d7ee9c91f9d23b431a3502fc8bfacd54ef0a27baa72a0843b29159", size = 2928923, upload-time = "2025-08-05T23:58:41.919Z" },
-    { url = "https://files.pythonhosted.org/packages/38/63/a025c3225188a811b82932a4dcc8457a26c3729d81578ccecbcce2cb784e/cryptography-45.0.6-cp311-abi3-win_amd64.whl", hash = "sha256:833dc32dfc1e39b7376a87b9a6a4288a10aae234631268486558920029b086ec", size = 3403805, upload-time = "2025-08-05T23:58:43.792Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/af/bcfbea93a30809f126d51c074ee0fac5bd9d57d068edf56c2a73abedbea4/cryptography-45.0.6-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:3436128a60a5e5490603ab2adbabc8763613f638513ffa7d311c900a8349a2a0", size = 7020111, upload-time = "2025-08-05T23:58:45.316Z" },
-    { url = "https://files.pythonhosted.org/packages/98/c6/ea5173689e014f1a8470899cd5beeb358e22bb3cf5a876060f9d1ca78af4/cryptography-45.0.6-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0d9ef57b6768d9fa58e92f4947cea96ade1233c0e236db22ba44748ffedca394", size = 4198169, upload-time = "2025-08-05T23:58:47.121Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/73/b12995edc0c7e2311ffb57ebd3b351f6b268fed37d93bfc6f9856e01c473/cryptography-45.0.6-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea3c42f2016a5bbf71825537c2ad753f2870191134933196bee408aac397b3d9", size = 4421273, upload-time = "2025-08-05T23:58:48.557Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/6e/286894f6f71926bc0da67408c853dd9ba953f662dcb70993a59fd499f111/cryptography-45.0.6-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:20ae4906a13716139d6d762ceb3e0e7e110f7955f3bc3876e3a07f5daadec5f3", size = 4199211, upload-time = "2025-08-05T23:58:50.139Z" },
-    { url = "https://files.pythonhosted.org/packages/de/34/a7f55e39b9623c5cb571d77a6a90387fe557908ffc44f6872f26ca8ae270/cryptography-45.0.6-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dac5ec199038b8e131365e2324c03d20e97fe214af051d20c49db129844e8b3", size = 3883732, upload-time = "2025-08-05T23:58:52.253Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/b9/c6d32edbcba0cd9f5df90f29ed46a65c4631c4fbe11187feb9169c6ff506/cryptography-45.0.6-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:18f878a34b90d688982e43f4b700408b478102dd58b3e39de21b5ebf6509c301", size = 4450655, upload-time = "2025-08-05T23:58:53.848Z" },
-    { url = "https://files.pythonhosted.org/packages/77/2d/09b097adfdee0227cfd4c699b3375a842080f065bab9014248933497c3f9/cryptography-45.0.6-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5bd6020c80c5b2b2242d6c48487d7b85700f5e0038e67b29d706f98440d66eb5", size = 4198956, upload-time = "2025-08-05T23:58:55.209Z" },
-    { url = "https://files.pythonhosted.org/packages/55/66/061ec6689207d54effdff535bbdf85cc380d32dd5377173085812565cf38/cryptography-45.0.6-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:eccddbd986e43014263eda489abbddfbc287af5cddfd690477993dbb31e31016", size = 4449859, upload-time = "2025-08-05T23:58:56.639Z" },
-    { url = "https://files.pythonhosted.org/packages/41/ff/e7d5a2ad2d035e5a2af116e1a3adb4d8fcd0be92a18032917a089c6e5028/cryptography-45.0.6-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:550ae02148206beb722cfe4ef0933f9352bab26b087af00e48fdfb9ade35c5b3", size = 4320254, upload-time = "2025-08-05T23:58:58.833Z" },
-    { url = "https://files.pythonhosted.org/packages/82/27/092d311af22095d288f4db89fcaebadfb2f28944f3d790a4cf51fe5ddaeb/cryptography-45.0.6-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5b64e668fc3528e77efa51ca70fadcd6610e8ab231e3e06ae2bab3b31c2b8ed9", size = 4554815, upload-time = "2025-08-05T23:59:00.283Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/01/aa2f4940262d588a8fdf4edabe4cda45854d00ebc6eaac12568b3a491a16/cryptography-45.0.6-cp37-abi3-win32.whl", hash = "sha256:780c40fb751c7d2b0c6786ceee6b6f871e86e8718a8ff4bc35073ac353c7cd02", size = 2912147, upload-time = "2025-08-05T23:59:01.716Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/bc/16e0276078c2de3ceef6b5a34b965f4436215efac45313df90d55f0ba2d2/cryptography-45.0.6-cp37-abi3-win_amd64.whl", hash = "sha256:20d15aed3ee522faac1a39fbfdfee25d17b1284bafd808e1640a74846d7c4d1b", size = 3390459, upload-time = "2025-08-05T23:59:03.358Z" },
-    { url = "https://files.pythonhosted.org/packages/56/d2/4482d97c948c029be08cb29854a91bd2ae8da7eb9c4152461f1244dcea70/cryptography-45.0.6-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:705bb7c7ecc3d79a50f236adda12ca331c8e7ecfbea51edd931ce5a7a7c4f012", size = 3576812, upload-time = "2025-08-05T23:59:04.833Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/24/55fc238fcaa122855442604b8badb2d442367dfbd5a7ca4bb0bd346e263a/cryptography-45.0.6-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:826b46dae41a1155a0c0e66fafba43d0ede1dc16570b95e40c4d83bfcf0a451d", size = 4141694, upload-time = "2025-08-05T23:59:06.66Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/7e/3ea4fa6fbe51baf3903806a0241c666b04c73d2358a3ecce09ebee8b9622/cryptography-45.0.6-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:cc4d66f5dc4dc37b89cfef1bd5044387f7a1f6f0abb490815628501909332d5d", size = 4375010, upload-time = "2025-08-05T23:59:08.14Z" },
-    { url = "https://files.pythonhosted.org/packages/50/42/ec5a892d82d2a2c29f80fc19ced4ba669bca29f032faf6989609cff1f8dc/cryptography-45.0.6-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:f68f833a9d445cc49f01097d95c83a850795921b3f7cc6488731e69bde3288da", size = 4141377, upload-time = "2025-08-05T23:59:09.584Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/d7/246c4c973a22b9c2931999da953a2c19cae7c66b9154c2d62ffed811225e/cryptography-45.0.6-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:3b5bf5267e98661b9b888a9250d05b063220dfa917a8203744454573c7eb79db", size = 4374609, upload-time = "2025-08-05T23:59:11.923Z" },
-    { url = "https://files.pythonhosted.org/packages/78/6d/c49ccf243f0a1b0781c2a8de8123ee552f0c8a417c6367a24d2ecb7c11b3/cryptography-45.0.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:2384f2ab18d9be88a6e4f8972923405e2dbb8d3e16c6b43f15ca491d7831bd18", size = 3322156, upload-time = "2025-08-05T23:59:13.597Z" },
-    { url = "https://files.pythonhosted.org/packages/61/69/c252de4ec047ba2f567ecb53149410219577d408c2aea9c989acae7eafce/cryptography-45.0.6-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fc022c1fa5acff6def2fc6d7819bbbd31ccddfe67d075331a65d9cfb28a20983", size = 3584669, upload-time = "2025-08-05T23:59:15.431Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/fe/deea71e9f310a31fe0a6bfee670955152128d309ea2d1c79e2a5ae0f0401/cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:3de77e4df42ac8d4e4d6cdb342d989803ad37707cf8f3fbf7b088c9cbdd46427", size = 4153022, upload-time = "2025-08-05T23:59:16.954Z" },
-    { url = "https://files.pythonhosted.org/packages/60/45/a77452f5e49cb580feedba6606d66ae7b82c128947aa754533b3d1bd44b0/cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:599c8d7df950aa68baa7e98f7b73f4f414c9f02d0e8104a30c0182a07732638b", size = 4386802, upload-time = "2025-08-05T23:59:18.55Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/b9/a2f747d2acd5e3075fdf5c145c7c3568895daaa38b3b0c960ef830db6cdc/cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:31a2b9a10530a1cb04ffd6aa1cd4d3be9ed49f7d77a4dafe198f3b382f41545c", size = 4152706, upload-time = "2025-08-05T23:59:20.044Z" },
-    { url = "https://files.pythonhosted.org/packages/81/ec/381b3e8d0685a3f3f304a382aa3dfce36af2d76467da0fd4bb21ddccc7b2/cryptography-45.0.6-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:e5b3dda1b00fb41da3af4c5ef3f922a200e33ee5ba0f0bc9ecf0b0c173958385", size = 4386740, upload-time = "2025-08-05T23:59:21.525Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/76/cf8d69da8d0b5ecb0db406f24a63a3f69ba5e791a11b782aeeefef27ccbb/cryptography-45.0.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:629127cfdcdc6806dfe234734d7cb8ac54edaf572148274fa377a7d3405b0043", size = 3331874, upload-time = "2025-08-05T23:59:23.017Z" },
-]
-
-[[package]]
-name = "distro"
-version = "1.9.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
-]
-
-[[package]]
-name = "e2b"
-version = "2.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs" },
-    { name = "httpcore" },
-    { name = "httpx" },
-    { name = "packaging" },
-    { name = "protobuf" },
-    { name = "python-dateutil" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ca/61/4cacf82b1d00f888678fdcfff23a8c3a09aed25b2993eea7af472e20dda5/e2b-2.0.0.tar.gz", hash = "sha256:4d033d937b0a09b8428e73233321a913cbaef8e7299fc731579c656e9d53a144", size = 66401, upload-time = "2025-08-21T15:50:40.207Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/92/76/ddf676a327006b9c3bdec1a10b99aad4f10af8b2cbc3358ebb156951914e/e2b-2.0.0-py3-none-any.whl", hash = "sha256:a6621b905cb2a883a9c520736ae98343a6184fc90c29b4f2f079d720294a0df0", size = 123785, upload-time = "2025-08-21T15:50:38.579Z" },
-]
-
-[[package]]
-name = "exceptiongroup"
-version = "1.3.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" },
-]
-
-[[package]]
-name = "frozenlist"
-version = "1.7.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/79/b1/b64018016eeb087db503b038296fd782586432b9c077fc5c7839e9cb6ef6/frozenlist-1.7.0.tar.gz", hash = "sha256:2e310d81923c2437ea8670467121cc3e9b0f76d3043cc1d2331d56c7fb7a3a8f", size = 45078, upload-time = "2025-06-09T23:02:35.538Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/af/36/0da0a49409f6b47cc2d060dc8c9040b897b5902a8a4e37d9bc1deb11f680/frozenlist-1.7.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cc4df77d638aa2ed703b878dd093725b72a824c3c546c076e8fdf276f78ee84a", size = 81304, upload-time = "2025-06-09T22:59:46.226Z" },
-    { url = "https://files.pythonhosted.org/packages/77/f0/77c11d13d39513b298e267b22eb6cb559c103d56f155aa9a49097221f0b6/frozenlist-1.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:716a9973a2cc963160394f701964fe25012600f3d311f60c790400b00e568b61", size = 47735, upload-time = "2025-06-09T22:59:48.133Z" },
-    { url = "https://files.pythonhosted.org/packages/37/12/9d07fa18971a44150593de56b2f2947c46604819976784bcf6ea0d5db43b/frozenlist-1.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a0fd1bad056a3600047fb9462cff4c5322cebc59ebf5d0a3725e0ee78955001d", size = 46775, upload-time = "2025-06-09T22:59:49.564Z" },
-    { url = "https://files.pythonhosted.org/packages/70/34/f73539227e06288fcd1f8a76853e755b2b48bca6747e99e283111c18bcd4/frozenlist-1.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3789ebc19cb811163e70fe2bd354cea097254ce6e707ae42e56f45e31e96cb8e", size = 224644, upload-time = "2025-06-09T22:59:51.35Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/68/c1d9c2f4a6e438e14613bad0f2973567586610cc22dcb1e1241da71de9d3/frozenlist-1.7.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:af369aa35ee34f132fcfad5be45fbfcde0e3a5f6a1ec0712857f286b7d20cca9", size = 222125, upload-time = "2025-06-09T22:59:52.884Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/d0/98e8f9a515228d708344d7c6986752be3e3192d1795f748c24bcf154ad99/frozenlist-1.7.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac64b6478722eeb7a3313d494f8342ef3478dff539d17002f849101b212ef97c", size = 233455, upload-time = "2025-06-09T22:59:54.74Z" },
-    { url = "https://files.pythonhosted.org/packages/79/df/8a11bcec5600557f40338407d3e5bea80376ed1c01a6c0910fcfdc4b8993/frozenlist-1.7.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f89f65d85774f1797239693cef07ad4c97fdd0639544bad9ac4b869782eb1981", size = 227339, upload-time = "2025-06-09T22:59:56.187Z" },
-    { url = "https://files.pythonhosted.org/packages/50/82/41cb97d9c9a5ff94438c63cc343eb7980dac4187eb625a51bdfdb7707314/frozenlist-1.7.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1073557c941395fdfcfac13eb2456cb8aad89f9de27bae29fabca8e563b12615", size = 212969, upload-time = "2025-06-09T22:59:57.604Z" },
-    { url = "https://files.pythonhosted.org/packages/13/47/f9179ee5ee4f55629e4f28c660b3fdf2775c8bfde8f9c53f2de2d93f52a9/frozenlist-1.7.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ed8d2fa095aae4bdc7fdd80351009a48d286635edffee66bf865e37a9125c50", size = 222862, upload-time = "2025-06-09T22:59:59.498Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/52/df81e41ec6b953902c8b7e3a83bee48b195cb0e5ec2eabae5d8330c78038/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:24c34bea555fe42d9f928ba0a740c553088500377448febecaa82cc3e88aa1fa", size = 222492, upload-time = "2025-06-09T23:00:01.026Z" },
-    { url = "https://files.pythonhosted.org/packages/84/17/30d6ea87fa95a9408245a948604b82c1a4b8b3e153cea596421a2aef2754/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:69cac419ac6a6baad202c85aaf467b65ac860ac2e7f2ac1686dc40dbb52f6577", size = 238250, upload-time = "2025-06-09T23:00:03.401Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/00/ecbeb51669e3c3df76cf2ddd66ae3e48345ec213a55e3887d216eb4fbab3/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:960d67d0611f4c87da7e2ae2eacf7ea81a5be967861e0c63cf205215afbfac59", size = 218720, upload-time = "2025-06-09T23:00:05.282Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/c0/c224ce0e0eb31cc57f67742071bb470ba8246623c1823a7530be0e76164c/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:41be2964bd4b15bf575e5daee5a5ce7ed3115320fb3c2b71fca05582ffa4dc9e", size = 232585, upload-time = "2025-06-09T23:00:07.962Z" },
-    { url = "https://files.pythonhosted.org/packages/55/3c/34cb694abf532f31f365106deebdeac9e45c19304d83cf7d51ebbb4ca4d1/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:46d84d49e00c9429238a7ce02dc0be8f6d7cd0cd405abd1bebdc991bf27c15bd", size = 234248, upload-time = "2025-06-09T23:00:09.428Z" },
-    { url = "https://files.pythonhosted.org/packages/98/c0/2052d8b6cecda2e70bd81299e3512fa332abb6dcd2969b9c80dfcdddbf75/frozenlist-1.7.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:15900082e886edb37480335d9d518cec978afc69ccbc30bd18610b7c1b22a718", size = 221621, upload-time = "2025-06-09T23:00:11.32Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/bf/7dcebae315436903b1d98ffb791a09d674c88480c158aa171958a3ac07f0/frozenlist-1.7.0-cp310-cp310-win32.whl", hash = "sha256:400ddd24ab4e55014bba442d917203c73b2846391dd42ca5e38ff52bb18c3c5e", size = 39578, upload-time = "2025-06-09T23:00:13.526Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/5f/f69818f017fa9a3d24d1ae39763e29b7f60a59e46d5f91b9c6b21622f4cd/frozenlist-1.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:6eb93efb8101ef39d32d50bce242c84bcbddb4f7e9febfa7b524532a239b4464", size = 43830, upload-time = "2025-06-09T23:00:14.98Z" },
-    { url = "https://files.pythonhosted.org/packages/34/7e/803dde33760128acd393a27eb002f2020ddb8d99d30a44bfbaab31c5f08a/frozenlist-1.7.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:aa51e147a66b2d74de1e6e2cf5921890de6b0f4820b257465101d7f37b49fb5a", size = 82251, upload-time = "2025-06-09T23:00:16.279Z" },
-    { url = "https://files.pythonhosted.org/packages/75/a9/9c2c5760b6ba45eae11334db454c189d43d34a4c0b489feb2175e5e64277/frozenlist-1.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9b35db7ce1cd71d36ba24f80f0c9e7cff73a28d7a74e91fe83e23d27c7828750", size = 48183, upload-time = "2025-06-09T23:00:17.698Z" },
-    { url = "https://files.pythonhosted.org/packages/47/be/4038e2d869f8a2da165f35a6befb9158c259819be22eeaf9c9a8f6a87771/frozenlist-1.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:34a69a85e34ff37791e94542065c8416c1afbf820b68f720452f636d5fb990cd", size = 47107, upload-time = "2025-06-09T23:00:18.952Z" },
-    { url = "https://files.pythonhosted.org/packages/79/26/85314b8a83187c76a37183ceed886381a5f992975786f883472fcb6dc5f2/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a646531fa8d82c87fe4bb2e596f23173caec9185bfbca5d583b4ccfb95183e2", size = 237333, upload-time = "2025-06-09T23:00:20.275Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/fd/e5b64f7d2c92a41639ffb2ad44a6a82f347787abc0c7df5f49057cf11770/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:79b2ffbba483f4ed36a0f236ccb85fbb16e670c9238313709638167670ba235f", size = 231724, upload-time = "2025-06-09T23:00:21.705Z" },
-    { url = "https://files.pythonhosted.org/packages/20/fb/03395c0a43a5976af4bf7534759d214405fbbb4c114683f434dfdd3128ef/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a26f205c9ca5829cbf82bb2a84b5c36f7184c4316617d7ef1b271a56720d6b30", size = 245842, upload-time = "2025-06-09T23:00:23.148Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/15/c01c8e1dffdac5d9803507d824f27aed2ba76b6ed0026fab4d9866e82f1f/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bcacfad3185a623fa11ea0e0634aac7b691aa925d50a440f39b458e41c561d98", size = 239767, upload-time = "2025-06-09T23:00:25.103Z" },
-    { url = "https://files.pythonhosted.org/packages/14/99/3f4c6fe882c1f5514b6848aa0a69b20cb5e5d8e8f51a339d48c0e9305ed0/frozenlist-1.7.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:72c1b0fe8fe451b34f12dce46445ddf14bd2a5bcad7e324987194dc8e3a74c86", size = 224130, upload-time = "2025-06-09T23:00:27.061Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/83/220a374bd7b2aeba9d0725130665afe11de347d95c3620b9b82cc2fcab97/frozenlist-1.7.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61d1a5baeaac6c0798ff6edfaeaa00e0e412d49946c53fae8d4b8e8b3566c4ae", size = 235301, upload-time = "2025-06-09T23:00:29.02Z" },
-    { url = "https://files.pythonhosted.org/packages/03/3c/3e3390d75334a063181625343e8daab61b77e1b8214802cc4e8a1bb678fc/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7edf5c043c062462f09b6820de9854bf28cc6cc5b6714b383149745e287181a8", size = 234606, upload-time = "2025-06-09T23:00:30.514Z" },
-    { url = "https://files.pythonhosted.org/packages/23/1e/58232c19608b7a549d72d9903005e2d82488f12554a32de2d5fb59b9b1ba/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:d50ac7627b3a1bd2dcef6f9da89a772694ec04d9a61b66cf87f7d9446b4a0c31", size = 248372, upload-time = "2025-06-09T23:00:31.966Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/a4/e4a567e01702a88a74ce8a324691e62a629bf47d4f8607f24bf1c7216e7f/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ce48b2fece5aeb45265bb7a58259f45027db0abff478e3077e12b05b17fb9da7", size = 229860, upload-time = "2025-06-09T23:00:33.375Z" },
-    { url = "https://files.pythonhosted.org/packages/73/a6/63b3374f7d22268b41a9db73d68a8233afa30ed164c46107b33c4d18ecdd/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:fe2365ae915a1fafd982c146754e1de6ab3478def8a59c86e1f7242d794f97d5", size = 245893, upload-time = "2025-06-09T23:00:35.002Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/eb/d18b3f6e64799a79673c4ba0b45e4cfbe49c240edfd03a68be20002eaeaa/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:45a6f2fdbd10e074e8814eb98b05292f27bad7d1883afbe009d96abdcf3bc898", size = 246323, upload-time = "2025-06-09T23:00:36.468Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/f5/720f3812e3d06cd89a1d5db9ff6450088b8f5c449dae8ffb2971a44da506/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:21884e23cffabb157a9dd7e353779077bf5b8f9a58e9b262c6caad2ef5f80a56", size = 233149, upload-time = "2025-06-09T23:00:37.963Z" },
-    { url = "https://files.pythonhosted.org/packages/69/68/03efbf545e217d5db8446acfd4c447c15b7c8cf4dbd4a58403111df9322d/frozenlist-1.7.0-cp311-cp311-win32.whl", hash = "sha256:284d233a8953d7b24f9159b8a3496fc1ddc00f4db99c324bd5fb5f22d8698ea7", size = 39565, upload-time = "2025-06-09T23:00:39.753Z" },
-    { url = "https://files.pythonhosted.org/packages/58/17/fe61124c5c333ae87f09bb67186d65038834a47d974fc10a5fadb4cc5ae1/frozenlist-1.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:387cbfdcde2f2353f19c2f66bbb52406d06ed77519ac7ee21be0232147c2592d", size = 44019, upload-time = "2025-06-09T23:00:40.988Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/a2/c8131383f1e66adad5f6ecfcce383d584ca94055a34d683bbb24ac5f2f1c/frozenlist-1.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3dbf9952c4bb0e90e98aec1bd992b3318685005702656bc6f67c1a32b76787f2", size = 81424, upload-time = "2025-06-09T23:00:42.24Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/9d/02754159955088cb52567337d1113f945b9e444c4960771ea90eb73de8db/frozenlist-1.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1f5906d3359300b8a9bb194239491122e6cf1444c2efb88865426f170c262cdb", size = 47952, upload-time = "2025-06-09T23:00:43.481Z" },
-    { url = "https://files.pythonhosted.org/packages/01/7a/0046ef1bd6699b40acd2067ed6d6670b4db2f425c56980fa21c982c2a9db/frozenlist-1.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3dabd5a8f84573c8d10d8859a50ea2dec01eea372031929871368c09fa103478", size = 46688, upload-time = "2025-06-09T23:00:44.793Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/a2/a910bafe29c86997363fb4c02069df4ff0b5bc39d33c5198b4e9dd42d8f8/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa57daa5917f1738064f302bf2626281a1cb01920c32f711fbc7bc36111058a8", size = 243084, upload-time = "2025-06-09T23:00:46.125Z" },
-    { url = "https://files.pythonhosted.org/packages/64/3e/5036af9d5031374c64c387469bfcc3af537fc0f5b1187d83a1cf6fab1639/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c193dda2b6d49f4c4398962810fa7d7c78f032bf45572b3e04dd5249dff27e08", size = 233524, upload-time = "2025-06-09T23:00:47.73Z" },
-    { url = "https://files.pythonhosted.org/packages/06/39/6a17b7c107a2887e781a48ecf20ad20f1c39d94b2a548c83615b5b879f28/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfe2b675cf0aaa6d61bf8fbffd3c274b3c9b7b1623beb3809df8a81399a4a9c4", size = 248493, upload-time = "2025-06-09T23:00:49.742Z" },
-    { url = "https://files.pythonhosted.org/packages/be/00/711d1337c7327d88c44d91dd0f556a1c47fb99afc060ae0ef66b4d24793d/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8fc5d5cda37f62b262405cf9652cf0856839c4be8ee41be0afe8858f17f4c94b", size = 244116, upload-time = "2025-06-09T23:00:51.352Z" },
-    { url = "https://files.pythonhosted.org/packages/24/fe/74e6ec0639c115df13d5850e75722750adabdc7de24e37e05a40527ca539/frozenlist-1.7.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b0d5ce521d1dd7d620198829b87ea002956e4319002ef0bc8d3e6d045cb4646e", size = 224557, upload-time = "2025-06-09T23:00:52.855Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/db/48421f62a6f77c553575201e89048e97198046b793f4a089c79a6e3268bd/frozenlist-1.7.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:488d0a7d6a0008ca0db273c542098a0fa9e7dfaa7e57f70acef43f32b3f69dca", size = 241820, upload-time = "2025-06-09T23:00:54.43Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/fa/cb4a76bea23047c8462976ea7b7a2bf53997a0ca171302deae9d6dd12096/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:15a7eaba63983d22c54d255b854e8108e7e5f3e89f647fc854bd77a237e767df", size = 236542, upload-time = "2025-06-09T23:00:56.409Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/32/476a4b5cfaa0ec94d3f808f193301debff2ea42288a099afe60757ef6282/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1eaa7e9c6d15df825bf255649e05bd8a74b04a4d2baa1ae46d9c2d00b2ca2cb5", size = 249350, upload-time = "2025-06-09T23:00:58.468Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/ba/9a28042f84a6bf8ea5dbc81cfff8eaef18d78b2a1ad9d51c7bc5b029ad16/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e4389e06714cfa9d47ab87f784a7c5be91d3934cd6e9a7b85beef808297cc025", size = 225093, upload-time = "2025-06-09T23:01:00.015Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/29/3a32959e68f9cf000b04e79ba574527c17e8842e38c91d68214a37455786/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:73bd45e1488c40b63fe5a7df892baf9e2a4d4bb6409a2b3b78ac1c6236178e01", size = 245482, upload-time = "2025-06-09T23:01:01.474Z" },
-    { url = "https://files.pythonhosted.org/packages/80/e8/edf2f9e00da553f07f5fa165325cfc302dead715cab6ac8336a5f3d0adc2/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99886d98e1643269760e5fe0df31e5ae7050788dd288947f7f007209b8c33f08", size = 249590, upload-time = "2025-06-09T23:01:02.961Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/80/9a0eb48b944050f94cc51ee1c413eb14a39543cc4f760ed12657a5a3c45a/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:290a172aae5a4c278c6da8a96222e6337744cd9c77313efe33d5670b9f65fc43", size = 237785, upload-time = "2025-06-09T23:01:05.095Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/74/87601e0fb0369b7a2baf404ea921769c53b7ae00dee7dcfe5162c8c6dbf0/frozenlist-1.7.0-cp312-cp312-win32.whl", hash = "sha256:426c7bc70e07cfebc178bc4c2bf2d861d720c4fff172181eeb4a4c41d4ca2ad3", size = 39487, upload-time = "2025-06-09T23:01:06.54Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/15/c026e9a9fc17585a9d461f65d8593d281fedf55fbf7eb53f16c6df2392f9/frozenlist-1.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:563b72efe5da92e02eb68c59cb37205457c977aa7a449ed1b37e6939e5c47c6a", size = 43874, upload-time = "2025-06-09T23:01:07.752Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/45/b82e3c16be2182bff01179db177fe144d58b5dc787a7d4492c6ed8b9317f/frozenlist-1.7.0-py3-none-any.whl", hash = "sha256:9a5af342e34f7e97caf8c995864c7a396418ae2859cc6fdf1b1073020d516a7e", size = 13106, upload-time = "2025-06-09T23:02:34.204Z" },
-]
-
-[[package]]
-name = "googleapis-common-protos"
-version = "1.70.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/39/24/33db22342cf4a2ea27c9955e6713140fedd51e8b141b5ce5260897020f1a/googleapis_common_protos-1.70.0.tar.gz", hash = "sha256:0e1b44e0ea153e6594f9f394fef15193a68aaaea2d843f83e2742717ca753257", size = 145903, upload-time = "2025-04-14T10:17:02.924Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/86/f1/62a193f0227cf15a920390abe675f386dec35f7ae3ffe6da582d3ade42c7/googleapis_common_protos-1.70.0-py3-none-any.whl", hash = "sha256:b8bfcca8c25a2bb253e0e0b0adaf8c00773e5e6af6fd92397576680b807e0fd8", size = 294530, upload-time = "2025-04-14T10:17:01.271Z" },
-]
-
-[[package]]
-name = "greenlet"
-version = "3.2.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/03/b8/704d753a5a45507a7aab61f18db9509302ed3d0a27ac7e0359ec2905b1a6/greenlet-3.2.4.tar.gz", hash = "sha256:0dca0d95ff849f9a364385f36ab49f50065d76964944638be9691e1832e9f86d", size = 188260, upload-time = "2025-08-07T13:24:33.51Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7d/ed/6bfa4109fcb23a58819600392564fea69cdc6551ffd5e69ccf1d52a40cbc/greenlet-3.2.4-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:8c68325b0d0acf8d91dde4e6f930967dd52a5302cd4062932a6b2e7c2969f47c", size = 271061, upload-time = "2025-08-07T13:17:15.373Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/fc/102ec1a2fc015b3a7652abab7acf3541d58c04d3d17a8d3d6a44adae1eb1/greenlet-3.2.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:94385f101946790ae13da500603491f04a76b6e4c059dab271b3ce2e283b2590", size = 629475, upload-time = "2025-08-07T13:42:54.009Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/26/80383131d55a4ac0fb08d71660fd77e7660b9db6bdb4e8884f46d9f2cc04/greenlet-3.2.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f10fd42b5ee276335863712fa3da6608e93f70629c631bf77145021600abc23c", size = 640802, upload-time = "2025-08-07T13:45:25.52Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/7c/e7833dbcd8f376f3326bd728c845d31dcde4c84268d3921afcae77d90d08/greenlet-3.2.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:c8c9e331e58180d0d83c5b7999255721b725913ff6bc6cf39fa2a45841a4fd4b", size = 636703, upload-time = "2025-08-07T13:53:12.622Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/49/547b93b7c0428ede7b3f309bc965986874759f7d89e4e04aeddbc9699acb/greenlet-3.2.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58b97143c9cc7b86fc458f215bd0932f1757ce649e05b640fea2e79b54cedb31", size = 635417, upload-time = "2025-08-07T13:18:25.189Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/91/ae2eb6b7979e2f9b035a9f612cf70f1bf54aad4e1d125129bef1eae96f19/greenlet-3.2.4-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c2ca18a03a8cfb5b25bc1cbe20f3d9a4c80d8c3b13ba3df49ac3961af0b1018d", size = 584358, upload-time = "2025-08-07T13:18:23.708Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/85/433de0c9c0252b22b16d413c9407e6cb3b41df7389afc366ca204dbc1393/greenlet-3.2.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9fe0a28a7b952a21e2c062cd5756d34354117796c6d9215a87f55e38d15402c5", size = 1113550, upload-time = "2025-08-07T13:42:37.467Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/8d/88f3ebd2bc96bf7747093696f4335a0a8a4c5acfcf1b757717c0d2474ba3/greenlet-3.2.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8854167e06950ca75b898b104b63cc646573aa5fef1353d4508ecdd1ee76254f", size = 1137126, upload-time = "2025-08-07T13:18:20.239Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/6f/b60b0291d9623c496638c582297ead61f43c4b72eef5e9c926ef4565ec13/greenlet-3.2.4-cp310-cp310-win_amd64.whl", hash = "sha256:73f49b5368b5359d04e18d15828eecc1806033db5233397748f4ca813ff1056c", size = 298654, upload-time = "2025-08-07T13:50:00.469Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/de/f28ced0a67749cac23fecb02b694f6473f47686dff6afaa211d186e2ef9c/greenlet-3.2.4-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:96378df1de302bc38e99c3a9aa311967b7dc80ced1dcc6f171e99842987882a2", size = 272305, upload-time = "2025-08-07T13:15:41.288Z" },
-    { url = "https://files.pythonhosted.org/packages/09/16/2c3792cba130000bf2a31c5272999113f4764fd9d874fb257ff588ac779a/greenlet-3.2.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1ee8fae0519a337f2329cb78bd7a8e128ec0f881073d43f023c7b8d4831d5246", size = 632472, upload-time = "2025-08-07T13:42:55.044Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/8f/95d48d7e3d433e6dae5b1682e4292242a53f22df82e6d3dda81b1701a960/greenlet-3.2.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:94abf90142c2a18151632371140b3dba4dee031633fe614cb592dbb6c9e17bc3", size = 644646, upload-time = "2025-08-07T13:45:26.523Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/5e/405965351aef8c76b8ef7ad370e5da58d57ef6068df197548b015464001a/greenlet-3.2.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:4d1378601b85e2e5171b99be8d2dc85f594c79967599328f95c1dc1a40f1c633", size = 640519, upload-time = "2025-08-07T13:53:13.928Z" },
-    { url = "https://files.pythonhosted.org/packages/25/5d/382753b52006ce0218297ec1b628e048c4e64b155379331f25a7316eb749/greenlet-3.2.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0db5594dce18db94f7d1650d7489909b57afde4c580806b8d9203b6e79cdc079", size = 639707, upload-time = "2025-08-07T13:18:27.146Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/8e/abdd3f14d735b2929290a018ecf133c901be4874b858dd1c604b9319f064/greenlet-3.2.4-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2523e5246274f54fdadbce8494458a2ebdcdbc7b802318466ac5606d3cded1f8", size = 587684, upload-time = "2025-08-07T13:18:25.164Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/65/deb2a69c3e5996439b0176f6651e0052542bb6c8f8ec2e3fba97c9768805/greenlet-3.2.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1987de92fec508535687fb807a5cea1560f6196285a4cde35c100b8cd632cc52", size = 1116647, upload-time = "2025-08-07T13:42:38.655Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/cc/b07000438a29ac5cfb2194bfc128151d52f333cee74dd7dfe3fb733fc16c/greenlet-3.2.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:55e9c5affaa6775e2c6b67659f3a71684de4c549b3dd9afca3bc773533d284fa", size = 1142073, upload-time = "2025-08-07T13:18:21.737Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/0f/30aef242fcab550b0b3520b8e3561156857c94288f0332a79928c31a52cf/greenlet-3.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:9c40adce87eaa9ddb593ccb0fa6a07caf34015a29bf8d344811665b573138db9", size = 299100, upload-time = "2025-08-07T13:44:12.287Z" },
-    { url = "https://files.pythonhosted.org/packages/44/69/9b804adb5fd0671f367781560eb5eb586c4d495277c93bde4307b9e28068/greenlet-3.2.4-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3b67ca49f54cede0186854a008109d6ee71f66bd57bb36abd6d0a0267b540cdd", size = 274079, upload-time = "2025-08-07T13:15:45.033Z" },
-    { url = "https://files.pythonhosted.org/packages/46/e9/d2a80c99f19a153eff70bc451ab78615583b8dac0754cfb942223d2c1a0d/greenlet-3.2.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddf9164e7a5b08e9d22511526865780a576f19ddd00d62f8a665949327fde8bb", size = 640997, upload-time = "2025-08-07T13:42:56.234Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/16/035dcfcc48715ccd345f3a93183267167cdd162ad123cd93067d86f27ce4/greenlet-3.2.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f28588772bb5fb869a8eb331374ec06f24a83a9c25bfa1f38b6993afe9c1e968", size = 655185, upload-time = "2025-08-07T13:45:27.624Z" },
-    { url = "https://files.pythonhosted.org/packages/31/da/0386695eef69ffae1ad726881571dfe28b41970173947e7c558d9998de0f/greenlet-3.2.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:5c9320971821a7cb77cfab8d956fa8e39cd07ca44b6070db358ceb7f8797c8c9", size = 649926, upload-time = "2025-08-07T13:53:15.251Z" },
-    { url = "https://files.pythonhosted.org/packages/68/88/69bf19fd4dc19981928ceacbc5fd4bb6bc2215d53199e367832e98d1d8fe/greenlet-3.2.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c60a6d84229b271d44b70fb6e5fa23781abb5d742af7b808ae3f6efd7c9c60f6", size = 651839, upload-time = "2025-08-07T13:18:30.281Z" },
-    { url = "https://files.pythonhosted.org/packages/19/0d/6660d55f7373b2ff8152401a83e02084956da23ae58cddbfb0b330978fe9/greenlet-3.2.4-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b3812d8d0c9579967815af437d96623f45c0f2ae5f04e366de62a12d83a8fb0", size = 607586, upload-time = "2025-08-07T13:18:28.544Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/1a/c953fdedd22d81ee4629afbb38d2f9d71e37d23caace44775a3a969147d4/greenlet-3.2.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:abbf57b5a870d30c4675928c37278493044d7c14378350b3aa5d484fa65575f0", size = 1123281, upload-time = "2025-08-07T13:42:39.858Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/c7/12381b18e21aef2c6bd3a636da1088b888b97b7a0362fac2e4de92405f97/greenlet-3.2.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:20fb936b4652b6e307b8f347665e2c615540d4b42b3b4c8a321d8286da7e520f", size = 1151142, upload-time = "2025-08-07T13:18:22.981Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/08/b0814846b79399e585f974bbeebf5580fbe59e258ea7be64d9dfb253c84f/greenlet-3.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:a7d4e128405eea3814a12cc2605e0e6aedb4035bf32697f72deca74de4105e02", size = 299899, upload-time = "2025-08-07T13:38:53.448Z" },
-]
-
-[[package]]
-name = "griffe"
-version = "1.12.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/81/ca/29f36e00c74844ae50d139cf5a8b1751887b2f4d5023af65d460268ad7aa/griffe-1.12.1.tar.gz", hash = "sha256:29f5a6114c0aeda7d9c86a570f736883f8a2c5b38b57323d56b3d1c000565567", size = 411863, upload-time = "2025-08-14T21:08:15.38Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/13/f2/4fab6c3e5bcaf38a44cc8a974d2752eaad4c129e45d6533d926a30edd133/griffe-1.12.1-py3-none-any.whl", hash = "sha256:2d7c12334de00089c31905424a00abcfd931b45b8b516967f224133903d302cc", size = 138940, upload-time = "2025-08-14T21:08:13.382Z" },
-]
-
-[[package]]
-name = "grpcio"
-version = "1.74.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/38/b4/35feb8f7cab7239c5b94bd2db71abb3d6adb5f335ad8f131abb6060840b6/grpcio-1.74.0.tar.gz", hash = "sha256:80d1f4fbb35b0742d3e3d3bb654b7381cd5f015f8497279a1e9c21ba623e01b1", size = 12756048, upload-time = "2025-07-24T18:54:23.039Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/54/68e51a90797ad7afc5b0a7881426c337f6a9168ebab73c3210b76aa7c90d/grpcio-1.74.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:85bd5cdf4ed7b2d6438871adf6afff9af7096486fcf51818a81b77ef4dd30907", size = 5481935, upload-time = "2025-07-24T18:52:43.756Z" },
-    { url = "https://files.pythonhosted.org/packages/32/2a/af817c7e9843929e93e54d09c9aee2555c2e8d81b93102a9426b36e91833/grpcio-1.74.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:68c8ebcca945efff9d86d8d6d7bfb0841cf0071024417e2d7f45c5e46b5b08eb", size = 10986796, upload-time = "2025-07-24T18:52:47.219Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/94/d67756638d7bb07750b07d0826c68e414124574b53840ba1ff777abcd388/grpcio-1.74.0-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:e154d230dc1bbbd78ad2fdc3039fa50ad7ffcf438e4eb2fa30bce223a70c7486", size = 5983663, upload-time = "2025-07-24T18:52:49.463Z" },
-    { url = "https://files.pythonhosted.org/packages/35/f5/c5e4853bf42148fea8532d49e919426585b73eafcf379a712934652a8de9/grpcio-1.74.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e8978003816c7b9eabe217f88c78bc26adc8f9304bf6a594b02e5a49b2ef9c11", size = 6653765, upload-time = "2025-07-24T18:52:51.094Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/75/a1991dd64b331d199935e096cc9daa3415ee5ccbe9f909aa48eded7bba34/grpcio-1.74.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3d7bd6e3929fd2ea7fbc3f562e4987229ead70c9ae5f01501a46701e08f1ad9", size = 6215172, upload-time = "2025-07-24T18:52:53.282Z" },
-    { url = "https://files.pythonhosted.org/packages/01/a4/7cef3dbb3b073d0ce34fd507efc44ac4c9442a0ef9fba4fb3f5c551efef5/grpcio-1.74.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:136b53c91ac1d02c8c24201bfdeb56f8b3ac3278668cbb8e0ba49c88069e1bdc", size = 6329142, upload-time = "2025-07-24T18:52:54.927Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/d3/587920f882b46e835ad96014087054655312400e2f1f1446419e5179a383/grpcio-1.74.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:fe0f540750a13fd8e5da4b3eaba91a785eea8dca5ccd2bc2ffe978caa403090e", size = 7018632, upload-time = "2025-07-24T18:52:56.523Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/95/c70a3b15a0bc83334b507e3d2ae20ee8fa38d419b8758a4d838f5c2a7d32/grpcio-1.74.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4e4181bfc24413d1e3a37a0b7889bea68d973d4b45dd2bc68bb766c140718f82", size = 6509641, upload-time = "2025-07-24T18:52:58.495Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/06/2e7042d06247d668ae69ea6998eca33f475fd4e2855f94dcb2aa5daef334/grpcio-1.74.0-cp310-cp310-win32.whl", hash = "sha256:1733969040989f7acc3d94c22f55b4a9501a30f6aaacdbccfaba0a3ffb255ab7", size = 3817478, upload-time = "2025-07-24T18:53:00.128Z" },
-    { url = "https://files.pythonhosted.org/packages/93/20/e02b9dcca3ee91124060b65bbf5b8e1af80b3b76a30f694b44b964ab4d71/grpcio-1.74.0-cp310-cp310-win_amd64.whl", hash = "sha256:9e912d3c993a29df6c627459af58975b2e5c897d93287939b9d5065f000249b5", size = 4493971, upload-time = "2025-07-24T18:53:02.068Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/77/b2f06db9f240a5abeddd23a0e49eae2b6ac54d85f0e5267784ce02269c3b/grpcio-1.74.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:69e1a8180868a2576f02356565f16635b99088da7df3d45aaa7e24e73a054e31", size = 5487368, upload-time = "2025-07-24T18:53:03.548Z" },
-    { url = "https://files.pythonhosted.org/packages/48/99/0ac8678a819c28d9a370a663007581744a9f2a844e32f0fa95e1ddda5b9e/grpcio-1.74.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:8efe72fde5500f47aca1ef59495cb59c885afe04ac89dd11d810f2de87d935d4", size = 10999804, upload-time = "2025-07-24T18:53:05.095Z" },
-    { url = "https://files.pythonhosted.org/packages/45/c6/a2d586300d9e14ad72e8dc211c7aecb45fe9846a51e558c5bca0c9102c7f/grpcio-1.74.0-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:a8f0302f9ac4e9923f98d8e243939a6fb627cd048f5cd38595c97e38020dffce", size = 5987667, upload-time = "2025-07-24T18:53:07.157Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/57/5f338bf56a7f22584e68d669632e521f0de460bb3749d54533fc3d0fca4f/grpcio-1.74.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2f609a39f62a6f6f05c7512746798282546358a37ea93c1fcbadf8b2fed162e3", size = 6655612, upload-time = "2025-07-24T18:53:09.244Z" },
-    { url = "https://files.pythonhosted.org/packages/82/ea/a4820c4c44c8b35b1903a6c72a5bdccec92d0840cf5c858c498c66786ba5/grpcio-1.74.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c98e0b7434a7fa4e3e63f250456eaef52499fba5ae661c58cc5b5477d11e7182", size = 6219544, upload-time = "2025-07-24T18:53:11.221Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/17/0537630a921365928f5abb6d14c79ba4dcb3e662e0dbeede8af4138d9dcf/grpcio-1.74.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:662456c4513e298db6d7bd9c3b8df6f75f8752f0ba01fb653e252ed4a59b5a5d", size = 6334863, upload-time = "2025-07-24T18:53:12.925Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/a6/85ca6cb9af3f13e1320d0a806658dca432ff88149d5972df1f7b51e87127/grpcio-1.74.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:3d14e3c4d65e19d8430a4e28ceb71ace4728776fd6c3ce34016947474479683f", size = 7019320, upload-time = "2025-07-24T18:53:15.002Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/a7/fe2beab970a1e25d2eff108b3cf4f7d9a53c185106377a3d1989216eba45/grpcio-1.74.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1bf949792cee20d2078323a9b02bacbbae002b9e3b9e2433f2741c15bdeba1c4", size = 6514228, upload-time = "2025-07-24T18:53:16.999Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/c2/2f9c945c8a248cebc3ccda1b7a1bf1775b9d7d59e444dbb18c0014e23da6/grpcio-1.74.0-cp311-cp311-win32.whl", hash = "sha256:55b453812fa7c7ce2f5c88be3018fb4a490519b6ce80788d5913f3f9d7da8c7b", size = 3817216, upload-time = "2025-07-24T18:53:20.564Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/d1/a9cf9c94b55becda2199299a12b9feef0c79946b0d9d34c989de6d12d05d/grpcio-1.74.0-cp311-cp311-win_amd64.whl", hash = "sha256:86ad489db097141a907c559988c29718719aa3e13370d40e20506f11b4de0d11", size = 4495380, upload-time = "2025-07-24T18:53:22.058Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/5d/e504d5d5c4469823504f65687d6c8fb97b7f7bf0b34873b7598f1df24630/grpcio-1.74.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:8533e6e9c5bd630ca98062e3a1326249e6ada07d05acf191a77bc33f8948f3d8", size = 5445551, upload-time = "2025-07-24T18:53:23.641Z" },
-    { url = "https://files.pythonhosted.org/packages/43/01/730e37056f96f2f6ce9f17999af1556df62ee8dab7fa48bceeaab5fd3008/grpcio-1.74.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:2918948864fec2a11721d91568effffbe0a02b23ecd57f281391d986847982f6", size = 10979810, upload-time = "2025-07-24T18:53:25.349Z" },
-    { url = "https://files.pythonhosted.org/packages/79/3d/09fd100473ea5c47083889ca47ffd356576173ec134312f6aa0e13111dee/grpcio-1.74.0-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:60d2d48b0580e70d2e1954d0d19fa3c2e60dd7cbed826aca104fff518310d1c5", size = 5941946, upload-time = "2025-07-24T18:53:27.387Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/99/12d2cca0a63c874c6d3d195629dcd85cdf5d6f98a30d8db44271f8a97b93/grpcio-1.74.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3601274bc0523f6dc07666c0e01682c94472402ac2fd1226fd96e079863bfa49", size = 6621763, upload-time = "2025-07-24T18:53:29.193Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/2c/930b0e7a2f1029bbc193443c7bc4dc2a46fedb0203c8793dcd97081f1520/grpcio-1.74.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:176d60a5168d7948539def20b2a3adcce67d72454d9ae05969a2e73f3a0feee7", size = 6180664, upload-time = "2025-07-24T18:53:30.823Z" },
-    { url = "https://files.pythonhosted.org/packages/db/d5/ff8a2442180ad0867717e670f5ec42bfd8d38b92158ad6bcd864e6d4b1ed/grpcio-1.74.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e759f9e8bc908aaae0412642afe5416c9f983a80499448fcc7fab8692ae044c3", size = 6301083, upload-time = "2025-07-24T18:53:32.454Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/ba/b361d390451a37ca118e4ec7dccec690422e05bc85fba2ec72b06cefec9f/grpcio-1.74.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:9e7c4389771855a92934b2846bd807fc25a3dfa820fd912fe6bd8136026b2707", size = 6994132, upload-time = "2025-07-24T18:53:34.506Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/0c/3a5fa47d2437a44ced74141795ac0251bbddeae74bf81df3447edd767d27/grpcio-1.74.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:cce634b10aeab37010449124814b05a62fb5f18928ca878f1bf4750d1f0c815b", size = 6489616, upload-time = "2025-07-24T18:53:36.217Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/95/ab64703b436d99dc5217228babc76047d60e9ad14df129e307b5fec81fd0/grpcio-1.74.0-cp312-cp312-win32.whl", hash = "sha256:885912559974df35d92219e2dc98f51a16a48395f37b92865ad45186f294096c", size = 3807083, upload-time = "2025-07-24T18:53:37.911Z" },
-    { url = "https://files.pythonhosted.org/packages/84/59/900aa2445891fc47a33f7d2f76e00ca5d6ae6584b20d19af9c06fa09bf9a/grpcio-1.74.0-cp312-cp312-win_amd64.whl", hash = "sha256:42f8fee287427b94be63d916c90399ed310ed10aadbf9e2e5538b3e497d269bc", size = 4490123, upload-time = "2025-07-24T18:53:39.528Z" },
-]
-
-[[package]]
-name = "h11"
-version = "0.16.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
-]
-
-[[package]]
-name = "httpcore"
-version = "1.0.9"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "h11" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
-]
-
-[[package]]
-name = "httpx"
-version = "0.28.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "certifi" },
-    { name = "httpcore" },
-    { name = "idna" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
-]
-
-[[package]]
-name = "httpx-sse"
-version = "0.4.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6e/fa/66bd985dd0b7c109a3bcb89272ee0bfb7e2b4d06309ad7b38ff866734b2a/httpx_sse-0.4.1.tar.gz", hash = "sha256:8f44d34414bc7b21bf3602713005c5df4917884f76072479b21f68befa4ea26e", size = 12998, upload-time = "2025-06-24T13:21:05.71Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/25/0a/6269e3473b09aed2dab8aa1a600c70f31f00ae1349bee30658f7e358a159/httpx_sse-0.4.1-py3-none-any.whl", hash = "sha256:cba42174344c3a5b06f255ce65b350880f962d99ead85e776f23c6618a377a37", size = 8054, upload-time = "2025-06-24T13:21:04.772Z" },
-]
-
-[[package]]
-name = "idna"
-version = "3.10"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },
-]
-
-[[package]]
-name = "importlib-metadata"
-version = "8.7.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" },
-]
-
-[[package]]
-name = "jiter"
-version = "0.10.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ee/9d/ae7ddb4b8ab3fb1b51faf4deb36cb48a4fbbd7cb36bad6a5fca4741306f7/jiter-0.10.0.tar.gz", hash = "sha256:07a7142c38aacc85194391108dc91b5b57093c978a9932bd86a36862759d9500", size = 162759, upload-time = "2025-05-18T19:04:59.73Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/7e/4011b5c77bec97cb2b572f566220364e3e21b51c48c5bd9c4a9c26b41b67/jiter-0.10.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:cd2fb72b02478f06a900a5782de2ef47e0396b3e1f7d5aba30daeb1fce66f303", size = 317215, upload-time = "2025-05-18T19:03:04.303Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/4f/144c1b57c39692efc7ea7d8e247acf28e47d0912800b34d0ad815f6b2824/jiter-0.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:32bb468e3af278f095d3fa5b90314728a6916d89ba3d0ffb726dd9bf7367285e", size = 322814, upload-time = "2025-05-18T19:03:06.433Z" },
-    { url = "https://files.pythonhosted.org/packages/63/1f/db977336d332a9406c0b1f0b82be6f71f72526a806cbb2281baf201d38e3/jiter-0.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa8b3e0068c26ddedc7abc6fac37da2d0af16b921e288a5a613f4b86f050354f", size = 345237, upload-time = "2025-05-18T19:03:07.833Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/1c/aa30a4a775e8a672ad7f21532bdbfb269f0706b39c6ff14e1f86bdd9e5ff/jiter-0.10.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:286299b74cc49e25cd42eea19b72aa82c515d2f2ee12d11392c56d8701f52224", size = 370999, upload-time = "2025-05-18T19:03:09.338Z" },
-    { url = "https://files.pythonhosted.org/packages/35/df/f8257abc4207830cb18880781b5f5b716bad5b2a22fb4330cfd357407c5b/jiter-0.10.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6ed5649ceeaeffc28d87fb012d25a4cd356dcd53eff5acff1f0466b831dda2a7", size = 491109, upload-time = "2025-05-18T19:03:11.13Z" },
-    { url = "https://files.pythonhosted.org/packages/06/76/9e1516fd7b4278aa13a2cc7f159e56befbea9aa65c71586305e7afa8b0b3/jiter-0.10.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2ab0051160cb758a70716448908ef14ad476c3774bd03ddce075f3c1f90a3d6", size = 388608, upload-time = "2025-05-18T19:03:12.911Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/64/67750672b4354ca20ca18d3d1ccf2c62a072e8a2d452ac3cf8ced73571ef/jiter-0.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03997d2f37f6b67d2f5c475da4412be584e1cec273c1cfc03d642c46db43f8cf", size = 352454, upload-time = "2025-05-18T19:03:14.741Z" },
-    { url = "https://files.pythonhosted.org/packages/96/4d/5c4e36d48f169a54b53a305114be3efa2bbffd33b648cd1478a688f639c1/jiter-0.10.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c404a99352d839fed80d6afd6c1d66071f3bacaaa5c4268983fc10f769112e90", size = 391833, upload-time = "2025-05-18T19:03:16.426Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/de/ce4a6166a78810bd83763d2fa13f85f73cbd3743a325469a4a9289af6dae/jiter-0.10.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:66e989410b6666d3ddb27a74c7e50d0829704ede652fd4c858e91f8d64b403d0", size = 523646, upload-time = "2025-05-18T19:03:17.704Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/a6/3bc9acce53466972964cf4ad85efecb94f9244539ab6da1107f7aed82934/jiter-0.10.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b532d3af9ef4f6374609a3bcb5e05a1951d3bf6190dc6b176fdb277c9bbf15ee", size = 514735, upload-time = "2025-05-18T19:03:19.44Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/d8/243c2ab8426a2a4dea85ba2a2ba43df379ccece2145320dfd4799b9633c5/jiter-0.10.0-cp310-cp310-win32.whl", hash = "sha256:da9be20b333970e28b72edc4dff63d4fec3398e05770fb3205f7fb460eb48dd4", size = 210747, upload-time = "2025-05-18T19:03:21.184Z" },
-    { url = "https://files.pythonhosted.org/packages/37/7a/8021bd615ef7788b98fc76ff533eaac846322c170e93cbffa01979197a45/jiter-0.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:f59e533afed0c5b0ac3eba20d2548c4a550336d8282ee69eb07b37ea526ee4e5", size = 207484, upload-time = "2025-05-18T19:03:23.046Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/dd/6cefc6bd68b1c3c979cecfa7029ab582b57690a31cd2f346c4d0ce7951b6/jiter-0.10.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3bebe0c558e19902c96e99217e0b8e8b17d570906e72ed8a87170bc290b1e978", size = 317473, upload-time = "2025-05-18T19:03:25.942Z" },
-    { url = "https://files.pythonhosted.org/packages/be/cf/fc33f5159ce132be1d8dd57251a1ec7a631c7df4bd11e1cd198308c6ae32/jiter-0.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:558cc7e44fd8e507a236bee6a02fa17199ba752874400a0ca6cd6e2196cdb7dc", size = 321971, upload-time = "2025-05-18T19:03:27.255Z" },
-    { url = "https://files.pythonhosted.org/packages/68/a4/da3f150cf1d51f6c472616fb7650429c7ce053e0c962b41b68557fdf6379/jiter-0.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d613e4b379a07d7c8453c5712ce7014e86c6ac93d990a0b8e7377e18505e98d", size = 345574, upload-time = "2025-05-18T19:03:28.63Z" },
-    { url = "https://files.pythonhosted.org/packages/84/34/6e8d412e60ff06b186040e77da5f83bc158e9735759fcae65b37d681f28b/jiter-0.10.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f62cf8ba0618eda841b9bf61797f21c5ebd15a7a1e19daab76e4e4b498d515b2", size = 371028, upload-time = "2025-05-18T19:03:30.292Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/d9/9ee86173aae4576c35a2f50ae930d2ccb4c4c236f6cb9353267aa1d626b7/jiter-0.10.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:919d139cdfa8ae8945112398511cb7fca58a77382617d279556b344867a37e61", size = 491083, upload-time = "2025-05-18T19:03:31.654Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/2c/f955de55e74771493ac9e188b0f731524c6a995dffdcb8c255b89c6fb74b/jiter-0.10.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:13ddbc6ae311175a3b03bd8994881bc4635c923754932918e18da841632349db", size = 388821, upload-time = "2025-05-18T19:03:33.184Z" },
-    { url = "https://files.pythonhosted.org/packages/81/5a/0e73541b6edd3f4aada586c24e50626c7815c561a7ba337d6a7eb0a915b4/jiter-0.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c440ea003ad10927a30521a9062ce10b5479592e8a70da27f21eeb457b4a9c5", size = 352174, upload-time = "2025-05-18T19:03:34.965Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/c0/61eeec33b8c75b31cae42be14d44f9e6fe3ac15a4e58010256ac3abf3638/jiter-0.10.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dc347c87944983481e138dea467c0551080c86b9d21de6ea9306efb12ca8f606", size = 391869, upload-time = "2025-05-18T19:03:36.436Z" },
-    { url = "https://files.pythonhosted.org/packages/41/22/5beb5ee4ad4ef7d86f5ea5b4509f680a20706c4a7659e74344777efb7739/jiter-0.10.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:13252b58c1f4d8c5b63ab103c03d909e8e1e7842d302473f482915d95fefd605", size = 523741, upload-time = "2025-05-18T19:03:38.168Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/10/768e8818538e5817c637b0df52e54366ec4cebc3346108a4457ea7a98f32/jiter-0.10.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7d1bbf3c465de4a24ab12fb7766a0003f6f9bce48b8b6a886158c4d569452dc5", size = 514527, upload-time = "2025-05-18T19:03:39.577Z" },
-    { url = "https://files.pythonhosted.org/packages/73/6d/29b7c2dc76ce93cbedabfd842fc9096d01a0550c52692dfc33d3cc889815/jiter-0.10.0-cp311-cp311-win32.whl", hash = "sha256:db16e4848b7e826edca4ccdd5b145939758dadf0dc06e7007ad0e9cfb5928ae7", size = 210765, upload-time = "2025-05-18T19:03:41.271Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/c9/d394706deb4c660137caf13e33d05a031d734eb99c051142e039d8ceb794/jiter-0.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:9c9c1d5f10e18909e993f9641f12fe1c77b3e9b533ee94ffa970acc14ded3812", size = 209234, upload-time = "2025-05-18T19:03:42.918Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/b5/348b3313c58f5fbfb2194eb4d07e46a35748ba6e5b3b3046143f3040bafa/jiter-0.10.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:1e274728e4a5345a6dde2d343c8da018b9d4bd4350f5a472fa91f66fda44911b", size = 312262, upload-time = "2025-05-18T19:03:44.637Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/4a/6a2397096162b21645162825f058d1709a02965606e537e3304b02742e9b/jiter-0.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7202ae396446c988cb2a5feb33a543ab2165b786ac97f53b59aafb803fef0744", size = 320124, upload-time = "2025-05-18T19:03:46.341Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/85/1ce02cade7516b726dd88f59a4ee46914bf79d1676d1228ef2002ed2f1c9/jiter-0.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23ba7722d6748b6920ed02a8f1726fb4b33e0fd2f3f621816a8b486c66410ab2", size = 345330, upload-time = "2025-05-18T19:03:47.596Z" },
-    { url = "https://files.pythonhosted.org/packages/75/d0/bb6b4f209a77190ce10ea8d7e50bf3725fc16d3372d0a9f11985a2b23eff/jiter-0.10.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:371eab43c0a288537d30e1f0b193bc4eca90439fc08a022dd83e5e07500ed026", size = 369670, upload-time = "2025-05-18T19:03:49.334Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/f5/a61787da9b8847a601e6827fbc42ecb12be2c925ced3252c8ffcb56afcaf/jiter-0.10.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c675736059020365cebc845a820214765162728b51ab1e03a1b7b3abb70f74c", size = 489057, upload-time = "2025-05-18T19:03:50.66Z" },
-    { url = "https://files.pythonhosted.org/packages/12/e4/6f906272810a7b21406c760a53aadbe52e99ee070fc5c0cb191e316de30b/jiter-0.10.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0c5867d40ab716e4684858e4887489685968a47e3ba222e44cde6e4a2154f959", size = 389372, upload-time = "2025-05-18T19:03:51.98Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/ba/77013b0b8ba904bf3762f11e0129b8928bff7f978a81838dfcc958ad5728/jiter-0.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:395bb9a26111b60141757d874d27fdea01b17e8fac958b91c20128ba8f4acc8a", size = 352038, upload-time = "2025-05-18T19:03:53.703Z" },
-    { url = "https://files.pythonhosted.org/packages/67/27/c62568e3ccb03368dbcc44a1ef3a423cb86778a4389e995125d3d1aaa0a4/jiter-0.10.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6842184aed5cdb07e0c7e20e5bdcfafe33515ee1741a6835353bb45fe5d1bd95", size = 391538, upload-time = "2025-05-18T19:03:55.046Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/72/0d6b7e31fc17a8fdce76164884edef0698ba556b8eb0af9546ae1a06b91d/jiter-0.10.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:62755d1bcea9876770d4df713d82606c8c1a3dca88ff39046b85a048566d56ea", size = 523557, upload-time = "2025-05-18T19:03:56.386Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/09/bc1661fbbcbeb6244bd2904ff3a06f340aa77a2b94e5a7373fd165960ea3/jiter-0.10.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:533efbce2cacec78d5ba73a41756beff8431dfa1694b6346ce7af3a12c42202b", size = 514202, upload-time = "2025-05-18T19:03:57.675Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/84/5a5d5400e9d4d54b8004c9673bbe4403928a00d28529ff35b19e9d176b19/jiter-0.10.0-cp312-cp312-win32.whl", hash = "sha256:8be921f0cadd245e981b964dfbcd6fd4bc4e254cdc069490416dd7a2632ecc01", size = 211781, upload-time = "2025-05-18T19:03:59.025Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/52/7ec47455e26f2d6e5f2ea4951a0652c06e5b995c291f723973ae9e724a65/jiter-0.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:a7c7d785ae9dda68c2678532a5a1581347e9c15362ae9f6e68f3fdbfb64f2e49", size = 206176, upload-time = "2025-05-18T19:04:00.305Z" },
-]
-
-[[package]]
-name = "jmespath"
-version = "1.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843, upload-time = "2022-06-17T18:00:12.224Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" },
-]
-
-[[package]]
-name = "jsonpatch"
-version = "1.33"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "jsonpointer" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/42/78/18813351fe5d63acad16aec57f94ec2b70a09e53ca98145589e185423873/jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c", size = 21699, upload-time = "2023-06-26T12:07:29.144Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/73/07/02e16ed01e04a374e644b575638ec7987ae846d25ad97bcc9945a3ee4b0e/jsonpatch-1.33-py2.py3-none-any.whl", hash = "sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade", size = 12898, upload-time = "2023-06-16T21:01:28.466Z" },
-]
-
-[[package]]
-name = "jsonpointer"
-version = "3.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114, upload-time = "2024-06-10T19:24:42.462Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595, upload-time = "2024-06-10T19:24:40.698Z" },
-]
-
-[[package]]
-name = "jsonschema"
-version = "4.25.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs" },
-    { name = "jsonschema-specifications" },
-    { name = "referencing" },
-    { name = "rpds-py" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" },
-]
-
-[[package]]
-name = "jsonschema-specifications"
-version = "2025.4.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "referencing" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/bf/ce/46fbd9c8119cfc3581ee5643ea49464d168028cfb5caff5fc0596d0cf914/jsonschema_specifications-2025.4.1.tar.gz", hash = "sha256:630159c9f4dbea161a6a2205c3011cc4f18ff381b189fff48bb39b9bf26ae608", size = 15513, upload-time = "2025-04-23T12:34:07.418Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/01/0e/b27cdbaccf30b890c40ed1da9fd4a3593a5cf94dae54fb34f8a4b74fcd3f/jsonschema_specifications-2025.4.1-py3-none-any.whl", hash = "sha256:4653bffbd6584f7de83a67e0d620ef16900b390ddc7939d56684d6c81e33f1af", size = 18437, upload-time = "2025-04-23T12:34:05.422Z" },
-]
-
-[[package]]
-name = "kalshi-agentic-agent"
-version = "0.1.0"
-source = { virtual = "." }
-dependencies = [
-    { name = "agentuity" },
-    { name = "aiohttp" },
-    { name = "click" },
-    { name = "cryptography" },
-    { name = "e2b" },
-    { name = "httpx" },
-    { name = "kalshi-python" },
-    { name = "nest-asyncio" },
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-    { name = "pandas" },
-    { name = "psutil" },
-    { name = "pydantic" },
-    { name = "python-dateutil" },
-    { name = "python-dotenv" },
-    { name = "pytz" },
-    { name = "pyyaml" },
-    { name = "redis" },
-    { name = "rich" },
-    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.16.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-    { name = "websocket-client" },
-    { name = "websockets" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "agentuity", specifier = ">=0.0.103" },
-    { name = "aiohttp", specifier = ">=3.9.0" },
-    { name = "click", specifier = ">=8.1.7" },
-    { name = "cryptography", specifier = ">=41.0.0" },
-    { name = "e2b", specifier = ">=0.17.0" },
-    { name = "httpx", specifier = ">=0.25.0" },
-    { name = "kalshi-python", specifier = ">=2.0.0" },
-    { name = "nest-asyncio", specifier = ">=1.5.8" },
-    { name = "numpy", specifier = ">=1.24.0" },
-    { name = "pandas", specifier = ">=2.1.0" },
-    { name = "psutil", specifier = ">=5.9.0" },
-    { name = "pydantic", specifier = ">=2.5.0" },
-    { name = "python-dateutil", specifier = ">=2.8.2" },
-    { name = "python-dotenv", specifier = ">=1.0.0" },
-    { name = "pytz", specifier = ">=2023.3" },
-    { name = "pyyaml", specifier = ">=6.0.1" },
-    { name = "redis", extras = ["asyncio"], specifier = ">=4.6.0" },
-    { name = "rich", specifier = ">=13.7.0" },
-    { name = "scipy", specifier = ">=1.11.0" },
-    { name = "websocket-client", specifier = ">=1.6.0" },
-    { name = "websockets", specifier = ">=11.0" },
-]
-
-[[package]]
-name = "kalshi-python"
-version = "2.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "python-dateutil" },
-    { name = "six" },
-    { name = "urllib3" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e2/00/2540596592882201a29546ddb6a20449538f8ff3b558e63e36e62d5e96a1/kalshi_python-2.0.0.tar.gz", hash = "sha256:c9b3bb3beaf14b7ad2a3a18dfc5642fc18529e57c7e7ff93a49912c61441618c", size = 55398, upload-time = "2023-03-03T03:23:48.587Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/10/bd/40228e277cca20ec07e9b59f429fd87311d8921471ced8828b6741cb1d6d/kalshi_python-2.0.0-py3-none-any.whl", hash = "sha256:2a454b4f41d118ba1987c77f3741fcb56dff7d3b73324f91bb6b9e99e2d21d27", size = 150683, upload-time = "2023-03-03T03:23:46.913Z" },
-]
-
-[[package]]
-name = "langchain"
-version = "0.3.27"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "async-timeout", marker = "python_full_version < '3.11'" },
-    { name = "langchain-core" },
-    { name = "langchain-text-splitters" },
-    { name = "langsmith" },
-    { name = "pydantic" },
-    { name = "pyyaml" },
-    { name = "requests" },
-    { name = "sqlalchemy" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/83/f6/f4f7f3a56626fe07e2bb330feb61254dbdf06c506e6b59a536a337da51cf/langchain-0.3.27.tar.gz", hash = "sha256:aa6f1e6274ff055d0fd36254176770f356ed0a8994297d1df47df341953cec62", size = 10233809, upload-time = "2025-07-24T14:42:32.959Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f6/d5/4861816a95b2f6993f1360cfb605aacb015506ee2090433a71de9cca8477/langchain-0.3.27-py3-none-any.whl", hash = "sha256:7b20c4f338826acb148d885b20a73a16e410ede9ee4f19bb02011852d5f98798", size = 1018194, upload-time = "2025-07-24T14:42:30.23Z" },
-]
-
-[[package]]
-name = "langchain-core"
-version = "0.3.74"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "jsonpatch" },
-    { name = "langsmith" },
-    { name = "packaging" },
-    { name = "pydantic" },
-    { name = "pyyaml" },
-    { name = "tenacity" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f1/c6/5d755a0f1f4857abbe5ea6f5907ed0e2b5df52bf4dde0a0fd768290e3084/langchain_core-0.3.74.tar.gz", hash = "sha256:ff604441aeade942fbcc0a3860a592daba7671345230c2078ba2eb5f82b6ba76", size = 569553, upload-time = "2025-08-07T20:47:05.094Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4d/26/545283681ac0379d31c7ad0bac5f195e1982092d76c65ca048db9e3cec0e/langchain_core-0.3.74-py3-none-any.whl", hash = "sha256:088338b5bc2f6a66892f9afc777992c24ee3188f41cbc603d09181e34a228ce7", size = 443453, upload-time = "2025-08-07T20:47:03.853Z" },
-]
-
-[[package]]
-name = "langchain-text-splitters"
-version = "0.3.9"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "langchain-core" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/91/52/d43ad77acae169210cc476cbc1e4ab37a701017c950211a11ab500fe7d7e/langchain_text_splitters-0.3.9.tar.gz", hash = "sha256:7cd1e5a3aaf609979583eeca2eb34177622570b8fa8f586a605c6b1c34e7ebdb", size = 45260, upload-time = "2025-07-24T14:38:45.14Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e2/52/7638394b88bc15083fd2c3752a843784d9d2d110d68fed6437c8607fb749/langchain_text_splitters-0.3.9-py3-none-any.whl", hash = "sha256:cee0bb816211584ea79cc79927317c358543f40404bcfdd69e69ba3ccde54401", size = 33314, upload-time = "2025-07-24T14:38:43.953Z" },
-]
-
-[[package]]
-name = "langsmith"
-version = "0.4.16"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "httpx" },
-    { name = "orjson", marker = "platform_python_implementation != 'PyPy'" },
-    { name = "packaging" },
-    { name = "pydantic" },
-    { name = "requests" },
-    { name = "requests-toolbelt" },
-    { name = "zstandard" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a9/fb/a0fab0ce0bb46aaae9703c1fb814b4ac7cbc2d75adc51e8689f1b34ac08d/langsmith-0.4.16.tar.gz", hash = "sha256:a94f374c7fa0f406757f95f311e84873258563961e1af0ba8996411822cd7241", size = 930411, upload-time = "2025-08-22T15:45:16.56Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/ed/7a48189bdad850cfd47df671204c31779dd190de6bc681f169d4535f852e/langsmith-0.4.16-py3-none-any.whl", hash = "sha256:9ba95ed09b057dfe227e882f5446e1824bfc9f2c89de542ee6f0f8d90ab953a7", size = 375761, upload-time = "2025-08-22T15:45:14.82Z" },
-]
-
-[[package]]
-name = "mail-parser"
-version = "4.1.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "six" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/07/57/20176377e709ea57481f559159f00b366d143cc0a8cf7271b7f0e9c9c7ff/mail_parser-4.1.4.tar.gz", hash = "sha256:b65abad3beee3ffb75c7851bc373412c69e1a22561d49dd7142ee7fb4321ed82", size = 27193, upload-time = "2025-06-25T22:14:20.453Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/e1/23f6629cab94f740ec8c4827742ebd8ef7b3b760cb3dea6e92349289d25c/mail_parser-4.1.4-py3-none-any.whl", hash = "sha256:ec2f7996792d81c0beb174a14795865f9c0f09f47c8afc7b9f7c1240f59d71c2", size = 27077, upload-time = "2025-06-25T22:14:19.529Z" },
-]
-
-[[package]]
-name = "markdown-it-py"
-version = "4.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mdurl" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
-]
-
-[[package]]
-name = "mcp"
-version = "1.13.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "httpx" },
-    { name = "httpx-sse" },
-    { name = "jsonschema" },
-    { name = "pydantic" },
-    { name = "pydantic-settings" },
-    { name = "python-multipart" },
-    { name = "pywin32", marker = "sys_platform == 'win32'" },
-    { name = "sse-starlette" },
-    { name = "starlette" },
-    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/66/3c/82c400c2d50afdac4fbefb5b4031fd327e2ad1f23ccef8eee13c5909aa48/mcp-1.13.1.tar.gz", hash = "sha256:165306a8fd7991dc80334edd2de07798175a56461043b7ae907b279794a834c5", size = 438198, upload-time = "2025-08-22T09:22:16.061Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/3f/d085c7f49ade6d273b185d61ec9405e672b6433f710ea64a90135a8dd445/mcp-1.13.1-py3-none-any.whl", hash = "sha256:c314e7c8bd477a23ba3ef472ee5a32880316c42d03e06dcfa31a1cc7a73b65df", size = 161494, upload-time = "2025-08-22T09:22:14.705Z" },
-]
-
-[[package]]
-name = "mdurl"
-version = "0.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
-]
-
-[[package]]
-name = "multidict"
-version = "6.6.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/69/7f/0652e6ed47ab288e3756ea9c0df8b14950781184d4bd7883f4d87dd41245/multidict-6.6.4.tar.gz", hash = "sha256:d2d4e4787672911b48350df02ed3fa3fffdc2f2e8ca06dd6afdf34189b76a9dd", size = 101843, upload-time = "2025-08-11T12:08:48.217Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/eb/6b/86f353088c1358e76fd30b0146947fddecee812703b604ee901e85cd2a80/multidict-6.6.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b8aa6f0bd8125ddd04a6593437bad6a7e70f300ff4180a531654aa2ab3f6d58f", size = 77054, upload-time = "2025-08-11T12:06:02.99Z" },
-    { url = "https://files.pythonhosted.org/packages/19/5d/c01dc3d3788bb877bd7f5753ea6eb23c1beeca8044902a8f5bfb54430f63/multidict-6.6.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b9e5853bbd7264baca42ffc53391b490d65fe62849bf2c690fa3f6273dbcd0cb", size = 44914, upload-time = "2025-08-11T12:06:05.264Z" },
-    { url = "https://files.pythonhosted.org/packages/46/44/964dae19ea42f7d3e166474d8205f14bb811020e28bc423d46123ddda763/multidict-6.6.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0af5f9dee472371e36d6ae38bde009bd8ce65ac7335f55dcc240379d7bed1495", size = 44601, upload-time = "2025-08-11T12:06:06.627Z" },
-    { url = "https://files.pythonhosted.org/packages/31/20/0616348a1dfb36cb2ab33fc9521de1f27235a397bf3f59338e583afadd17/multidict-6.6.4-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:d24f351e4d759f5054b641c81e8291e5d122af0fca5c72454ff77f7cbe492de8", size = 224821, upload-time = "2025-08-11T12:06:08.06Z" },
-    { url = "https://files.pythonhosted.org/packages/14/26/5d8923c69c110ff51861af05bd27ca6783011b96725d59ccae6d9daeb627/multidict-6.6.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:db6a3810eec08280a172a6cd541ff4a5f6a97b161d93ec94e6c4018917deb6b7", size = 242608, upload-time = "2025-08-11T12:06:09.697Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/cc/e2ad3ba9459aa34fa65cf1f82a5c4a820a2ce615aacfb5143b8817f76504/multidict-6.6.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a1b20a9d56b2d81e2ff52ecc0670d583eaabaa55f402e8d16dd062373dbbe796", size = 222324, upload-time = "2025-08-11T12:06:10.905Z" },
-    { url = "https://files.pythonhosted.org/packages/19/db/4ed0f65701afbc2cb0c140d2d02928bb0fe38dd044af76e58ad7c54fd21f/multidict-6.6.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8c9854df0eaa610a23494c32a6f44a3a550fb398b6b51a56e8c6b9b3689578db", size = 253234, upload-time = "2025-08-11T12:06:12.658Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c1/5160c9813269e39ae14b73debb907bfaaa1beee1762da8c4fb95df4764ed/multidict-6.6.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4bb7627fd7a968f41905a4d6343b0d63244a0623f006e9ed989fa2b78f4438a0", size = 251613, upload-time = "2025-08-11T12:06:13.97Z" },
-    { url = "https://files.pythonhosted.org/packages/05/a9/48d1bd111fc2f8fb98b2ed7f9a115c55a9355358432a19f53c0b74d8425d/multidict-6.6.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:caebafea30ed049c57c673d0b36238b1748683be2593965614d7b0e99125c877", size = 241649, upload-time = "2025-08-11T12:06:15.204Z" },
-    { url = "https://files.pythonhosted.org/packages/85/2a/f7d743df0019408768af8a70d2037546a2be7b81fbb65f040d76caafd4c5/multidict-6.6.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ad887a8250eb47d3ab083d2f98db7f48098d13d42eb7a3b67d8a5c795f224ace", size = 239238, upload-time = "2025-08-11T12:06:16.467Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/b8/4f4bb13323c2d647323f7919201493cf48ebe7ded971717bfb0f1a79b6bf/multidict-6.6.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:ed8358ae7d94ffb7c397cecb62cbac9578a83ecefc1eba27b9090ee910e2efb6", size = 233517, upload-time = "2025-08-11T12:06:18.107Z" },
-    { url = "https://files.pythonhosted.org/packages/33/29/4293c26029ebfbba4f574febd2ed01b6f619cfa0d2e344217d53eef34192/multidict-6.6.4-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:ecab51ad2462197a4c000b6d5701fc8585b80eecb90583635d7e327b7b6923eb", size = 243122, upload-time = "2025-08-11T12:06:19.361Z" },
-    { url = "https://files.pythonhosted.org/packages/20/60/a1c53628168aa22447bfde3a8730096ac28086704a0d8c590f3b63388d0c/multidict-6.6.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:c5c97aa666cf70e667dfa5af945424ba1329af5dd988a437efeb3a09430389fb", size = 248992, upload-time = "2025-08-11T12:06:20.661Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/3b/55443a0c372f33cae5d9ec37a6a973802884fa0ab3586659b197cf8cc5e9/multidict-6.6.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:9a950b7cf54099c1209f455ac5970b1ea81410f2af60ed9eb3c3f14f0bfcf987", size = 243708, upload-time = "2025-08-11T12:06:21.891Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/60/a18c6900086769312560b2626b18e8cca22d9e85b1186ba77f4755b11266/multidict-6.6.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:163c7ea522ea9365a8a57832dea7618e6cbdc3cd75f8c627663587459a4e328f", size = 237498, upload-time = "2025-08-11T12:06:23.206Z" },
-    { url = "https://files.pythonhosted.org/packages/11/3d/8bdd8bcaff2951ce2affccca107a404925a2beafedd5aef0b5e4a71120a6/multidict-6.6.4-cp310-cp310-win32.whl", hash = "sha256:17d2cbbfa6ff20821396b25890f155f40c986f9cfbce5667759696d83504954f", size = 41415, upload-time = "2025-08-11T12:06:24.77Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/53/cab1ad80356a4cd1b685a254b680167059b433b573e53872fab245e9fc95/multidict-6.6.4-cp310-cp310-win_amd64.whl", hash = "sha256:ce9a40fbe52e57e7edf20113a4eaddfacac0561a0879734e636aa6d4bb5e3fb0", size = 46046, upload-time = "2025-08-11T12:06:25.893Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/9a/874212b6f5c1c2d870d0a7adc5bb4cfe9b0624fa15cdf5cf757c0f5087ae/multidict-6.6.4-cp310-cp310-win_arm64.whl", hash = "sha256:01d0959807a451fe9fdd4da3e139cb5b77f7328baf2140feeaf233e1d777b729", size = 43147, upload-time = "2025-08-11T12:06:27.534Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/7f/90a7f01e2d005d6653c689039977f6856718c75c5579445effb7e60923d1/multidict-6.6.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c7a0e9b561e6460484318a7612e725df1145d46b0ef57c6b9866441bf6e27e0c", size = 76472, upload-time = "2025-08-11T12:06:29.006Z" },
-    { url = "https://files.pythonhosted.org/packages/54/a3/bed07bc9e2bb302ce752f1dabc69e884cd6a676da44fb0e501b246031fdd/multidict-6.6.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6bf2f10f70acc7a2446965ffbc726e5fc0b272c97a90b485857e5c70022213eb", size = 44634, upload-time = "2025-08-11T12:06:30.374Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/4b/ceeb4f8f33cf81277da464307afeaf164fb0297947642585884f5cad4f28/multidict-6.6.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:66247d72ed62d5dd29752ffc1d3b88f135c6a8de8b5f63b7c14e973ef5bda19e", size = 44282, upload-time = "2025-08-11T12:06:31.958Z" },
-    { url = "https://files.pythonhosted.org/packages/03/35/436a5da8702b06866189b69f655ffdb8f70796252a8772a77815f1812679/multidict-6.6.4-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:105245cc6b76f51e408451a844a54e6823bbd5a490ebfe5bdfc79798511ceded", size = 229696, upload-time = "2025-08-11T12:06:33.087Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/0e/915160be8fecf1fca35f790c08fb74ca684d752fcba62c11daaf3d92c216/multidict-6.6.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cbbc54e58b34c3bae389ef00046be0961f30fef7cb0dd9c7756aee376a4f7683", size = 246665, upload-time = "2025-08-11T12:06:34.448Z" },
-    { url = "https://files.pythonhosted.org/packages/08/ee/2f464330acd83f77dcc346f0b1a0eaae10230291450887f96b204b8ac4d3/multidict-6.6.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:56c6b3652f945c9bc3ac6c8178cd93132b8d82dd581fcbc3a00676c51302bc1a", size = 225485, upload-time = "2025-08-11T12:06:35.672Z" },
-    { url = "https://files.pythonhosted.org/packages/71/cc/9a117f828b4d7fbaec6adeed2204f211e9caf0a012692a1ee32169f846ae/multidict-6.6.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b95494daf857602eccf4c18ca33337dd2be705bccdb6dddbfc9d513e6addb9d9", size = 257318, upload-time = "2025-08-11T12:06:36.98Z" },
-    { url = "https://files.pythonhosted.org/packages/25/77/62752d3dbd70e27fdd68e86626c1ae6bccfebe2bb1f84ae226363e112f5a/multidict-6.6.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e5b1413361cef15340ab9dc61523e653d25723e82d488ef7d60a12878227ed50", size = 254689, upload-time = "2025-08-11T12:06:38.233Z" },
-    { url = "https://files.pythonhosted.org/packages/00/6e/fac58b1072a6fc59af5e7acb245e8754d3e1f97f4f808a6559951f72a0d4/multidict-6.6.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e167bf899c3d724f9662ef00b4f7fef87a19c22b2fead198a6f68b263618df52", size = 246709, upload-time = "2025-08-11T12:06:39.517Z" },
-    { url = "https://files.pythonhosted.org/packages/01/ef/4698d6842ef5e797c6db7744b0081e36fb5de3d00002cc4c58071097fac3/multidict-6.6.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:aaea28ba20a9026dfa77f4b80369e51cb767c61e33a2d4043399c67bd95fb7c6", size = 243185, upload-time = "2025-08-11T12:06:40.796Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/c9/d82e95ae1d6e4ef396934e9b0e942dfc428775f9554acf04393cce66b157/multidict-6.6.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:8c91cdb30809a96d9ecf442ec9bc45e8cfaa0f7f8bdf534e082c2443a196727e", size = 237838, upload-time = "2025-08-11T12:06:42.595Z" },
-    { url = "https://files.pythonhosted.org/packages/57/cf/f94af5c36baaa75d44fab9f02e2a6bcfa0cd90acb44d4976a80960759dbc/multidict-6.6.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1a0ccbfe93ca114c5d65a2471d52d8829e56d467c97b0e341cf5ee45410033b3", size = 246368, upload-time = "2025-08-11T12:06:44.304Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/fe/29f23460c3d995f6a4b678cb2e9730e7277231b981f0b234702f0177818a/multidict-6.6.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:55624b3f321d84c403cb7d8e6e982f41ae233d85f85db54ba6286f7295dc8a9c", size = 253339, upload-time = "2025-08-11T12:06:45.597Z" },
-    { url = "https://files.pythonhosted.org/packages/29/b6/fd59449204426187b82bf8a75f629310f68c6adc9559dc922d5abe34797b/multidict-6.6.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:4a1fb393a2c9d202cb766c76208bd7945bc194eba8ac920ce98c6e458f0b524b", size = 246933, upload-time = "2025-08-11T12:06:46.841Z" },
-    { url = "https://files.pythonhosted.org/packages/19/52/d5d6b344f176a5ac3606f7a61fb44dc746e04550e1a13834dff722b8d7d6/multidict-6.6.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:43868297a5759a845fa3a483fb4392973a95fb1de891605a3728130c52b8f40f", size = 242225, upload-time = "2025-08-11T12:06:48.588Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/d3/5b2281ed89ff4d5318d82478a2a2450fcdfc3300da48ff15c1778280ad26/multidict-6.6.4-cp311-cp311-win32.whl", hash = "sha256:ed3b94c5e362a8a84d69642dbeac615452e8af9b8eb825b7bc9f31a53a1051e2", size = 41306, upload-time = "2025-08-11T12:06:49.95Z" },
-    { url = "https://files.pythonhosted.org/packages/74/7d/36b045c23a1ab98507aefd44fd8b264ee1dd5e5010543c6fccf82141ccef/multidict-6.6.4-cp311-cp311-win_amd64.whl", hash = "sha256:d8c112f7a90d8ca5d20213aa41eac690bb50a76da153e3afb3886418e61cb22e", size = 46029, upload-time = "2025-08-11T12:06:51.082Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/5e/553d67d24432c5cd52b49047f2d248821843743ee6d29a704594f656d182/multidict-6.6.4-cp311-cp311-win_arm64.whl", hash = "sha256:3bb0eae408fa1996d87247ca0d6a57b7fc1dcf83e8a5c47ab82c558c250d4adf", size = 43017, upload-time = "2025-08-11T12:06:52.243Z" },
-    { url = "https://files.pythonhosted.org/packages/05/f6/512ffd8fd8b37fb2680e5ac35d788f1d71bbaf37789d21a820bdc441e565/multidict-6.6.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0ffb87be160942d56d7b87b0fdf098e81ed565add09eaa1294268c7f3caac4c8", size = 76516, upload-time = "2025-08-11T12:06:53.393Z" },
-    { url = "https://files.pythonhosted.org/packages/99/58/45c3e75deb8855c36bd66cc1658007589662ba584dbf423d01df478dd1c5/multidict-6.6.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d191de6cbab2aff5de6c5723101705fd044b3e4c7cfd587a1929b5028b9714b3", size = 45394, upload-time = "2025-08-11T12:06:54.555Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/ca/e8c4472a93a26e4507c0b8e1f0762c0d8a32de1328ef72fd704ef9cc5447/multidict-6.6.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:38a0956dd92d918ad5feff3db8fcb4a5eb7dba114da917e1a88475619781b57b", size = 43591, upload-time = "2025-08-11T12:06:55.672Z" },
-    { url = "https://files.pythonhosted.org/packages/05/51/edf414f4df058574a7265034d04c935aa84a89e79ce90fcf4df211f47b16/multidict-6.6.4-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6865f6d3b7900ae020b495d599fcf3765653bc927951c1abb959017f81ae8287", size = 237215, upload-time = "2025-08-11T12:06:57.213Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/45/8b3d6dbad8cf3252553cc41abea09ad527b33ce47a5e199072620b296902/multidict-6.6.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a2088c126b6f72db6c9212ad827d0ba088c01d951cee25e758c450da732c138", size = 258299, upload-time = "2025-08-11T12:06:58.946Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/e8/8ca2e9a9f5a435fc6db40438a55730a4bf4956b554e487fa1b9ae920f825/multidict-6.6.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0f37bed7319b848097085d7d48116f545985db988e2256b2e6f00563a3416ee6", size = 242357, upload-time = "2025-08-11T12:07:00.301Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/84/80c77c99df05a75c28490b2af8f7cba2a12621186e0a8b0865d8e745c104/multidict-6.6.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:01368e3c94032ba6ca0b78e7ccb099643466cf24f8dc8eefcfdc0571d56e58f9", size = 268369, upload-time = "2025-08-11T12:07:01.638Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/e9/920bfa46c27b05fb3e1ad85121fd49f441492dca2449c5bcfe42e4565d8a/multidict-6.6.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe323540c255db0bffee79ad7f048c909f2ab0edb87a597e1c17da6a54e493c", size = 269341, upload-time = "2025-08-11T12:07:02.943Z" },
-    { url = "https://files.pythonhosted.org/packages/af/65/753a2d8b05daf496f4a9c367fe844e90a1b2cac78e2be2c844200d10cc4c/multidict-6.6.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8eb3025f17b0a4c3cd08cda49acf312a19ad6e8a4edd9dbd591e6506d999402", size = 256100, upload-time = "2025-08-11T12:07:04.564Z" },
-    { url = "https://files.pythonhosted.org/packages/09/54/655be13ae324212bf0bc15d665a4e34844f34c206f78801be42f7a0a8aaa/multidict-6.6.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bbc14f0365534d35a06970d6a83478b249752e922d662dc24d489af1aa0d1be7", size = 253584, upload-time = "2025-08-11T12:07:05.914Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/74/ab2039ecc05264b5cec73eb018ce417af3ebb384ae9c0e9ed42cb33f8151/multidict-6.6.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:75aa52fba2d96bf972e85451b99d8e19cc37ce26fd016f6d4aa60da9ab2b005f", size = 251018, upload-time = "2025-08-11T12:07:08.301Z" },
-    { url = "https://files.pythonhosted.org/packages/af/0a/ccbb244ac848e56c6427f2392741c06302bbfba49c0042f1eb3c5b606497/multidict-6.6.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4fefd4a815e362d4f011919d97d7b4a1e566f1dde83dc4ad8cfb5b41de1df68d", size = 251477, upload-time = "2025-08-11T12:07:10.248Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/b0/0ed49bba775b135937f52fe13922bc64a7eaf0a3ead84a36e8e4e446e096/multidict-6.6.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:db9801fe021f59a5b375ab778973127ca0ac52429a26e2fd86aa9508f4d26eb7", size = 263575, upload-time = "2025-08-11T12:07:11.928Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/d9/7fb85a85e14de2e44dfb6a24f03c41e2af8697a6df83daddb0e9b7569f73/multidict-6.6.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a650629970fa21ac1fb06ba25dabfc5b8a2054fcbf6ae97c758aa956b8dba802", size = 259649, upload-time = "2025-08-11T12:07:13.244Z" },
-    { url = "https://files.pythonhosted.org/packages/03/9e/b3a459bcf9b6e74fa461a5222a10ff9b544cb1cd52fd482fb1b75ecda2a2/multidict-6.6.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:452ff5da78d4720d7516a3a2abd804957532dd69296cb77319c193e3ffb87e24", size = 251505, upload-time = "2025-08-11T12:07:14.57Z" },
-    { url = "https://files.pythonhosted.org/packages/86/a2/8022f78f041dfe6d71e364001a5cf987c30edfc83c8a5fb7a3f0974cff39/multidict-6.6.4-cp312-cp312-win32.whl", hash = "sha256:8c2fcb12136530ed19572bbba61b407f655e3953ba669b96a35036a11a485793", size = 41888, upload-time = "2025-08-11T12:07:15.904Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/eb/d88b1780d43a56db2cba24289fa744a9d216c1a8546a0dc3956563fd53ea/multidict-6.6.4-cp312-cp312-win_amd64.whl", hash = "sha256:047d9425860a8c9544fed1b9584f0c8bcd31bcde9568b047c5e567a1025ecd6e", size = 46072, upload-time = "2025-08-11T12:07:17.045Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/16/b929320bf5750e2d9d4931835a4c638a19d2494a5b519caaaa7492ebe105/multidict-6.6.4-cp312-cp312-win_arm64.whl", hash = "sha256:14754eb72feaa1e8ae528468f24250dd997b8e2188c3d2f593f9eba259e4b364", size = 43222, upload-time = "2025-08-11T12:07:18.328Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/69/b547032297c7e63ba2af494edba695d781af8a0c6e89e4d06cf848b21d80/multidict-6.6.4-py3-none-any.whl", hash = "sha256:27d8f8e125c07cb954e54d75d04905a9bba8a439c1d84aca94949d4d03d8601c", size = 12313, upload-time = "2025-08-11T12:08:46.891Z" },
-]
-
-[[package]]
-name = "nest-asyncio"
-version = "1.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" },
-]
-
-[[package]]
-name = "numpy"
-version = "2.2.6"
-source = { registry = "https://pypi.org/simple" }
-resolution-markers = [
-    "python_full_version < '3.11'",
-]
-sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" },
-    { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" },
-    { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" },
-    { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" },
-    { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" },
-    { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" },
-    { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" },
-    { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" },
-    { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" },
-    { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" },
-    { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" },
-    { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" },
-    { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" },
-    { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" },
-    { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" },
-    { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" },
-]
-
-[[package]]
-name = "numpy"
-version = "2.3.2"
-source = { registry = "https://pypi.org/simple" }
-resolution-markers = [
-    "python_full_version >= '3.12'",
-    "python_full_version == '3.11.*'",
-]
-sdist = { url = "https://files.pythonhosted.org/packages/37/7d/3fec4199c5ffb892bed55cff901e4f39a58c81df9c44c280499e92cad264/numpy-2.3.2.tar.gz", hash = "sha256:e0486a11ec30cdecb53f184d496d1c6a20786c81e55e41640270130056f8ee48", size = 20489306, upload-time = "2025-07-24T21:32:07.553Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/96/26/1320083986108998bd487e2931eed2aeedf914b6e8905431487543ec911d/numpy-2.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:852ae5bed3478b92f093e30f785c98e0cb62fa0a939ed057c31716e18a7a22b9", size = 21259016, upload-time = "2025-07-24T20:24:35.214Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/2b/792b341463fa93fc7e55abbdbe87dac316c5b8cb5e94fb7a59fb6fa0cda5/numpy-2.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7a0e27186e781a69959d0230dd9909b5e26024f8da10683bd6344baea1885168", size = 14451158, upload-time = "2025-07-24T20:24:58.397Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/13/e792d7209261afb0c9f4759ffef6135b35c77c6349a151f488f531d13595/numpy-2.3.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:f0a1a8476ad77a228e41619af2fa9505cf69df928e9aaa165746584ea17fed2b", size = 5379817, upload-time = "2025-07-24T20:25:07.746Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ce/055274fcba4107c022b2113a213c7287346563f48d62e8d2a5176ad93217/numpy-2.3.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:cbc95b3813920145032412f7e33d12080f11dc776262df1712e1638207dde9e8", size = 6913606, upload-time = "2025-07-24T20:25:18.84Z" },
-    { url = "https://files.pythonhosted.org/packages/17/f2/e4d72e6bc5ff01e2ab613dc198d560714971900c03674b41947e38606502/numpy-2.3.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f75018be4980a7324edc5930fe39aa391d5734531b1926968605416ff58c332d", size = 14589652, upload-time = "2025-07-24T20:25:40.356Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/b0/fbeee3000a51ebf7222016e2939b5c5ecf8000a19555d04a18f1e02521b8/numpy-2.3.2-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20b8200721840f5621b7bd03f8dcd78de33ec522fc40dc2641aa09537df010c3", size = 16938816, upload-time = "2025-07-24T20:26:05.721Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/ec/2f6c45c3484cc159621ea8fc000ac5a86f1575f090cac78ac27193ce82cd/numpy-2.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1f91e5c028504660d606340a084db4b216567ded1056ea2b4be4f9d10b67197f", size = 16370512, upload-time = "2025-07-24T20:26:30.545Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/01/dd67cf511850bd7aefd6347aaae0956ed415abea741ae107834aae7d6d4e/numpy-2.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:fb1752a3bb9a3ad2d6b090b88a9a0ae1cd6f004ef95f75825e2f382c183b2097", size = 18884947, upload-time = "2025-07-24T20:26:58.24Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/17/2cf60fd3e6a61d006778735edf67a222787a8c1a7842aed43ef96d777446/numpy-2.3.2-cp311-cp311-win32.whl", hash = "sha256:4ae6863868aaee2f57503c7a5052b3a2807cf7a3914475e637a0ecd366ced220", size = 6599494, upload-time = "2025-07-24T20:27:09.786Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/03/0eade211c504bda872a594f045f98ddcc6caef2b7c63610946845e304d3f/numpy-2.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:240259d6564f1c65424bcd10f435145a7644a65a6811cfc3201c4a429ba79170", size = 13087889, upload-time = "2025-07-24T20:27:29.558Z" },
-    { url = "https://files.pythonhosted.org/packages/13/32/2c7979d39dafb2a25087e12310fc7f3b9d3c7d960df4f4bc97955ae0ce1d/numpy-2.3.2-cp311-cp311-win_arm64.whl", hash = "sha256:4209f874d45f921bde2cff1ffcd8a3695f545ad2ffbef6d3d3c6768162efab89", size = 10459560, upload-time = "2025-07-24T20:27:46.803Z" },
-    { url = "https://files.pythonhosted.org/packages/00/6d/745dd1c1c5c284d17725e5c802ca4d45cfc6803519d777f087b71c9f4069/numpy-2.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bc3186bea41fae9d8e90c2b4fb5f0a1f5a690682da79b92574d63f56b529080b", size = 20956420, upload-time = "2025-07-24T20:28:18.002Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/96/e7b533ea5740641dd62b07a790af5d9d8fec36000b8e2d0472bd7574105f/numpy-2.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f4f0215edb189048a3c03bd5b19345bdfa7b45a7a6f72ae5945d2a28272727f", size = 14184660, upload-time = "2025-07-24T20:28:39.522Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/53/102c6122db45a62aa20d1b18c9986f67e6b97e0d6fbc1ae13e3e4c84430c/numpy-2.3.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8b1224a734cd509f70816455c3cffe13a4f599b1bf7130f913ba0e2c0b2006c0", size = 5113382, upload-time = "2025-07-24T20:28:48.544Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/21/376257efcbf63e624250717e82b4fae93d60178f09eb03ed766dbb48ec9c/numpy-2.3.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3dcf02866b977a38ba3ec10215220609ab9667378a9e2150615673f3ffd6c73b", size = 6647258, upload-time = "2025-07-24T20:28:59.104Z" },
-    { url = "https://files.pythonhosted.org/packages/91/ba/f4ebf257f08affa464fe6036e13f2bf9d4642a40228781dc1235da81be9f/numpy-2.3.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:572d5512df5470f50ada8d1972c5f1082d9a0b7aa5944db8084077570cf98370", size = 14281409, upload-time = "2025-07-24T20:40:30.298Z" },
-    { url = "https://files.pythonhosted.org/packages/59/ef/f96536f1df42c668cbacb727a8c6da7afc9c05ece6d558927fb1722693e1/numpy-2.3.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8145dd6d10df13c559d1e4314df29695613575183fa2e2d11fac4c208c8a1f73", size = 16641317, upload-time = "2025-07-24T20:40:56.625Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/a7/af813a7b4f9a42f498dde8a4c6fcbff8100eed00182cc91dbaf095645f38/numpy-2.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:103ea7063fa624af04a791c39f97070bf93b96d7af7eb23530cd087dc8dbe9dc", size = 16056262, upload-time = "2025-07-24T20:41:20.797Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/5d/41c4ef8404caaa7f05ed1cfb06afe16a25895260eacbd29b4d84dff2920b/numpy-2.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc927d7f289d14f5e037be917539620603294454130b6de200091e23d27dc9be", size = 18579342, upload-time = "2025-07-24T20:41:50.753Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/4f/9950e44c5a11636f4a3af6e825ec23003475cc9a466edb7a759ed3ea63bd/numpy-2.3.2-cp312-cp312-win32.whl", hash = "sha256:d95f59afe7f808c103be692175008bab926b59309ade3e6d25009e9a171f7036", size = 6320610, upload-time = "2025-07-24T20:42:01.551Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/2f/244643a5ce54a94f0a9a2ab578189c061e4a87c002e037b0829dd77293b6/numpy-2.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:9e196ade2400c0c737d93465327d1ae7c06c7cb8a1756121ebf54b06ca183c7f", size = 12786292, upload-time = "2025-07-24T20:42:20.738Z" },
-    { url = "https://files.pythonhosted.org/packages/54/cd/7b5f49d5d78db7badab22d8323c1b6ae458fbf86c4fdfa194ab3cd4eb39b/numpy-2.3.2-cp312-cp312-win_arm64.whl", hash = "sha256:ee807923782faaf60d0d7331f5e86da7d5e3079e28b291973c545476c2b00d07", size = 10194071, upload-time = "2025-07-24T20:42:36.657Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/ea/50ebc91d28b275b23b7128ef25c3d08152bc4068f42742867e07a870a42a/numpy-2.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:14a91ebac98813a49bc6aa1a0dfc09513dcec1d97eaf31ca21a87221a1cdcb15", size = 21130338, upload-time = "2025-07-24T20:57:54.37Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/57/cdd5eac00dd5f137277355c318a955c0d8fb8aa486020c22afd305f8b88f/numpy-2.3.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:71669b5daae692189540cffc4c439468d35a3f84f0c88b078ecd94337f6cb0ec", size = 14375776, upload-time = "2025-07-24T20:58:16.303Z" },
-    { url = "https://files.pythonhosted.org/packages/83/85/27280c7f34fcd305c2209c0cdca4d70775e4859a9eaa92f850087f8dea50/numpy-2.3.2-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:69779198d9caee6e547adb933941ed7520f896fd9656834c300bdf4dd8642712", size = 5304882, upload-time = "2025-07-24T20:58:26.199Z" },
-    { url = "https://files.pythonhosted.org/packages/48/b4/6500b24d278e15dd796f43824e69939d00981d37d9779e32499e823aa0aa/numpy-2.3.2-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:2c3271cc4097beb5a60f010bcc1cc204b300bb3eafb4399376418a83a1c6373c", size = 6818405, upload-time = "2025-07-24T20:58:37.341Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/c9/142c1e03f199d202da8e980c2496213509291b6024fd2735ad28ae7065c7/numpy-2.3.2-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8446acd11fe3dc1830568c941d44449fd5cb83068e5c70bd5a470d323d448296", size = 14419651, upload-time = "2025-07-24T20:58:59.048Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/95/8023e87cbea31a750a6c00ff9427d65ebc5fef104a136bfa69f76266d614/numpy-2.3.2-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa098a5ab53fa407fded5870865c6275a5cd4101cfdef8d6fafc48286a96e981", size = 16760166, upload-time = "2025-07-24T21:28:56.38Z" },
-    { url = "https://files.pythonhosted.org/packages/78/e3/6690b3f85a05506733c7e90b577e4762517404ea78bab2ca3a5cb1aeb78d/numpy-2.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6936aff90dda378c09bea075af0d9c675fe3a977a9d2402f95a87f440f59f619", size = 12977811, upload-time = "2025-07-24T21:29:18.234Z" },
-]
-
-[[package]]
-name = "openai"
-version = "1.101.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "distro" },
-    { name = "httpx" },
-    { name = "jiter" },
-    { name = "pydantic" },
-    { name = "sniffio" },
-    { name = "tqdm" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/00/7c/eaf06b62281f5ca4f774c4cff066e6ddfd6a027e0ac791be16acec3a95e3/openai-1.101.0.tar.gz", hash = "sha256:29f56df2236069686e64aca0e13c24a4ec310545afb25ef7da2ab1a18523f22d", size = 518415, upload-time = "2025-08-21T21:11:01.645Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/a6/0e39baa335bbd1c66c7e0a41dbbec10c5a15ab95c1344e7f7beb28eee65a/openai-1.101.0-py3-none-any.whl", hash = "sha256:6539a446cce154f8d9fb42757acdfd3ed9357ab0d34fcac11096c461da87133b", size = 810772, upload-time = "2025-08-21T21:10:59.215Z" },
-]
-
-[[package]]
-name = "openai-agents"
-version = "0.2.9"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "griffe" },
-    { name = "mcp" },
-    { name = "openai" },
-    { name = "pydantic" },
-    { name = "requests" },
-    { name = "types-requests" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c3/03/45a1022ae6daa7f0223a3cae8975c5a524858edcad2355f8e1adcd4f000e/openai_agents-0.2.9.tar.gz", hash = "sha256:619c51c8ce49f841474a9e619573d6f7f96a46432900752145ad04309ab70ae9", size = 1664869, upload-time = "2025-08-22T02:03:39.196Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/dc/bf/8a8dd24206763214f364b272371486247744a64ef554e952d92444e6ce14/openai_agents-0.2.9-py3-none-any.whl", hash = "sha256:cca016c28e39b24b17cae232c2bc16769e48dbfc7cbe006775d10822c441f6e4", size = 175106, upload-time = "2025-08-22T02:03:37.738Z" },
-]
-
-[[package]]
-name = "openlit"
-version = "1.35.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anthropic" },
-    { name = "boto3" },
-    { name = "botocore" },
-    { name = "langchain" },
-    { name = "openai" },
-    { name = "openai-agents" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-exporter-otlp" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-aiohttp-client" },
-    { name = "opentelemetry-instrumentation-asgi" },
-    { name = "opentelemetry-instrumentation-django" },
-    { name = "opentelemetry-instrumentation-falcon" },
-    { name = "opentelemetry-instrumentation-fastapi" },
-    { name = "opentelemetry-instrumentation-flask" },
-    { name = "opentelemetry-instrumentation-httpx" },
-    { name = "opentelemetry-instrumentation-pyramid" },
-    { name = "opentelemetry-instrumentation-requests" },
-    { name = "opentelemetry-instrumentation-starlette" },
-    { name = "opentelemetry-instrumentation-tornado" },
-    { name = "opentelemetry-instrumentation-urllib" },
-    { name = "opentelemetry-instrumentation-urllib3" },
-    { name = "opentelemetry-sdk" },
-    { name = "pydantic" },
-    { name = "requests" },
-    { name = "schedule" },
-    { name = "xmltodict" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e1/e0/e7588c64b35aa61f15ee19d1410dd507364408e694f8c463413349aa9c06/openlit-1.35.1.tar.gz", hash = "sha256:c528921156c72723c320d14c192db81ee67baf7f90a99fef7b96e368d0a3f952", size = 256734, upload-time = "2025-08-24T14:25:44.251Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/d1/f2d99f4e7b68aa825fcc283537cd11a46b7766a6392cbf3aa8544da9332f/openlit-1.35.1-py3-none-any.whl", hash = "sha256:d26850d55593562074cbef86ffaf8bdb2dd75462072b96a6ecb41c30e52c0492", size = 401570, upload-time = "2025-08-24T14:25:42.493Z" },
-]
-
-[[package]]
-name = "opentelemetry-api"
-version = "1.36.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "importlib-metadata" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/27/d2/c782c88b8afbf961d6972428821c302bd1e9e7bc361352172f0ca31296e2/opentelemetry_api-1.36.0.tar.gz", hash = "sha256:9a72572b9c416d004d492cbc6e61962c0501eaf945ece9b5a0f56597d8348aa0", size = 64780, upload-time = "2025-07-29T15:12:06.02Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bb/ee/6b08dde0a022c463b88f55ae81149584b125a42183407dc1045c486cc870/opentelemetry_api-1.36.0-py3-none-any.whl", hash = "sha256:02f20bcacf666e1333b6b1f04e647dc1d5111f86b8e510238fcc56d7762cda8c", size = 65564, upload-time = "2025-07-29T15:11:47.998Z" },
-]
-
-[[package]]
-name = "opentelemetry-exporter-otlp"
-version = "1.36.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-exporter-otlp-proto-grpc" },
-    { name = "opentelemetry-exporter-otlp-proto-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/95/7f/d31294ac28d567a14aefd855756bab79fed69c5a75df712f228f10c47e04/opentelemetry_exporter_otlp-1.36.0.tar.gz", hash = "sha256:72f166ea5a8923ac42889337f903e93af57db8893de200369b07401e98e4e06b", size = 6144, upload-time = "2025-07-29T15:12:07.153Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/a2/8966111a285124f3d6156a663ddf2aeddd52843c1a3d6b56cbd9b6c3fd0e/opentelemetry_exporter_otlp-1.36.0-py3-none-any.whl", hash = "sha256:de93b7c45bcc78296998775d52add7c63729e83ef2cd6560730a6b336d7f6494", size = 7018, upload-time = "2025-07-29T15:11:50.498Z" },
-]
-
-[[package]]
-name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.36.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-proto" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/34/da/7747e57eb341c59886052d733072bc878424bf20f1d8cf203d508bbece5b/opentelemetry_exporter_otlp_proto_common-1.36.0.tar.gz", hash = "sha256:6c496ccbcbe26b04653cecadd92f73659b814c6e3579af157d8716e5f9f25cbf", size = 20302, upload-time = "2025-07-29T15:12:07.71Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d0/ed/22290dca7db78eb32e0101738366b5bbda00d0407f00feffb9bf8c3fdf87/opentelemetry_exporter_otlp_proto_common-1.36.0-py3-none-any.whl", hash = "sha256:0fc002a6ed63eac235ada9aa7056e5492e9a71728214a61745f6ad04b923f840", size = 18349, upload-time = "2025-07-29T15:11:51.327Z" },
-]
-
-[[package]]
-name = "opentelemetry-exporter-otlp-proto-grpc"
-version = "1.36.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "googleapis-common-protos" },
-    { name = "grpcio" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-exporter-otlp-proto-common" },
-    { name = "opentelemetry-proto" },
-    { name = "opentelemetry-sdk" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/72/6f/6c1b0bdd0446e5532294d1d41bf11fbaea39c8a2423a4cdfe4fe6b708127/opentelemetry_exporter_otlp_proto_grpc-1.36.0.tar.gz", hash = "sha256:b281afbf7036b325b3588b5b6c8bb175069e3978d1bd24071f4a59d04c1e5bbf", size = 23822, upload-time = "2025-07-29T15:12:08.292Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0c/67/5f6bd188d66d0fd8e81e681bbf5822e53eb150034e2611dd2b935d3ab61a/opentelemetry_exporter_otlp_proto_grpc-1.36.0-py3-none-any.whl", hash = "sha256:734e841fc6a5d6f30e7be4d8053adb703c70ca80c562ae24e8083a28fadef211", size = 18828, upload-time = "2025-07-29T15:11:52.235Z" },
-]
-
-[[package]]
-name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.36.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "googleapis-common-protos" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-exporter-otlp-proto-common" },
-    { name = "opentelemetry-proto" },
-    { name = "opentelemetry-sdk" },
-    { name = "requests" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/25/85/6632e7e5700ba1ce5b8a065315f92c1e6d787ccc4fb2bdab15139eaefc82/opentelemetry_exporter_otlp_proto_http-1.36.0.tar.gz", hash = "sha256:dd3637f72f774b9fc9608ab1ac479f8b44d09b6fb5b2f3df68a24ad1da7d356e", size = 16213, upload-time = "2025-07-29T15:12:08.932Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7f/41/a680d38b34f8f5ddbd78ed9f0042e1cc712d58ec7531924d71cb1e6c629d/opentelemetry_exporter_otlp_proto_http-1.36.0-py3-none-any.whl", hash = "sha256:3d769f68e2267e7abe4527f70deb6f598f40be3ea34c6adc35789bea94a32902", size = 18752, upload-time = "2025-07-29T15:11:53.164Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "packaging" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/12/37/cf17cf28f945a3aca5a038cfbb45ee01317d4f7f3a0e5209920883fe9b08/opentelemetry_instrumentation-0.57b0.tar.gz", hash = "sha256:f2a30135ba77cdea2b0e1df272f4163c154e978f57214795d72f40befd4fcf05", size = 30807, upload-time = "2025-07-29T15:42:44.746Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d0/6f/f20cd1542959f43fb26a5bf9bb18cd81a1ea0700e8870c8f369bd07f5c65/opentelemetry_instrumentation-0.57b0-py3-none-any.whl", hash = "sha256:9109280f44882e07cec2850db28210b90600ae9110b42824d196de357cbddf7e", size = 32460, upload-time = "2025-07-29T15:41:40.883Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-aiohttp-client"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/35/0b/62ecc589a619d2661557084077854fc8b3908382e08ddd79d811124a930a/opentelemetry_instrumentation_aiohttp_client-0.57b0.tar.gz", hash = "sha256:ce05e8ef7bc7016d4b0d8e47786b5cf5e6efd7ff0bea8e1ab6616ef5fa985f37", size = 15037, upload-time = "2025-07-29T15:42:45.929Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/63/45a664f89ea7f3e57658de084477bd3c2b437e123a212e699c19c0690f73/opentelemetry_instrumentation_aiohttp_client-0.57b0-py3-none-any.whl", hash = "sha256:fbec3966da845b9a650a72f8fc7f7ac4dd25365317c850a188611e1c92606ac8", size = 12374, upload-time = "2025-07-29T15:41:43.134Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-asgi"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "asgiref" },
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/97/10/7ba59b586eb099fa0155521b387d857de476687c670096597f618d889323/opentelemetry_instrumentation_asgi-0.57b0.tar.gz", hash = "sha256:a6f880b5d1838f65688fc992c65fbb1d3571f319d370990c32e759d3160e510b", size = 24654, upload-time = "2025-07-29T15:42:48.199Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9e/07/ab97dd7e8bc680b479203f7d3b2771b7a097468135a669a38da3208f96cb/opentelemetry_instrumentation_asgi-0.57b0-py3-none-any.whl", hash = "sha256:47debbde6af066a7e8e911f7193730d5e40d62effc1ac2e1119908347790a3ea", size = 16599, upload-time = "2025-07-29T15:41:48.332Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-django"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-wsgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5a/88/d88268c37aabbd2bcc54f4f868394316fa6fdfd3b91e011d229617d862d3/opentelemetry_instrumentation_django-0.57b0.tar.gz", hash = "sha256:df4116d2ea2c6bbbbf8853b843deb74d66bd0d573ddd372ec84fd60adaf977c6", size = 25005, upload-time = "2025-07-29T15:42:56.88Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/97/f0/1d5022f2fe16d50b79d9f1f5b70bd08d0e59819e0f6b237cff82c3dbda0f/opentelemetry_instrumentation_django-0.57b0-py3-none-any.whl", hash = "sha256:3d702d79a9ec0c836ccf733becf34630c6afb3c86c25c330c5b7601debe1e7c5", size = 19597, upload-time = "2025-07-29T15:42:00.657Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-falcon"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-wsgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "packaging" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/c2/8ccc7e90f587878f13b95c91eba43eadb2ad987eb92fce89177c5783c1e6/opentelemetry_instrumentation_falcon-0.57b0.tar.gz", hash = "sha256:8b37cd9868e7ef276ce85a6d95a16d91bcc67f3819060a1beea2ff5ba8fb9bc1", size = 17307, upload-time = "2025-07-29T15:42:58.046Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/df/d9a564cad9d02a3b35e3078ffa1791bd407e503581c72ab48418b0376614/opentelemetry_instrumentation_falcon-0.57b0-py3-none-any.whl", hash = "sha256:948209be98a020ee5b2fa894191dd83ded5f983bd4d8b2ebc98c11eb25bf1150", size = 14259, upload-time = "2025-07-29T15:42:02.382Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-fastapi"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-asgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/47/a8/7c22a33ff5986523a7f9afcb5f4d749533842c3cc77ef55b46727580edd0/opentelemetry_instrumentation_fastapi-0.57b0.tar.gz", hash = "sha256:73ac22f3c472a8f9cb21d1fbe5a4bf2797690c295fff4a1c040e9b1b1688a105", size = 20277, upload-time = "2025-07-29T15:42:58.68Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/df/f20fc21c88c7af5311bfefc15fc4e606bab5edb7c193aa8c73c354904c35/opentelemetry_instrumentation_fastapi-0.57b0-py3-none-any.whl", hash = "sha256:61e6402749ffe0bfec582e58155e0d81dd38723cd9bc4562bca1acca80334006", size = 12712, upload-time = "2025-07-29T15:42:03.332Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-flask"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-wsgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "packaging" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5f/98/8a8fa41f624069ac2912141b65bd528fd345d65e14a359c4d896fc3dc291/opentelemetry_instrumentation_flask-0.57b0.tar.gz", hash = "sha256:c5244a40b03664db966d844a32f43c900181431b77929be62a68d4907e86ed25", size = 19381, upload-time = "2025-07-29T15:42:59.38Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bb/3f/79b6c9a240221f5614a143eab6a0ecacdcb23b93cc35ff2b78234f68804f/opentelemetry_instrumentation_flask-0.57b0-py3-none-any.whl", hash = "sha256:5ecd614f194825725b61ee9ba8e37dcd4d3f9b5d40fef759df8650d6a91b1cb9", size = 14688, upload-time = "2025-07-29T15:42:04.162Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-httpx"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/01/28/65fea8b8e7f19502a8af1229c62384f9211c1480f5dee1776841810d6551/opentelemetry_instrumentation_httpx-0.57b0.tar.gz", hash = "sha256:ea5669cdb17185f8d247c2dbf756ae5b95b53110ca4d58424f2be5cc7223dbdd", size = 19511, upload-time = "2025-07-29T15:43:00.575Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bd/24/e59b319a5c6a41c6b4230f5e25651edbeb3a8d248afa1b411fd07cc3f9bf/opentelemetry_instrumentation_httpx-0.57b0-py3-none-any.whl", hash = "sha256:729fef97624016d3e5b03b71f51c9a1a2f7480b023373186d643fbed7496712a", size = 15111, upload-time = "2025-07-29T15:42:06.501Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-pyramid"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-wsgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/db/46/623c6dc12b8cd11fd588bdfb160b90148ed72671045623700844b14ae62c/opentelemetry_instrumentation_pyramid-0.57b0.tar.gz", hash = "sha256:dd87af46ae9a96b8a27da170d26aa9e7a903c2cbf87030250ca21b4ab383a729", size = 15005, upload-time = "2025-07-29T15:43:09.809Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8f/b7/03b0338393f4c6e8cfd2eb869ea27a78f11f90a8d9cf21fff89c4686c994/opentelemetry_instrumentation_pyramid-0.57b0-py3-none-any.whl", hash = "sha256:6b2fa0fe8082e7cfdd054c32a88c0456766aeb7567f0ad2ed0df8e1eb568d2a7", size = 13964, upload-time = "2025-07-29T15:42:21.384Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-requests"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0d/e1/01f5c28a60ffbc4c04946ad35bc8bf16382d333e41afaa042b31c35364b9/opentelemetry_instrumentation_requests-0.57b0.tar.gz", hash = "sha256:193bd3fd1f14737721876fb1952dffc7d43795586118df633a91ecd9057446ff", size = 15182, upload-time = "2025-07-29T15:43:11.812Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b5/7d/40144701fa22521e3b3fce23e2f0a5684a9385c90b119b70e7598b3cb607/opentelemetry_instrumentation_requests-0.57b0-py3-none-any.whl", hash = "sha256:66a576ac8080724ddc8a14c39d16bb5f430991bd504fdbea844c7a063f555971", size = 12966, upload-time = "2025-07-29T15:42:24.608Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-starlette"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-instrumentation-asgi" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/84/2c/bc7533a4b91dcf0e2d76c1f61cf42e90d17bbcb31de9000015284fea3bad/opentelemetry_instrumentation_starlette-0.57b0.tar.gz", hash = "sha256:d01c411f0189fe530c574f4392f83941a7845839af7ae6456ad00ac2aeb6441c", size = 14499, upload-time = "2025-07-29T15:43:13.515Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/16/5b/239cab1dccb2e2964c22157860da8178e8870e10b2250c208daac4678505/opentelemetry_instrumentation_starlette-0.57b0-py3-none-any.whl", hash = "sha256:be835509cc4192b5c4aa4fdafbcbb18a028bc329746d9c12e4693ad81f9c2cac", size = 11717, upload-time = "2025-07-29T15:42:28.896Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-tornado"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/bf/55/6e891b522700db14efe033d98fd4f4add0014fe803d9440638852a2592f9/opentelemetry_instrumentation_tornado-0.57b0.tar.gz", hash = "sha256:dcaa23dffb3bfb500de1013a75e4bcbca23870bd30d10ff6292a62aa03e8c2aa", size = 17590, upload-time = "2025-07-29T15:43:15.35Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/0f/d57e318e42114d013dcd674959fa0ea7ed59484fab59d37f345a5e7b9c65/opentelemetry_instrumentation_tornado-0.57b0-py3-none-any.whl", hash = "sha256:25ab57b3197c91f881ae7c6ab088652bbeb54f3b703d15de374cc62887a06d65", size = 15464, upload-time = "2025-07-29T15:42:32.779Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-urllib"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/86/a5/9d400dd978ac5e81356fe8435ca264e140a7d4cf77a88db43791d62311d5/opentelemetry_instrumentation_urllib-0.57b0.tar.gz", hash = "sha256:657225ceae8bb52b67bd5c26dcb8a33f0efb041f1baea4c59dbd1adbc63a4162", size = 13929, upload-time = "2025-07-29T15:43:16.498Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/47/3c9535a68b9dd125eb6a25c086984e5cee7285e4f36bfa37eeb40e95d2b5/opentelemetry_instrumentation_urllib-0.57b0-py3-none-any.whl", hash = "sha256:bb3a01172109a6f56bfcc38ea83b9d4a61c4c2cac6b9a190e757063daadf545c", size = 12671, upload-time = "2025-07-29T15:42:34.561Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-urllib3"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9a/2d/c241e9716c94704dbddf64e2c7367b57642425455befdbc622936bec78e9/opentelemetry_instrumentation_urllib3-0.57b0.tar.gz", hash = "sha256:f49d8c3d1d81ae56304a08b14a7f564d250733ed75cd2210ccef815b5af2eea1", size = 15790, upload-time = "2025-07-29T15:43:17.05Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/0e/a5467ab57d815caa58cbabb3a7f3906c3718c599221ac770482d13187306/opentelemetry_instrumentation_urllib3-0.57b0-py3-none-any.whl", hash = "sha256:337ecac6df3ff92026b51c64df7dd4a3fff52f2dc96036ea9371670243bf83c6", size = 13186, upload-time = "2025-07-29T15:42:35.775Z" },
-]
-
-[[package]]
-name = "opentelemetry-instrumentation-wsgi"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-instrumentation" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "opentelemetry-util-http" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f8/3f/d1ab49d68f2f6ebbe3c2fa5ff609ee5603a9cc68915203c454afb3a38d5b/opentelemetry_instrumentation_wsgi-0.57b0.tar.gz", hash = "sha256:d7e16b3b87930c30fc4c1bbc8b58c5dd6eefade493a3a5e7343bc24d572bc5b7", size = 18376, upload-time = "2025-07-29T15:43:17.683Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1f/0c/7760f9e14f4f8128e4880b4fd5f232ef4eb00cb29ee560c972dbf7801369/opentelemetry_instrumentation_wsgi-0.57b0-py3-none-any.whl", hash = "sha256:b9cf0c6e61489f7503fc17ef04d169bd214e7a825650ee492f5d2b4d73b17b54", size = 14450, upload-time = "2025-07-29T15:42:37.351Z" },
-]
-
-[[package]]
-name = "opentelemetry-proto"
-version = "1.36.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "protobuf" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/fd/02/f6556142301d136e3b7e95ab8ea6a5d9dc28d879a99f3dd673b5f97dca06/opentelemetry_proto-1.36.0.tar.gz", hash = "sha256:0f10b3c72f74c91e0764a5ec88fd8f1c368ea5d9c64639fb455e2854ef87dd2f", size = 46152, upload-time = "2025-07-29T15:12:15.717Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/57/3361e06136225be8180e879199caea520f38026f8071366241ac458beb8d/opentelemetry_proto-1.36.0-py3-none-any.whl", hash = "sha256:151b3bf73a09f94afc658497cf77d45a565606f62ce0c17acb08cd9937ca206e", size = 72537, upload-time = "2025-07-29T15:12:02.243Z" },
-]
-
-[[package]]
-name = "opentelemetry-sdk"
-version = "1.36.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "opentelemetry-semantic-conventions" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/85/8567a966b85a2d3f971c4d42f781c305b2b91c043724fa08fd37d158e9dc/opentelemetry_sdk-1.36.0.tar.gz", hash = "sha256:19c8c81599f51b71670661ff7495c905d8fdf6976e41622d5245b791b06fa581", size = 162557, upload-time = "2025-07-29T15:12:16.76Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/59/7bed362ad1137ba5886dac8439e84cd2df6d087be7c09574ece47ae9b22c/opentelemetry_sdk-1.36.0-py3-none-any.whl", hash = "sha256:19fe048b42e98c5c1ffe85b569b7073576ad4ce0bcb6e9b4c6a39e890a6c45fb", size = 119995, upload-time = "2025-07-29T15:12:03.181Z" },
-]
-
-[[package]]
-name = "opentelemetry-semantic-conventions"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "opentelemetry-api" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/7e/31/67dfa252ee88476a29200b0255bda8dfc2cf07b56ad66dc9a6221f7dc787/opentelemetry_semantic_conventions-0.57b0.tar.gz", hash = "sha256:609a4a79c7891b4620d64c7aac6898f872d790d75f22019913a660756f27ff32", size = 124225, upload-time = "2025-07-29T15:12:17.873Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/75/7d591371c6c39c73de5ce5da5a2cc7b72d1d1cd3f8f4638f553c01c37b11/opentelemetry_semantic_conventions-0.57b0-py3-none-any.whl", hash = "sha256:757f7e76293294f124c827e514c2a3144f191ef175b069ce8d1211e1e38e9e78", size = 201627, upload-time = "2025-07-29T15:12:04.174Z" },
-]
-
-[[package]]
-name = "opentelemetry-util-http"
-version = "0.57b0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9b/1b/6229c45445e08e798fa825f5376f6d6a4211d29052a4088eed6d577fa653/opentelemetry_util_http-0.57b0.tar.gz", hash = "sha256:f7417595ead0eb42ed1863ec9b2f839fc740368cd7bbbfc1d0a47bc1ab0aba11", size = 9405, upload-time = "2025-07-29T15:43:19.916Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/a6/b98d508d189b9c208f5978d0906141747d7e6df7c7cafec03657ed1ed559/opentelemetry_util_http-0.57b0-py3-none-any.whl", hash = "sha256:e54c0df5543951e471c3d694f85474977cd5765a3b7654398c83bab3d2ffb8e9", size = 7643, upload-time = "2025-07-29T15:42:41.744Z" },
-]
-
-[[package]]
-name = "orjson"
-version = "3.11.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/df/1d/5e0ae38788bdf0721326695e65fdf41405ed535f633eb0df0f06f57552fa/orjson-3.11.2.tar.gz", hash = "sha256:91bdcf5e69a8fd8e8bdb3de32b31ff01d2bd60c1e8d5fe7d5afabdcf19920309", size = 5470739, upload-time = "2025-08-12T15:12:28.626Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a1/7b/7aebe925c6b1c46c8606a960fe1d6b681fccd4aaf3f37cd647c3309d6582/orjson-3.11.2-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:d6b8a78c33496230a60dc9487118c284c15ebdf6724386057239641e1eb69761", size = 226896, upload-time = "2025-08-12T15:10:22.02Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/39/c952c9b0d51063e808117dd1e53668a2e4325cc63cfe7df453d853ee8680/orjson-3.11.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc04036eeae11ad4180d1f7b5faddb5dab1dee49ecd147cd431523869514873b", size = 111845, upload-time = "2025-08-12T15:10:24.963Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/dc/90b7f29be38745eeacc30903b693f29fcc1097db0c2a19a71ffb3e9f2a5f/orjson-3.11.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9c04325839c5754c253ff301cee8aaed7442d974860a44447bb3be785c411c27", size = 116395, upload-time = "2025-08-12T15:10:26.314Z" },
-    { url = "https://files.pythonhosted.org/packages/10/c2/fe84ba63164c22932b8d59b8810e2e58590105293a259e6dd1bfaf3422c9/orjson-3.11.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32769e04cd7fdc4a59854376211145a1bbbc0aea5e9d6c9755d3d3c301d7c0df", size = 118768, upload-time = "2025-08-12T15:10:27.605Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/ce/d9748ec69b1a4c29b8e2bab8233e8c41c583c69f515b373f1fb00247d8c9/orjson-3.11.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0ff285d14917ea1408a821786e3677c5261fa6095277410409c694b8e7720ae0", size = 120887, upload-time = "2025-08-12T15:10:29.153Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/66/b90fac8e4a76e83f981912d7f9524d402b31f6c1b8bff3e498aa321c326c/orjson-3.11.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2662f908114864b63ff75ffe6ffacf996418dd6cc25e02a72ad4bda81b1ec45a", size = 123650, upload-time = "2025-08-12T15:10:30.602Z" },
-    { url = "https://files.pythonhosted.org/packages/33/81/56143898d1689c7f915ac67703efb97e8f2f8d5805ce8c2c3fd0f2bb6e3d/orjson-3.11.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab463cf5d08ad6623a4dac1badd20e88a5eb4b840050c4812c782e3149fe2334", size = 121287, upload-time = "2025-08-12T15:10:31.868Z" },
-    { url = "https://files.pythonhosted.org/packages/80/de/f9c6d00c127be766a3739d0d85b52a7c941e437d8dd4d573e03e98d0f89c/orjson-3.11.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:64414241bde943cbf3c00d45fcb5223dca6d9210148ba984aae6b5d63294502b", size = 119637, upload-time = "2025-08-12T15:10:33.078Z" },
-    { url = "https://files.pythonhosted.org/packages/67/4c/ab70c7627022d395c1b4eb5badf6196b7144e82b46a3a17ed2354f9e592d/orjson-3.11.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:7773e71c0ae8c9660192ff144a3d69df89725325e3d0b6a6bb2c50e5ebaf9b84", size = 392478, upload-time = "2025-08-12T15:10:34.669Z" },
-    { url = "https://files.pythonhosted.org/packages/77/91/d890b873b69311db4fae2624c5603c437df9c857fb061e97706dac550a77/orjson-3.11.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:652ca14e283b13ece35bf3a86503c25592f294dbcfc5bb91b20a9c9a62a3d4be", size = 134343, upload-time = "2025-08-12T15:10:35.978Z" },
-    { url = "https://files.pythonhosted.org/packages/47/16/1aa248541b4830274a079c4aeb2aa5d1ff17c3f013b1d0d8d16d0848f3de/orjson-3.11.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:26e99e98df8990ecfe3772bbdd7361f602149715c2cbc82e61af89bfad9528a4", size = 123887, upload-time = "2025-08-12T15:10:37.601Z" },
-    { url = "https://files.pythonhosted.org/packages/95/e4/7419833c55ac8b5f385d00c02685a260da1f391e900fc5c3e0b797e0d506/orjson-3.11.2-cp310-cp310-win32.whl", hash = "sha256:5814313b3e75a2be7fe6c7958201c16c4560e21a813dbad25920752cecd6ad66", size = 124560, upload-time = "2025-08-12T15:10:38.966Z" },
-    { url = "https://files.pythonhosted.org/packages/74/f8/27ca7ef3e194c462af32ce1883187f5ec483650c559166f0de59c4c2c5f0/orjson-3.11.2-cp310-cp310-win_amd64.whl", hash = "sha256:dc471ce2225ab4c42ca672f70600d46a8b8e28e8d4e536088c1ccdb1d22b35ce", size = 119700, upload-time = "2025-08-12T15:10:40.911Z" },
-    { url = "https://files.pythonhosted.org/packages/78/7d/e295df1ac9920cbb19fb4c1afa800e86f175cb657143aa422337270a4782/orjson-3.11.2-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:888b64ef7eaeeff63f773881929434a5834a6a140a63ad45183d59287f07fc6a", size = 226502, upload-time = "2025-08-12T15:10:42.284Z" },
-    { url = "https://files.pythonhosted.org/packages/65/21/ffb0f10ea04caf418fb4e7ad1fda4b9ab3179df9d7a33b69420f191aadd5/orjson-3.11.2-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:83387cc8b26c9fa0ae34d1ea8861a7ae6cff8fb3e346ab53e987d085315a728e", size = 115999, upload-time = "2025-08-12T15:10:43.738Z" },
-    { url = "https://files.pythonhosted.org/packages/90/d5/8da1e252ac3353d92e6f754ee0c85027c8a2cda90b6899da2be0df3ef83d/orjson-3.11.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7e35f003692c216d7ee901b6b916b5734d6fc4180fcaa44c52081f974c08e17", size = 111563, upload-time = "2025-08-12T15:10:45.301Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/81/baabc32e52c570b0e4e1044b1bd2ccbec965e0de3ba2c13082255efa2006/orjson-3.11.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4a0a4c29ae90b11d0c00bcc31533854d89f77bde2649ec602f512a7e16e00640", size = 116222, upload-time = "2025-08-12T15:10:46.92Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/b7/da2ad55ad80b49b560dce894c961477d0e76811ee6e614b301de9f2f8728/orjson-3.11.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:585d712b1880f68370108bc5534a257b561672d1592fae54938738fe7f6f1e33", size = 118594, upload-time = "2025-08-12T15:10:48.488Z" },
-    { url = "https://files.pythonhosted.org/packages/61/be/014f7eab51449f3c894aa9bbda2707b5340c85650cb7d0db4ec9ae280501/orjson-3.11.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d08e342a7143f8a7c11f1c4033efe81acbd3c98c68ba1b26b96080396019701f", size = 120700, upload-time = "2025-08-12T15:10:49.811Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/ae/c217903a30c51341868e2d8c318c59a8413baa35af54d7845071c8ccd6fe/orjson-3.11.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:29c0f84fc50398773a702732c87cd622737bf11c0721e6db3041ac7802a686fb", size = 123433, upload-time = "2025-08-12T15:10:51.06Z" },
-    { url = "https://files.pythonhosted.org/packages/57/c2/b3c346f78b1ff2da310dd300cb0f5d32167f872b4d3bb1ad122c889d97b0/orjson-3.11.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:140f84e3c8d4c142575898c91e3981000afebf0333df753a90b3435d349a5fe5", size = 121061, upload-time = "2025-08-12T15:10:52.381Z" },
-    { url = "https://files.pythonhosted.org/packages/00/c8/c97798f6010327ffc75ad21dd6bca11ea2067d1910777e798c2849f1c68f/orjson-3.11.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:96304a2b7235e0f3f2d9363ddccdbfb027d27338722fe469fe656832a017602e", size = 119410, upload-time = "2025-08-12T15:10:53.692Z" },
-    { url = "https://files.pythonhosted.org/packages/37/fd/df720f7c0e35694617b7f95598b11a2cb0374661d8389703bea17217da53/orjson-3.11.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:3d7612bb227d5d9582f1f50a60bd55c64618fc22c4a32825d233a4f2771a428a", size = 392294, upload-time = "2025-08-12T15:10:55.079Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/52/0120d18f60ab0fe47531d520372b528a45c9a25dcab500f450374421881c/orjson-3.11.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a134587d18fe493befc2defffef2a8d27cfcada5696cb7234de54a21903ae89a", size = 134134, upload-time = "2025-08-12T15:10:56.568Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/10/1f967671966598366de42f07e92b0fc694ffc66eafa4b74131aeca84915f/orjson-3.11.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0b84455e60c4bc12c1e4cbaa5cfc1acdc7775a9da9cec040e17232f4b05458bd", size = 123745, upload-time = "2025-08-12T15:10:57.907Z" },
-    { url = "https://files.pythonhosted.org/packages/43/eb/76081238671461cfd0f47e0c24f408ffa66184237d56ef18c33e86abb612/orjson-3.11.2-cp311-cp311-win32.whl", hash = "sha256:f0660efeac223f0731a70884e6914a5f04d613b5ae500744c43f7bf7b78f00f9", size = 124393, upload-time = "2025-08-12T15:10:59.267Z" },
-    { url = "https://files.pythonhosted.org/packages/26/76/cc598c1811ba9ba935171267b02e377fc9177489efce525d478a2999d9cc/orjson-3.11.2-cp311-cp311-win_amd64.whl", hash = "sha256:955811c8405251d9e09cbe8606ad8fdef49a451bcf5520095a5ed38c669223d8", size = 119561, upload-time = "2025-08-12T15:11:00.559Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/17/c48011750f0489006f7617b0a3cebc8230f36d11a34e7e9aca2085f07792/orjson-3.11.2-cp311-cp311-win_arm64.whl", hash = "sha256:2e4d423a6f838552e3a6d9ec734b729f61f88b1124fd697eab82805ea1a2a97d", size = 114186, upload-time = "2025-08-12T15:11:01.931Z" },
-    { url = "https://files.pythonhosted.org/packages/40/02/46054ebe7996a8adee9640dcad7d39d76c2000dc0377efa38e55dc5cbf78/orjson-3.11.2-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:901d80d349d8452162b3aa1afb82cec5bee79a10550660bc21311cc61a4c5486", size = 226528, upload-time = "2025-08-12T15:11:03.317Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/c6/6b6f0b4d8aea1137436546b990f71be2cd8bd870aa2f5aa14dba0fcc95dc/orjson-3.11.2-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:cf3bd3967a360e87ee14ed82cb258b7f18c710dacf3822fb0042a14313a673a1", size = 115931, upload-time = "2025-08-12T15:11:04.759Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/05/4205cc97c30e82a293dd0d149b1a89b138ebe76afeca66fc129fa2aa4e6a/orjson-3.11.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26693dde66910078229a943e80eeb99fdce6cd2c26277dc80ead9f3ab97d2131", size = 111382, upload-time = "2025-08-12T15:11:06.468Z" },
-    { url = "https://files.pythonhosted.org/packages/50/c7/b8a951a93caa821f9272a7c917115d825ae2e4e8768f5ddf37968ec9de01/orjson-3.11.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4ad4c8acb50a28211c33fc7ef85ddf5cb18d4636a5205fd3fa2dce0411a0e30c", size = 116271, upload-time = "2025-08-12T15:11:07.845Z" },
-    { url = "https://files.pythonhosted.org/packages/17/03/1006c7f8782d5327439e26d9b0ec66500ea7b679d4bbb6b891d2834ab3ee/orjson-3.11.2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:994181e7f1725bb5f2d481d7d228738e0743b16bf319ca85c29369c65913df14", size = 119086, upload-time = "2025-08-12T15:11:09.329Z" },
-    { url = "https://files.pythonhosted.org/packages/44/61/57d22bc31f36a93878a6f772aea76b2184102c6993dea897656a66d18c74/orjson-3.11.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dbb79a0476393c07656b69c8e763c3cc925fa8e1d9e9b7d1f626901bb5025448", size = 120724, upload-time = "2025-08-12T15:11:10.674Z" },
-    { url = "https://files.pythonhosted.org/packages/78/a9/4550e96b4c490c83aea697d5347b8f7eb188152cd7b5a38001055ca5b379/orjson-3.11.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:191ed27a1dddb305083d8716af413d7219f40ec1d4c9b0e977453b4db0d6fb6c", size = 123577, upload-time = "2025-08-12T15:11:12.015Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/86/09b8cb3ebd513d708ef0c92d36ac3eebda814c65c72137b0a82d6d688fc4/orjson-3.11.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0afb89f16f07220183fd00f5f297328ed0a68d8722ad1b0c8dcd95b12bc82804", size = 121195, upload-time = "2025-08-12T15:11:13.399Z" },
-    { url = "https://files.pythonhosted.org/packages/37/68/7b40b39ac2c1c644d4644e706d0de6c9999764341cd85f2a9393cb387661/orjson-3.11.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6ab6e6b4e93b1573a026b6ec16fca9541354dd58e514b62c558b58554ae04307", size = 119234, upload-time = "2025-08-12T15:11:15.134Z" },
-    { url = "https://files.pythonhosted.org/packages/40/7c/bb6e7267cd80c19023d44d8cbc4ea4ed5429fcd4a7eb9950f50305697a28/orjson-3.11.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:9cb23527efb61fb75527df55d20ee47989c4ee34e01a9c98ee9ede232abf6219", size = 392250, upload-time = "2025-08-12T15:11:16.604Z" },
-    { url = "https://files.pythonhosted.org/packages/64/f2/6730ace05583dbca7c1b406d59f4266e48cd0d360566e71482420fb849fc/orjson-3.11.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a4dd1268e4035af21b8a09e4adf2e61f87ee7bf63b86d7bb0a237ac03fad5b45", size = 134572, upload-time = "2025-08-12T15:11:18.205Z" },
-    { url = "https://files.pythonhosted.org/packages/96/0f/7d3e03a30d5aac0432882b539a65b8c02cb6dd4221ddb893babf09c424cc/orjson-3.11.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ff8b155b145eaf5a9d94d2c476fbe18d6021de93cf36c2ae2c8c5b775763f14e", size = 123869, upload-time = "2025-08-12T15:11:19.554Z" },
-    { url = "https://files.pythonhosted.org/packages/45/80/1513265eba6d4a960f078f4b1d2bff94a571ab2d28c6f9835e03dfc65cc6/orjson-3.11.2-cp312-cp312-win32.whl", hash = "sha256:ae3bb10279d57872f9aba68c9931aa71ed3b295fa880f25e68da79e79453f46e", size = 124430, upload-time = "2025-08-12T15:11:20.914Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/61/eadf057b68a332351eeb3d89a4cc538d14f31cd8b5ec1b31a280426ccca2/orjson-3.11.2-cp312-cp312-win_amd64.whl", hash = "sha256:d026e1967239ec11a2559b4146a61d13914504b396f74510a1c4d6b19dfd8732", size = 119598, upload-time = "2025-08-12T15:11:22.372Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/3f/7f4b783402143d965ab7e9a2fc116fdb887fe53bdce7d3523271cd106098/orjson-3.11.2-cp312-cp312-win_arm64.whl", hash = "sha256:59f8d5ad08602711af9589375be98477d70e1d102645430b5a7985fdbf613b36", size = 114052, upload-time = "2025-08-12T15:11:23.762Z" },
-]
-
-[[package]]
-name = "packaging"
-version = "25.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
-]
-
-[[package]]
-name = "pandas"
-version = "2.3.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-    { name = "python-dateutil" },
-    { name = "pytz" },
-    { name = "tzdata" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/79/8e/0e90233ac205ad182bd6b422532695d2b9414944a280488105d598c70023/pandas-2.3.2.tar.gz", hash = "sha256:ab7b58f8f82706890924ccdfb5f48002b83d2b5a3845976a9fb705d36c34dcdb", size = 4488684, upload-time = "2025-08-21T10:28:29.257Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/16/a8eeb70aad84ccbf14076793f90e0031eded63c1899aeae9fdfbf37881f4/pandas-2.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:52bc29a946304c360561974c6542d1dd628ddafa69134a7131fdfd6a5d7a1a35", size = 11539648, upload-time = "2025-08-21T10:26:36.236Z" },
-    { url = "https://files.pythonhosted.org/packages/47/f1/c5bdaea13bf3708554d93e948b7ea74121ce6e0d59537ca4c4f77731072b/pandas-2.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:220cc5c35ffaa764dd5bb17cf42df283b5cb7fdf49e10a7b053a06c9cb48ee2b", size = 10786923, upload-time = "2025-08-21T10:26:40.518Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/10/811fa01476d29ffed692e735825516ad0e56d925961819e6126b4ba32147/pandas-2.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42c05e15111221384019897df20c6fe893b2f697d03c811ee67ec9e0bb5a3424", size = 11726241, upload-time = "2025-08-21T10:26:43.175Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/6a/40b043b06e08df1ea1b6d20f0e0c2f2c4ec8c4f07d1c92948273d943a50b/pandas-2.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc03acc273c5515ab69f898df99d9d4f12c4d70dbfc24c3acc6203751d0804cf", size = 12349533, upload-time = "2025-08-21T10:26:46.611Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/ea/2e081a2302e41a9bca7056659fdd2b85ef94923723e41665b42d65afd347/pandas-2.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d25c20a03e8870f6339bcf67281b946bd20b86f1a544ebbebb87e66a8d642cba", size = 13202407, upload-time = "2025-08-21T10:26:49.068Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/12/7ff9f6a79e2ee8869dcf70741ef998b97ea20050fe25f83dc759764c1e32/pandas-2.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:21bb612d148bb5860b7eb2c10faacf1a810799245afd342cf297d7551513fbb6", size = 13837212, upload-time = "2025-08-21T10:26:51.832Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/df/5ab92fcd76455a632b3db34a746e1074d432c0cdbbd28d7cd1daba46a75d/pandas-2.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:b62d586eb25cb8cb70a5746a378fc3194cb7f11ea77170d59f889f5dfe3cec7a", size = 11338099, upload-time = "2025-08-21T10:26:54.382Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/59/f3e010879f118c2d400902d2d871c2226cef29b08c09fb8dc41111730400/pandas-2.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1333e9c299adcbb68ee89a9bb568fc3f20f9cbb419f1dd5225071e6cddb2a743", size = 11563308, upload-time = "2025-08-21T10:26:56.656Z" },
-    { url = "https://files.pythonhosted.org/packages/38/18/48f10f1cc5c397af59571d638d211f494dba481f449c19adbd282aa8f4ca/pandas-2.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:76972bcbd7de8e91ad5f0ca884a9f2c477a2125354af624e022c49e5bd0dfff4", size = 10820319, upload-time = "2025-08-21T10:26:59.162Z" },
-    { url = "https://files.pythonhosted.org/packages/95/3b/1e9b69632898b048e223834cd9702052bcf06b15e1ae716eda3196fb972e/pandas-2.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b98bdd7c456a05eef7cd21fd6b29e3ca243591fe531c62be94a2cc987efb5ac2", size = 11790097, upload-time = "2025-08-21T10:27:02.204Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/ef/0e2ffb30b1f7fbc9a588bd01e3c14a0d96854d09a887e15e30cc19961227/pandas-2.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1d81573b3f7db40d020983f78721e9bfc425f411e616ef019a10ebf597aedb2e", size = 12397958, upload-time = "2025-08-21T10:27:05.409Z" },
-    { url = "https://files.pythonhosted.org/packages/23/82/e6b85f0d92e9afb0e7f705a51d1399b79c7380c19687bfbf3d2837743249/pandas-2.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e190b738675a73b581736cc8ec71ae113d6c3768d0bd18bffa5b9a0927b0b6ea", size = 13225600, upload-time = "2025-08-21T10:27:07.791Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/f1/f682015893d9ed51611948bd83683670842286a8edd4f68c2c1c3b231eef/pandas-2.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c253828cb08f47488d60f43c5fc95114c771bbfff085da54bfc79cb4f9e3a372", size = 13879433, upload-time = "2025-08-21T10:27:10.347Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/e7/ae86261695b6c8a36d6a4c8d5f9b9ede8248510d689a2f379a18354b37d7/pandas-2.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:9467697b8083f9667b212633ad6aa4ab32436dcbaf4cd57325debb0ddef2012f", size = 11336557, upload-time = "2025-08-21T10:27:12.983Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/db/614c20fb7a85a14828edd23f1c02db58a30abf3ce76f38806155d160313c/pandas-2.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fbb977f802156e7a3f829e9d1d5398f6192375a3e2d1a9ee0803e35fe70a2b9", size = 11587652, upload-time = "2025-08-21T10:27:15.888Z" },
-    { url = "https://files.pythonhosted.org/packages/99/b0/756e52f6582cade5e746f19bad0517ff27ba9c73404607c0306585c201b3/pandas-2.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1b9b52693123dd234b7c985c68b709b0b009f4521000d0525f2b95c22f15944b", size = 10717686, upload-time = "2025-08-21T10:27:18.486Z" },
-    { url = "https://files.pythonhosted.org/packages/37/4c/dd5ccc1e357abfeee8353123282de17997f90ff67855f86154e5a13b81e5/pandas-2.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bd281310d4f412733f319a5bc552f86d62cddc5f51d2e392c8787335c994175", size = 11278722, upload-time = "2025-08-21T10:27:21.149Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/a4/f7edcfa47e0a88cda0be8b068a5bae710bf264f867edfdf7b71584ace362/pandas-2.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:96d31a6b4354e3b9b8a2c848af75d31da390657e3ac6f30c05c82068b9ed79b9", size = 11987803, upload-time = "2025-08-21T10:27:23.767Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/61/1bce4129f93ab66f1c68b7ed1c12bac6a70b1b56c5dab359c6bbcd480b52/pandas-2.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:df4df0b9d02bb873a106971bb85d448378ef14b86ba96f035f50bbd3688456b4", size = 12766345, upload-time = "2025-08-21T10:27:26.6Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/46/80d53de70fee835531da3a1dae827a1e76e77a43ad22a8cd0f8142b61587/pandas-2.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:213a5adf93d020b74327cb2c1b842884dbdd37f895f42dcc2f09d451d949f811", size = 13439314, upload-time = "2025-08-21T10:27:29.213Z" },
-    { url = "https://files.pythonhosted.org/packages/28/30/8114832daff7489f179971dbc1d854109b7f4365a546e3ea75b6516cea95/pandas-2.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c13b81a9347eb8c7548f53fd9a4f08d4dfe996836543f805c987bafa03317ae", size = 10983326, upload-time = "2025-08-21T10:27:31.901Z" },
-]
-
-[[package]]
-name = "propcache"
-version = "0.3.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/16/43264e4a779dd8588c21a70f0709665ee8f611211bdd2c87d952cfa7c776/propcache-0.3.2.tar.gz", hash = "sha256:20d7d62e4e7ef05f221e0db2856b979540686342e7dd9973b815599c7057e168", size = 44139, upload-time = "2025-06-09T22:56:06.081Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ab/14/510deed325e262afeb8b360043c5d7c960da7d3ecd6d6f9496c9c56dc7f4/propcache-0.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:22d9962a358aedbb7a2e36187ff273adeaab9743373a272976d2e348d08c7770", size = 73178, upload-time = "2025-06-09T22:53:40.126Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/4e/ad52a7925ff01c1325653a730c7ec3175a23f948f08626a534133427dcff/propcache-0.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0d0fda578d1dc3f77b6b5a5dce3b9ad69a8250a891760a548df850a5e8da87f3", size = 43133, upload-time = "2025-06-09T22:53:41.965Z" },
-    { url = "https://files.pythonhosted.org/packages/63/7c/e9399ba5da7780871db4eac178e9c2e204c23dd3e7d32df202092a1ed400/propcache-0.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3def3da3ac3ce41562d85db655d18ebac740cb3fa4367f11a52b3da9d03a5cc3", size = 43039, upload-time = "2025-06-09T22:53:43.268Z" },
-    { url = "https://files.pythonhosted.org/packages/22/e1/58da211eb8fdc6fc854002387d38f415a6ca5f5c67c1315b204a5d3e9d7a/propcache-0.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9bec58347a5a6cebf239daba9bda37dffec5b8d2ce004d9fe4edef3d2815137e", size = 201903, upload-time = "2025-06-09T22:53:44.872Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/0a/550ea0f52aac455cb90111c8bab995208443e46d925e51e2f6ebdf869525/propcache-0.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55ffda449a507e9fbd4aca1a7d9aa6753b07d6166140e5a18d2ac9bc49eac220", size = 213362, upload-time = "2025-06-09T22:53:46.707Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/af/9893b7d878deda9bb69fcf54600b247fba7317761b7db11fede6e0f28bd0/propcache-0.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:64a67fb39229a8a8491dd42f864e5e263155e729c2e7ff723d6e25f596b1e8cb", size = 210525, upload-time = "2025-06-09T22:53:48.547Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/bb/38fd08b278ca85cde36d848091ad2b45954bc5f15cce494bb300b9285831/propcache-0.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9da1cf97b92b51253d5b68cf5a2b9e0dafca095e36b7f2da335e27dc6172a614", size = 198283, upload-time = "2025-06-09T22:53:50.067Z" },
-    { url = "https://files.pythonhosted.org/packages/78/8c/9fe55bd01d362bafb413dfe508c48753111a1e269737fa143ba85693592c/propcache-0.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5f559e127134b07425134b4065be45b166183fdcb433cb6c24c8e4149056ad50", size = 191872, upload-time = "2025-06-09T22:53:51.438Z" },
-    { url = "https://files.pythonhosted.org/packages/54/14/4701c33852937a22584e08abb531d654c8bcf7948a8f87ad0a4822394147/propcache-0.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:aff2e4e06435d61f11a428360a932138d0ec288b0a31dd9bd78d200bd4a2b339", size = 199452, upload-time = "2025-06-09T22:53:53.229Z" },
-    { url = "https://files.pythonhosted.org/packages/16/44/447f2253d859602095356007657ee535e0093215ea0b3d1d6a41d16e5201/propcache-0.3.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:4927842833830942a5d0a56e6f4839bc484785b8e1ce8d287359794818633ba0", size = 191567, upload-time = "2025-06-09T22:53:54.541Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/b3/e4756258749bb2d3b46defcff606a2f47410bab82be5824a67e84015b267/propcache-0.3.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:6107ddd08b02654a30fb8ad7a132021759d750a82578b94cd55ee2772b6ebea2", size = 193015, upload-time = "2025-06-09T22:53:56.44Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/df/e6d3c7574233164b6330b9fd697beeac402afd367280e6dc377bb99b43d9/propcache-0.3.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:70bd8b9cd6b519e12859c99f3fc9a93f375ebd22a50296c3a295028bea73b9e7", size = 204660, upload-time = "2025-06-09T22:53:57.839Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/53/e4d31dd5170b4a0e2e6b730f2385a96410633b4833dc25fe5dffd1f73294/propcache-0.3.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2183111651d710d3097338dd1893fcf09c9f54e27ff1a8795495a16a469cc90b", size = 206105, upload-time = "2025-06-09T22:53:59.638Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/fe/74d54cf9fbe2a20ff786e5f7afcfde446588f0cf15fb2daacfbc267b866c/propcache-0.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:fb075ad271405dcad8e2a7ffc9a750a3bf70e533bd86e89f0603e607b93aa64c", size = 196980, upload-time = "2025-06-09T22:54:01.071Z" },
-    { url = "https://files.pythonhosted.org/packages/22/ec/c469c9d59dada8a7679625e0440b544fe72e99311a4679c279562051f6fc/propcache-0.3.2-cp310-cp310-win32.whl", hash = "sha256:404d70768080d3d3bdb41d0771037da19d8340d50b08e104ca0e7f9ce55fce70", size = 37679, upload-time = "2025-06-09T22:54:03.003Z" },
-    { url = "https://files.pythonhosted.org/packages/38/35/07a471371ac89d418f8d0b699c75ea6dca2041fbda360823de21f6a9ce0a/propcache-0.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:7435d766f978b4ede777002e6b3b6641dd229cd1da8d3d3106a45770365f9ad9", size = 41459, upload-time = "2025-06-09T22:54:04.134Z" },
-    { url = "https://files.pythonhosted.org/packages/80/8d/e8b436717ab9c2cfc23b116d2c297305aa4cd8339172a456d61ebf5669b8/propcache-0.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0b8d2f607bd8f80ddc04088bc2a037fdd17884a6fcadc47a96e334d72f3717be", size = 74207, upload-time = "2025-06-09T22:54:05.399Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/29/1e34000e9766d112171764b9fa3226fa0153ab565d0c242c70e9945318a7/propcache-0.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:06766d8f34733416e2e34f46fea488ad5d60726bb9481d3cddf89a6fa2d9603f", size = 43648, upload-time = "2025-06-09T22:54:08.023Z" },
-    { url = "https://files.pythonhosted.org/packages/46/92/1ad5af0df781e76988897da39b5f086c2bf0f028b7f9bd1f409bb05b6874/propcache-0.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2dc1f4a1df4fecf4e6f68013575ff4af84ef6f478fe5344317a65d38a8e6dc9", size = 43496, upload-time = "2025-06-09T22:54:09.228Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/ce/e96392460f9fb68461fabab3e095cb00c8ddf901205be4eae5ce246e5b7e/propcache-0.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be29c4f4810c5789cf10ddf6af80b041c724e629fa51e308a7a0fb19ed1ef7bf", size = 217288, upload-time = "2025-06-09T22:54:10.466Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/2a/866726ea345299f7ceefc861a5e782b045545ae6940851930a6adaf1fca6/propcache-0.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59d61f6970ecbd8ff2e9360304d5c8876a6abd4530cb752c06586849ac8a9dc9", size = 227456, upload-time = "2025-06-09T22:54:11.828Z" },
-    { url = "https://files.pythonhosted.org/packages/de/03/07d992ccb6d930398689187e1b3c718339a1c06b8b145a8d9650e4726166/propcache-0.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:62180e0b8dbb6b004baec00a7983e4cc52f5ada9cd11f48c3528d8cfa7b96a66", size = 225429, upload-time = "2025-06-09T22:54:13.823Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/e6/116ba39448753b1330f48ab8ba927dcd6cf0baea8a0ccbc512dfb49ba670/propcache-0.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c144ca294a204c470f18cf4c9d78887810d04a3e2fbb30eea903575a779159df", size = 213472, upload-time = "2025-06-09T22:54:15.232Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/85/f01f5d97e54e428885a5497ccf7f54404cbb4f906688a1690cd51bf597dc/propcache-0.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5c2a784234c28854878d68978265617aa6dc0780e53d44b4d67f3651a17a9a2", size = 204480, upload-time = "2025-06-09T22:54:17.104Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/79/7bf5ab9033b8b8194cc3f7cf1aaa0e9c3256320726f64a3e1f113a812dce/propcache-0.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5745bc7acdafa978ca1642891b82c19238eadc78ba2aaa293c6863b304e552d7", size = 214530, upload-time = "2025-06-09T22:54:18.512Z" },
-    { url = "https://files.pythonhosted.org/packages/31/0b/bd3e0c00509b609317df4a18e6b05a450ef2d9a963e1d8bc9c9415d86f30/propcache-0.3.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:c0075bf773d66fa8c9d41f66cc132ecc75e5bb9dd7cce3cfd14adc5ca184cb95", size = 205230, upload-time = "2025-06-09T22:54:19.947Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/23/fae0ff9b54b0de4e819bbe559508da132d5683c32d84d0dc2ccce3563ed4/propcache-0.3.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5f57aa0847730daceff0497f417c9de353c575d8da3579162cc74ac294c5369e", size = 206754, upload-time = "2025-06-09T22:54:21.716Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/7f/ad6a3c22630aaa5f618b4dc3c3598974a72abb4c18e45a50b3cdd091eb2f/propcache-0.3.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:eef914c014bf72d18efb55619447e0aecd5fb7c2e3fa7441e2e5d6099bddff7e", size = 218430, upload-time = "2025-06-09T22:54:23.17Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/2c/ba4f1c0e8a4b4c75910742f0d333759d441f65a1c7f34683b4a74c0ee015/propcache-0.3.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2a4092e8549031e82facf3decdbc0883755d5bbcc62d3aea9d9e185549936dcf", size = 223884, upload-time = "2025-06-09T22:54:25.539Z" },
-    { url = "https://files.pythonhosted.org/packages/88/e4/ebe30fc399e98572019eee82ad0caf512401661985cbd3da5e3140ffa1b0/propcache-0.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:85871b050f174bc0bfb437efbdb68aaf860611953ed12418e4361bc9c392749e", size = 211480, upload-time = "2025-06-09T22:54:26.892Z" },
-    { url = "https://files.pythonhosted.org/packages/96/0a/7d5260b914e01d1d0906f7f38af101f8d8ed0dc47426219eeaf05e8ea7c2/propcache-0.3.2-cp311-cp311-win32.whl", hash = "sha256:36c8d9b673ec57900c3554264e630d45980fd302458e4ac801802a7fd2ef7897", size = 37757, upload-time = "2025-06-09T22:54:28.241Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/2d/89fe4489a884bc0da0c3278c552bd4ffe06a1ace559db5ef02ef24ab446b/propcache-0.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53af8cb6a781b02d2ea079b5b853ba9430fcbe18a8e3ce647d5982a3ff69f39", size = 41500, upload-time = "2025-06-09T22:54:29.4Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/42/9ca01b0a6f48e81615dca4765a8f1dd2c057e0540f6116a27dc5ee01dfb6/propcache-0.3.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8de106b6c84506b31c27168582cd3cb3000a6412c16df14a8628e5871ff83c10", size = 73674, upload-time = "2025-06-09T22:54:30.551Z" },
-    { url = "https://files.pythonhosted.org/packages/af/6e/21293133beb550f9c901bbece755d582bfaf2176bee4774000bd4dd41884/propcache-0.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:28710b0d3975117239c76600ea351934ac7b5ff56e60953474342608dbbb6154", size = 43570, upload-time = "2025-06-09T22:54:32.296Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/c8/0393a0a3a2b8760eb3bde3c147f62b20044f0ddac81e9d6ed7318ec0d852/propcache-0.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce26862344bdf836650ed2487c3d724b00fbfec4233a1013f597b78c1cb73615", size = 43094, upload-time = "2025-06-09T22:54:33.929Z" },
-    { url = "https://files.pythonhosted.org/packages/37/2c/489afe311a690399d04a3e03b069225670c1d489eb7b044a566511c1c498/propcache-0.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bca54bd347a253af2cf4544bbec232ab982f4868de0dd684246b67a51bc6b1db", size = 226958, upload-time = "2025-06-09T22:54:35.186Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/ca/63b520d2f3d418c968bf596839ae26cf7f87bead026b6192d4da6a08c467/propcache-0.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55780d5e9a2ddc59711d727226bb1ba83a22dd32f64ee15594b9392b1f544eb1", size = 234894, upload-time = "2025-06-09T22:54:36.708Z" },
-    { url = "https://files.pythonhosted.org/packages/11/60/1d0ed6fff455a028d678df30cc28dcee7af77fa2b0e6962ce1df95c9a2a9/propcache-0.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:035e631be25d6975ed87ab23153db6a73426a48db688070d925aa27e996fe93c", size = 233672, upload-time = "2025-06-09T22:54:38.062Z" },
-    { url = "https://files.pythonhosted.org/packages/37/7c/54fd5301ef38505ab235d98827207176a5c9b2aa61939b10a460ca53e123/propcache-0.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ee6f22b6eaa39297c751d0e80c0d3a454f112f5c6481214fcf4c092074cecd67", size = 224395, upload-time = "2025-06-09T22:54:39.634Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/1a/89a40e0846f5de05fdc6779883bf46ba980e6df4d2ff8fb02643de126592/propcache-0.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ca3aee1aa955438c4dba34fc20a9f390e4c79967257d830f137bd5a8a32ed3b", size = 212510, upload-time = "2025-06-09T22:54:41.565Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/33/ca98368586c9566a6b8d5ef66e30484f8da84c0aac3f2d9aec6d31a11bd5/propcache-0.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7a4f30862869fa2b68380d677cc1c5fcf1e0f2b9ea0cf665812895c75d0ca3b8", size = 222949, upload-time = "2025-06-09T22:54:43.038Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/11/ace870d0aafe443b33b2f0b7efdb872b7c3abd505bfb4890716ad7865e9d/propcache-0.3.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b77ec3c257d7816d9f3700013639db7491a434644c906a2578a11daf13176251", size = 217258, upload-time = "2025-06-09T22:54:44.376Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/d2/86fd6f7adffcfc74b42c10a6b7db721d1d9ca1055c45d39a1a8f2a740a21/propcache-0.3.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cab90ac9d3f14b2d5050928483d3d3b8fb6b4018893fc75710e6aa361ecb2474", size = 213036, upload-time = "2025-06-09T22:54:46.243Z" },
-    { url = "https://files.pythonhosted.org/packages/07/94/2d7d1e328f45ff34a0a284cf5a2847013701e24c2a53117e7c280a4316b3/propcache-0.3.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:0b504d29f3c47cf6b9e936c1852246c83d450e8e063d50562115a6be6d3a2535", size = 227684, upload-time = "2025-06-09T22:54:47.63Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/05/37ae63a0087677e90b1d14710e532ff104d44bc1efa3b3970fff99b891dc/propcache-0.3.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:ce2ac2675a6aa41ddb2a0c9cbff53780a617ac3d43e620f8fd77ba1c84dcfc06", size = 234562, upload-time = "2025-06-09T22:54:48.982Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/7c/3f539fcae630408d0bd8bf3208b9a647ccad10976eda62402a80adf8fc34/propcache-0.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:62b4239611205294cc433845b914131b2a1f03500ff3c1ed093ed216b82621e1", size = 222142, upload-time = "2025-06-09T22:54:50.424Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/d2/34b9eac8c35f79f8a962546b3e97e9d4b990c420ee66ac8255d5d9611648/propcache-0.3.2-cp312-cp312-win32.whl", hash = "sha256:df4a81b9b53449ebc90cc4deefb052c1dd934ba85012aa912c7ea7b7e38b60c1", size = 37711, upload-time = "2025-06-09T22:54:52.072Z" },
-    { url = "https://files.pythonhosted.org/packages/19/61/d582be5d226cf79071681d1b46b848d6cb03d7b70af7063e33a2787eaa03/propcache-0.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:7046e79b989d7fe457bb755844019e10f693752d169076138abf17f31380800c", size = 41479, upload-time = "2025-06-09T22:54:53.234Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/35/cc0aaecf278bb4575b8555f2b137de5ab821595ddae9da9d3cd1da4072c7/propcache-0.3.2-py3-none-any.whl", hash = "sha256:98f1ec44fb675f5052cccc8e609c46ed23a35a1cfd18545ad4e29002d858a43f", size = 12663, upload-time = "2025-06-09T22:56:04.484Z" },
-]
-
-[[package]]
-name = "protobuf"
-version = "6.32.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c0/df/fb4a8eeea482eca989b51cffd274aac2ee24e825f0bf3cbce5281fa1567b/protobuf-6.32.0.tar.gz", hash = "sha256:a81439049127067fc49ec1d36e25c6ee1d1a2b7be930675f919258d03c04e7d2", size = 440614, upload-time = "2025-08-14T21:21:25.015Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/33/18/df8c87da2e47f4f1dcc5153a81cd6bca4e429803f4069a299e236e4dd510/protobuf-6.32.0-cp310-abi3-win32.whl", hash = "sha256:84f9e3c1ff6fb0308dbacb0950d8aa90694b0d0ee68e75719cb044b7078fe741", size = 424409, upload-time = "2025-08-14T21:21:12.366Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/59/0a820b7310f8139bd8d5a9388e6a38e1786d179d6f33998448609296c229/protobuf-6.32.0-cp310-abi3-win_amd64.whl", hash = "sha256:a8bdbb2f009cfc22a36d031f22a625a38b615b5e19e558a7b756b3279723e68e", size = 435735, upload-time = "2025-08-14T21:21:15.046Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/5b/0d421533c59c789e9c9894683efac582c06246bf24bb26b753b149bd88e4/protobuf-6.32.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d52691e5bee6c860fff9a1c86ad26a13afbeb4b168cd4445c922b7e2cf85aaf0", size = 426449, upload-time = "2025-08-14T21:21:16.687Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/7b/607764ebe6c7a23dcee06e054fd1de3d5841b7648a90fd6def9a3bb58c5e/protobuf-6.32.0-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:501fe6372fd1c8ea2a30b4d9be8f87955a64d6be9c88a973996cef5ef6f0abf1", size = 322869, upload-time = "2025-08-14T21:21:18.282Z" },
-    { url = "https://files.pythonhosted.org/packages/40/01/2e730bd1c25392fc32e3268e02446f0d77cb51a2c3a8486b1798e34d5805/protobuf-6.32.0-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:75a2aab2bd1aeb1f5dc7c5f33bcb11d82ea8c055c9becbb41c26a8c43fd7092c", size = 322009, upload-time = "2025-08-14T21:21:19.893Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/f2/80ffc4677aac1bc3519b26bc7f7f5de7fce0ee2f7e36e59e27d8beb32dd1/protobuf-6.32.0-py3-none-any.whl", hash = "sha256:ba377e5b67b908c8f3072a57b63e2c6a4cbd18aea4ed98d2584350dbf46f2783", size = 169287, upload-time = "2025-08-14T21:21:23.515Z" },
-]
-
-[[package]]
-name = "psutil"
-version = "7.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003, upload-time = "2025-02-13T21:54:07.946Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051, upload-time = "2025-02-13T21:54:12.36Z" },
-    { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535, upload-time = "2025-02-13T21:54:16.07Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004, upload-time = "2025-02-13T21:54:18.662Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986, upload-time = "2025-02-13T21:54:21.811Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544, upload-time = "2025-02-13T21:54:24.68Z" },
-    { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053, upload-time = "2025-02-13T21:54:34.31Z" },
-    { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885, upload-time = "2025-02-13T21:54:37.486Z" },
-]
-
-[[package]]
-name = "pycparser"
-version = "2.22"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload-time = "2024-03-30T13:22:22.564Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload-time = "2024-03-30T13:22:20.476Z" },
-]
-
-[[package]]
-name = "pydantic"
-version = "2.11.7"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "annotated-types" },
-    { name = "pydantic-core" },
-    { name = "typing-extensions" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/00/dd/4325abf92c39ba8623b5af936ddb36ffcfe0beae70405d456ab1fb2f5b8c/pydantic-2.11.7.tar.gz", hash = "sha256:d989c3c6cb79469287b1569f7447a17848c998458d49ebe294e975b9baf0f0db", size = 788350, upload-time = "2025-06-14T08:33:17.137Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/c0/ec2b1c8712ca690e5d61979dee872603e92b8a32f94cc1b72d53beab008a/pydantic-2.11.7-py3-none-any.whl", hash = "sha256:dde5df002701f6de26248661f6835bbe296a47bf73990135c7d07ce741b9623b", size = 444782, upload-time = "2025-06-14T08:33:14.905Z" },
-]
-
-[[package]]
-name = "pydantic-core"
-version = "2.33.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/92/b31726561b5dae176c2d2c2dc43a9c5bfba5d32f96f8b4c0a600dd492447/pydantic_core-2.33.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2b3d326aaef0c0399d9afffeb6367d5e26ddc24d351dbc9c636840ac355dc5d8", size = 2028817, upload-time = "2025-04-23T18:30:43.919Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/44/3f0b95fafdaca04a483c4e685fe437c6891001bf3ce8b2fded82b9ea3aa1/pydantic_core-2.33.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e5b2671f05ba48b94cb90ce55d8bdcaaedb8ba00cc5359f6810fc918713983d", size = 1861357, upload-time = "2025-04-23T18:30:46.372Z" },
-    { url = "https://files.pythonhosted.org/packages/30/97/e8f13b55766234caae05372826e8e4b3b96e7b248be3157f53237682e43c/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0069c9acc3f3981b9ff4cdfaf088e98d83440a4c7ea1bc07460af3d4dc22e72d", size = 1898011, upload-time = "2025-04-23T18:30:47.591Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/a3/99c48cf7bafc991cc3ee66fd544c0aae8dc907b752f1dad2d79b1b5a471f/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d53b22f2032c42eaaf025f7c40c2e3b94568ae077a606f006d206a463bc69572", size = 1982730, upload-time = "2025-04-23T18:30:49.328Z" },
-    { url = "https://files.pythonhosted.org/packages/de/8e/a5b882ec4307010a840fb8b58bd9bf65d1840c92eae7534c7441709bf54b/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0405262705a123b7ce9f0b92f123334d67b70fd1f20a9372b907ce1080c7ba02", size = 2136178, upload-time = "2025-04-23T18:30:50.907Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/bb/71e35fc3ed05af6834e890edb75968e2802fe98778971ab5cba20a162315/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4b25d91e288e2c4e0662b8038a28c6a07eaac3e196cfc4ff69de4ea3db992a1b", size = 2736462, upload-time = "2025-04-23T18:30:52.083Z" },
-    { url = "https://files.pythonhosted.org/packages/31/0d/c8f7593e6bc7066289bbc366f2235701dcbebcd1ff0ef8e64f6f239fb47d/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bdfe4b3789761f3bcb4b1ddf33355a71079858958e3a552f16d5af19768fef2", size = 2005652, upload-time = "2025-04-23T18:30:53.389Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/7a/996d8bd75f3eda405e3dd219ff5ff0a283cd8e34add39d8ef9157e722867/pydantic_core-2.33.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:efec8db3266b76ef9607c2c4c419bdb06bf335ae433b80816089ea7585816f6a", size = 2113306, upload-time = "2025-04-23T18:30:54.661Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/84/daf2a6fb2db40ffda6578a7e8c5a6e9c8affb251a05c233ae37098118788/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:031c57d67ca86902726e0fae2214ce6770bbe2f710dc33063187a68744a5ecac", size = 2073720, upload-time = "2025-04-23T18:30:56.11Z" },
-    { url = "https://files.pythonhosted.org/packages/77/fb/2258da019f4825128445ae79456a5499c032b55849dbd5bed78c95ccf163/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:f8de619080e944347f5f20de29a975c2d815d9ddd8be9b9b7268e2e3ef68605a", size = 2244915, upload-time = "2025-04-23T18:30:57.501Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/7a/925ff73756031289468326e355b6fa8316960d0d65f8b5d6b3a3e7866de7/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:73662edf539e72a9440129f231ed3757faab89630d291b784ca99237fb94db2b", size = 2241884, upload-time = "2025-04-23T18:30:58.867Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/b0/249ee6d2646f1cdadcb813805fe76265745c4010cf20a8eba7b0e639d9b2/pydantic_core-2.33.2-cp310-cp310-win32.whl", hash = "sha256:0a39979dcbb70998b0e505fb1556a1d550a0781463ce84ebf915ba293ccb7e22", size = 1910496, upload-time = "2025-04-23T18:31:00.078Z" },
-    { url = "https://files.pythonhosted.org/packages/66/ff/172ba8f12a42d4b552917aa65d1f2328990d3ccfc01d5b7c943ec084299f/pydantic_core-2.33.2-cp310-cp310-win_amd64.whl", hash = "sha256:b0379a2b24882fef529ec3b4987cb5d003b9cda32256024e6fe1586ac45fc640", size = 1955019, upload-time = "2025-04-23T18:31:01.335Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/8d/71db63483d518cbbf290261a1fc2839d17ff89fce7089e08cad07ccfce67/pydantic_core-2.33.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4c5b0a576fb381edd6d27f0a85915c6daf2f8138dc5c267a57c08a62900758c7", size = 2028584, upload-time = "2025-04-23T18:31:03.106Z" },
-    { url = "https://files.pythonhosted.org/packages/24/2f/3cfa7244ae292dd850989f328722d2aef313f74ffc471184dc509e1e4e5a/pydantic_core-2.33.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e799c050df38a639db758c617ec771fd8fb7a5f8eaaa4b27b101f266b216a246", size = 1855071, upload-time = "2025-04-23T18:31:04.621Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/d3/4ae42d33f5e3f50dd467761304be2fa0a9417fbf09735bc2cce003480f2a/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc46a01bf8d62f227d5ecee74178ffc448ff4e5197c756331f71efcc66dc980f", size = 1897823, upload-time = "2025-04-23T18:31:06.377Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/f3/aa5976e8352b7695ff808599794b1fba2a9ae2ee954a3426855935799488/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a144d4f717285c6d9234a66778059f33a89096dfb9b39117663fd8413d582dcc", size = 1983792, upload-time = "2025-04-23T18:31:07.93Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/7a/cda9b5a23c552037717f2b2a5257e9b2bfe45e687386df9591eff7b46d28/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cf6373c21bc80b2e0dc88444f41ae60b2f070ed02095754eb5a01df12256de", size = 2136338, upload-time = "2025-04-23T18:31:09.283Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/9f/b8f9ec8dd1417eb9da784e91e1667d58a2a4a7b7b34cf4af765ef663a7e5/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dc625f4aa79713512d1976fe9f0bc99f706a9dee21dfd1810b4bbbf228d0e8a", size = 2730998, upload-time = "2025-04-23T18:31:11.7Z" },
-    { url = "https://files.pythonhosted.org/packages/47/bc/cd720e078576bdb8255d5032c5d63ee5c0bf4b7173dd955185a1d658c456/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b21b5549499972441da4758d662aeea93f1923f953e9cbaff14b8b9565aef", size = 2003200, upload-time = "2025-04-23T18:31:13.536Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/22/3602b895ee2cd29d11a2b349372446ae9727c32e78a94b3d588a40fdf187/pydantic_core-2.33.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bdc25f3681f7b78572699569514036afe3c243bc3059d3942624e936ec93450e", size = 2113890, upload-time = "2025-04-23T18:31:15.011Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/e6/e3c5908c03cf00d629eb38393a98fccc38ee0ce8ecce32f69fc7d7b558a7/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fe5b32187cbc0c862ee201ad66c30cf218e5ed468ec8dc1cf49dec66e160cc4d", size = 2073359, upload-time = "2025-04-23T18:31:16.393Z" },
-    { url = "https://files.pythonhosted.org/packages/12/e7/6a36a07c59ebefc8777d1ffdaf5ae71b06b21952582e4b07eba88a421c79/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:bc7aee6f634a6f4a95676fcb5d6559a2c2a390330098dba5e5a5f28a2e4ada30", size = 2245883, upload-time = "2025-04-23T18:31:17.892Z" },
-    { url = "https://files.pythonhosted.org/packages/16/3f/59b3187aaa6cc0c1e6616e8045b284de2b6a87b027cce2ffcea073adf1d2/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:235f45e5dbcccf6bd99f9f472858849f73d11120d76ea8707115415f8e5ebebf", size = 2241074, upload-time = "2025-04-23T18:31:19.205Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/ed/55532bb88f674d5d8f67ab121a2a13c385df382de2a1677f30ad385f7438/pydantic_core-2.33.2-cp311-cp311-win32.whl", hash = "sha256:6368900c2d3ef09b69cb0b913f9f8263b03786e5b2a387706c5afb66800efd51", size = 1910538, upload-time = "2025-04-23T18:31:20.541Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/1b/25b7cccd4519c0b23c2dd636ad39d381abf113085ce4f7bec2b0dc755eb1/pydantic_core-2.33.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e063337ef9e9820c77acc768546325ebe04ee38b08703244c1309cccc4f1bab", size = 1952909, upload-time = "2025-04-23T18:31:22.371Z" },
-    { url = "https://files.pythonhosted.org/packages/49/a9/d809358e49126438055884c4366a1f6227f0f84f635a9014e2deb9b9de54/pydantic_core-2.33.2-cp311-cp311-win_arm64.whl", hash = "sha256:6b99022f1d19bc32a4c2a0d544fc9a76e3be90f0b3f4af413f87d38749300e65", size = 1897786, upload-time = "2025-04-23T18:31:24.161Z" },
-    { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" },
-    { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" },
-    { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" },
-    { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" },
-    { url = "https://files.pythonhosted.org/packages/30/68/373d55e58b7e83ce371691f6eaa7175e3a24b956c44628eb25d7da007917/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5c4aa4e82353f65e548c476b37e64189783aa5384903bfea4f41580f255fddfa", size = 2023982, upload-time = "2025-04-23T18:32:53.14Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/16/145f54ac08c96a63d8ed6442f9dec17b2773d19920b627b18d4f10a061ea/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d946c8bf0d5c24bf4fe333af284c59a19358aa3ec18cb3dc4370080da1e8ad29", size = 1858412, upload-time = "2025-04-23T18:32:55.52Z" },
-    { url = "https://files.pythonhosted.org/packages/41/b1/c6dc6c3e2de4516c0bb2c46f6a373b91b5660312342a0cf5826e38ad82fa/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:87b31b6846e361ef83fedb187bb5b4372d0da3f7e28d85415efa92d6125d6e6d", size = 1892749, upload-time = "2025-04-23T18:32:57.546Z" },
-    { url = "https://files.pythonhosted.org/packages/12/73/8cd57e20afba760b21b742106f9dbdfa6697f1570b189c7457a1af4cd8a0/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa9d91b338f2df0508606f7009fde642391425189bba6d8c653afd80fd6bb64e", size = 2067527, upload-time = "2025-04-23T18:32:59.771Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/d5/0bb5d988cc019b3cba4a78f2d4b3854427fc47ee8ec8e9eaabf787da239c/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2058a32994f1fde4ca0480ab9d1e75a0e8c87c22b53a3ae66554f9af78f2fe8c", size = 2108225, upload-time = "2025-04-23T18:33:04.51Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/c5/00c02d1571913d496aabf146106ad8239dc132485ee22efe08085084ff7c/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:0e03262ab796d986f978f79c943fc5f620381be7287148b8010b4097f79a39ec", size = 2069490, upload-time = "2025-04-23T18:33:06.391Z" },
-    { url = "https://files.pythonhosted.org/packages/22/a8/dccc38768274d3ed3a59b5d06f59ccb845778687652daa71df0cab4040d7/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:1a8695a8d00c73e50bff9dfda4d540b7dee29ff9b8053e38380426a85ef10052", size = 2237525, upload-time = "2025-04-23T18:33:08.44Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/e7/4f98c0b125dda7cf7ccd14ba936218397b44f50a56dd8c16a3091df116c3/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:fa754d1850735a0b0e03bcffd9d4b4343eb417e47196e4485d9cca326073a42c", size = 2238446, upload-time = "2025-04-23T18:33:10.313Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/91/2ec36480fdb0b783cd9ef6795753c1dea13882f2e68e73bce76ae8c21e6a/pydantic_core-2.33.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a11c8d26a50bfab49002947d3d237abe4d9e4b5bdc8846a63537b6488e197808", size = 2066678, upload-time = "2025-04-23T18:33:12.224Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/27/d4ae6487d73948d6f20dddcd94be4ea43e74349b56eba82e9bdee2d7494c/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dd14041875d09cc0f9308e37a6f8b65f5585cf2598a53aa0123df8b129d481f8", size = 2025200, upload-time = "2025-04-23T18:33:14.199Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/b8/b3cb95375f05d33801024079b9392a5ab45267a63400bf1866e7ce0f0de4/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d87c561733f66531dced0da6e864f44ebf89a8fba55f31407b00c2f7f9449593", size = 1859123, upload-time = "2025-04-23T18:33:16.555Z" },
-    { url = "https://files.pythonhosted.org/packages/05/bc/0d0b5adeda59a261cd30a1235a445bf55c7e46ae44aea28f7bd6ed46e091/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f82865531efd18d6e07a04a17331af02cb7a651583c418df8266f17a63c6612", size = 1892852, upload-time = "2025-04-23T18:33:18.513Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/11/d37bdebbda2e449cb3f519f6ce950927b56d62f0b84fd9cb9e372a26a3d5/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bfb5112df54209d820d7bf9317c7a6c9025ea52e49f46b6a2060104bba37de7", size = 2067484, upload-time = "2025-04-23T18:33:20.475Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/55/1f95f0a05ce72ecb02a8a8a1c3be0579bbc29b1d5ab68f1378b7bebc5057/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:64632ff9d614e5eecfb495796ad51b0ed98c453e447a76bcbeeb69615079fc7e", size = 2108896, upload-time = "2025-04-23T18:33:22.501Z" },
-    { url = "https://files.pythonhosted.org/packages/53/89/2b2de6c81fa131f423246a9109d7b2a375e83968ad0800d6e57d0574629b/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f889f7a40498cc077332c7ab6b4608d296d852182211787d4f3ee377aaae66e8", size = 2069475, upload-time = "2025-04-23T18:33:24.528Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/e9/1f7efbe20d0b2b10f6718944b5d8ece9152390904f29a78e68d4e7961159/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:de4b83bb311557e439b9e186f733f6c645b9417c84e2eb8203f3f820a4b988bf", size = 2239013, upload-time = "2025-04-23T18:33:26.621Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/b2/5309c905a93811524a49b4e031e9851a6b00ff0fb668794472ea7746b448/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:82f68293f055f51b51ea42fafc74b6aad03e70e191799430b90c13d643059ebb", size = 2238715, upload-time = "2025-04-23T18:33:28.656Z" },
-    { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757, upload-time = "2025-04-23T18:33:30.645Z" },
-]
-
-[[package]]
-name = "pydantic-settings"
-version = "2.10.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/68/85/1ea668bbab3c50071ca613c6ab30047fb36ab0da1b92fa8f17bbc38fd36c/pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee", size = 172583, upload-time = "2025-06-24T13:26:46.841Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235, upload-time = "2025-06-24T13:26:45.485Z" },
-]
-
-[[package]]
-name = "pygments"
-version = "2.19.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
-]
-
-[[package]]
-name = "python-dateutil"
-version = "2.9.0.post0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "six" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
-]
-
-[[package]]
-name = "python-dotenv"
-version = "1.1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload-time = "2025-06-24T04:21:07.341Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },
-]
-
-[[package]]
-name = "python-multipart"
-version = "0.0.20"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158, upload-time = "2024-12-16T19:45:46.972Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546, upload-time = "2024-12-16T19:45:44.423Z" },
-]
-
-[[package]]
-name = "pytz"
-version = "2025.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" },
-]
-
-[[package]]
-name = "pywin32"
-version = "311"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7b/40/44efbb0dfbd33aca6a6483191dae0716070ed99e2ecb0c53683f400a0b4f/pywin32-311-cp310-cp310-win32.whl", hash = "sha256:d03ff496d2a0cd4a5893504789d4a15399133fe82517455e78bad62efbb7f0a3", size = 8760432, upload-time = "2025-07-14T20:13:05.9Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/bf/360243b1e953bd254a82f12653974be395ba880e7ec23e3731d9f73921cc/pywin32-311-cp310-cp310-win_amd64.whl", hash = "sha256:797c2772017851984b97180b0bebe4b620bb86328e8a884bb626156295a63b3b", size = 9590103, upload-time = "2025-07-14T20:13:07.698Z" },
-    { url = "https://files.pythonhosted.org/packages/57/38/d290720e6f138086fb3d5ffe0b6caa019a791dd57866940c82e4eeaf2012/pywin32-311-cp310-cp310-win_arm64.whl", hash = "sha256:0502d1facf1fed4839a9a51ccbcc63d952cf318f78ffc00a7e78528ac27d7a2b", size = 8778557, upload-time = "2025-07-14T20:13:11.11Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031, upload-time = "2025-07-14T20:13:13.266Z" },
-    { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308, upload-time = "2025-07-14T20:13:15.147Z" },
-    { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930, upload-time = "2025-07-14T20:13:16.945Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" },
-]
-
-[[package]]
-name = "pyyaml"
-version = "6.0.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631, upload-time = "2024-08-06T20:33:50.674Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199, upload-time = "2024-08-06T20:31:40.178Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758, upload-time = "2024-08-06T20:31:42.173Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463, upload-time = "2024-08-06T20:31:44.263Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280, upload-time = "2024-08-06T20:31:50.199Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239, upload-time = "2024-08-06T20:31:52.292Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802, upload-time = "2024-08-06T20:31:53.836Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527, upload-time = "2024-08-06T20:31:55.565Z" },
-    { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052, upload-time = "2024-08-06T20:31:56.914Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774, upload-time = "2024-08-06T20:31:58.304Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612, upload-time = "2024-08-06T20:32:03.408Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040, upload-time = "2024-08-06T20:32:04.926Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829, upload-time = "2024-08-06T20:32:06.459Z" },
-    { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167, upload-time = "2024-08-06T20:32:08.338Z" },
-    { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952, upload-time = "2024-08-06T20:32:14.124Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301, upload-time = "2024-08-06T20:32:16.17Z" },
-    { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638, upload-time = "2024-08-06T20:32:18.555Z" },
-    { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850, upload-time = "2024-08-06T20:32:19.889Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980, upload-time = "2024-08-06T20:32:21.273Z" },
-    { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873, upload-time = "2024-08-06T20:32:25.131Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302, upload-time = "2024-08-06T20:32:26.511Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154, upload-time = "2024-08-06T20:32:28.363Z" },
-    { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223, upload-time = "2024-08-06T20:32:30.058Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542, upload-time = "2024-08-06T20:32:31.881Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164, upload-time = "2024-08-06T20:32:37.083Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611, upload-time = "2024-08-06T20:32:38.898Z" },
-    { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591, upload-time = "2024-08-06T20:32:40.241Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338, upload-time = "2024-08-06T20:32:41.93Z" },
-]
-
-[[package]]
-name = "redis"
-version = "6.4.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "async-timeout", marker = "python_full_version < '3.11.3'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0d/d6/e8b92798a5bd67d659d51a18170e91c16ac3b59738d91894651ee255ed49/redis-6.4.0.tar.gz", hash = "sha256:b01bc7282b8444e28ec36b261df5375183bb47a07eb9c603f284e89cbc5ef010", size = 4647399, upload-time = "2025-08-07T08:10:11.441Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e8/02/89e2ed7e85db6c93dfa9e8f691c5087df4e3551ab39081a4d7c6d1f90e05/redis-6.4.0-py3-none-any.whl", hash = "sha256:f0544fa9604264e9464cdf4814e7d4830f74b165d52f2a330a760a88dd248b7f", size = 279847, upload-time = "2025-08-07T08:10:09.84Z" },
-]
-
-[[package]]
-name = "referencing"
-version = "0.36.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs" },
-    { name = "rpds-py" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload-time = "2025-01-25T08:48:16.138Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775, upload-time = "2025-01-25T08:48:14.241Z" },
-]
-
-[[package]]
-name = "requests"
-version = "2.32.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "charset-normalizer" },
-    { name = "idna" },
-    { name = "urllib3" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
-]
-
-[[package]]
-name = "requests-toolbelt"
-version = "1.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" },
-]
-
-[[package]]
-name = "rich"
-version = "14.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "markdown-it-py" },
-    { name = "pygments" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/fe/75/af448d8e52bf1d8fa6a9d089ca6c07ff4453d86c65c145d0a300bb073b9b/rich-14.1.0.tar.gz", hash = "sha256:e497a48b844b0320d45007cdebfeaeed8db2a4f4bcf49f15e455cfc4af11eaa8", size = 224441, upload-time = "2025-07-25T07:32:58.125Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e3/30/3c4d035596d3cf444529e0b2953ad0466f6049528a879d27534700580395/rich-14.1.0-py3-none-any.whl", hash = "sha256:536f5f1785986d6dbdea3c75205c473f970777b4a0d6c6dd1b696aa05a3fa04f", size = 243368, upload-time = "2025-07-25T07:32:56.73Z" },
-]
-
-[[package]]
-name = "rpds-py"
-version = "0.27.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1e/d9/991a0dee12d9fc53ed027e26a26a64b151d77252ac477e22666b9688bc16/rpds_py-0.27.0.tar.gz", hash = "sha256:8b23cf252f180cda89220b378d917180f29d313cd6a07b2431c0d3b776aae86f", size = 27420, upload-time = "2025-08-07T08:26:39.624Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/75/2d/ad2e37dee3f45580f7fa0066c412a521f9bee53d2718b0e9436d308a1ecd/rpds_py-0.27.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:130c1ffa5039a333f5926b09e346ab335f0d4ec393b030a18549a7c7e7c2cea4", size = 371511, upload-time = "2025-08-07T08:23:06.205Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/67/57b4b2479193fde9dd6983a13c2550b5f9c3bcdf8912dffac2068945eb14/rpds_py-0.27.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a4cf32a26fa744101b67bfd28c55d992cd19438aff611a46cac7f066afca8fd4", size = 354718, upload-time = "2025-08-07T08:23:08.222Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/be/c2b95ec4b813eb11f3a3c3d22f22bda8d3a48a074a0519cde968c4d102cf/rpds_py-0.27.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64a0fe3f334a40b989812de70160de6b0ec7e3c9e4a04c0bbc48d97c5d3600ae", size = 381518, upload-time = "2025-08-07T08:23:09.696Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/d2/5a7279bc2b93b20bd50865a2269016238cee45f7dc3cc33402a7f41bd447/rpds_py-0.27.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9a0ff7ee28583ab30a52f371b40f54e7138c52ca67f8ca17ccb7ccf0b383cb5f", size = 396694, upload-time = "2025-08-07T08:23:11.105Z" },
-    { url = "https://files.pythonhosted.org/packages/65/e9/bac8b3714bd853c5bcb466e04acfb9a5da030d77e0ddf1dfad9afb791c31/rpds_py-0.27.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:15ea4d2e182345dd1b4286593601d766411b43f868924afe297570658c31a62b", size = 514813, upload-time = "2025-08-07T08:23:12.215Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/aa/293115e956d7d13b7d2a9e9a4121f74989a427aa125f00ce4426ca8b7b28/rpds_py-0.27.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:36184b44bf60a480863e51021c26aca3dfe8dd2f5eeabb33622b132b9d8b8b54", size = 402246, upload-time = "2025-08-07T08:23:13.699Z" },
-    { url = "https://files.pythonhosted.org/packages/88/59/2d6789bb898fb3e2f0f7b82b7bcf27f579ebcb6cc36c24f4e208f7f58a5b/rpds_py-0.27.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b78430703cfcf5f5e86eb74027a1ed03a93509273d7c705babb547f03e60016", size = 383661, upload-time = "2025-08-07T08:23:15.231Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/55/add13a593a7a81243a9eed56d618d3d427be5dc1214931676e3f695dfdc1/rpds_py-0.27.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:dbd749cff1defbde270ca346b69b3baf5f1297213ef322254bf2a28537f0b046", size = 401691, upload-time = "2025-08-07T08:23:16.681Z" },
-    { url = "https://files.pythonhosted.org/packages/04/09/3e8b2aad494ffaca571e4e19611a12cc18fcfd756d9274f3871a2d822445/rpds_py-0.27.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bde37765564cd22a676dd8101b657839a1854cfaa9c382c5abf6ff7accfd4ae", size = 416529, upload-time = "2025-08-07T08:23:17.863Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/6d/bd899234728f1d8f72c9610f50fdf1c140ecd0a141320e1f1d0f6b20595d/rpds_py-0.27.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:1d66f45b9399036e890fb9c04e9f70c33857fd8f58ac8db9f3278cfa835440c3", size = 558673, upload-time = "2025-08-07T08:23:18.99Z" },
-    { url = "https://files.pythonhosted.org/packages/79/f4/f3e02def5193fb899d797c232f90d6f8f0f2b9eca2faef6f0d34cbc89b2e/rpds_py-0.27.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:d85d784c619370d9329bbd670f41ff5f2ae62ea4519761b679d0f57f0f0ee267", size = 588426, upload-time = "2025-08-07T08:23:20.541Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/0c/88e716cd8fd760e5308835fe298255830de4a1c905fd51760b9bb40aa965/rpds_py-0.27.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5df559e9e7644d9042f626f2c3997b555f347d7a855a15f170b253f6c5bfe358", size = 554552, upload-time = "2025-08-07T08:23:21.714Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/a9/0a8243c182e7ac59b901083dff7e671feba6676a131bfff3f8d301cd2b36/rpds_py-0.27.0-cp310-cp310-win32.whl", hash = "sha256:b8a4131698b6992b2a56015f51646711ec5d893a0b314a4b985477868e240c87", size = 218081, upload-time = "2025-08-07T08:23:23.273Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/e7/202ff35852312760148be9e08fe2ba6900aa28e7a46940a313eae473c10c/rpds_py-0.27.0-cp310-cp310-win_amd64.whl", hash = "sha256:cbc619e84a5e3ab2d452de831c88bdcad824414e9c2d28cd101f94dbdf26329c", size = 230077, upload-time = "2025-08-07T08:23:24.308Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/c1/49d515434c1752e40f5e35b985260cf27af052593378580a2f139a5be6b8/rpds_py-0.27.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:dbc2ab5d10544eb485baa76c63c501303b716a5c405ff2469a1d8ceffaabf622", size = 371577, upload-time = "2025-08-07T08:23:25.379Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/6d/bf2715b2fee5087fa13b752b5fd573f1a93e4134c74d275f709e38e54fe7/rpds_py-0.27.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7ec85994f96a58cf7ed288caa344b7fe31fd1d503bdf13d7331ead5f70ab60d5", size = 354959, upload-time = "2025-08-07T08:23:26.767Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/5c/e7762808c746dd19733a81373c10da43926f6a6adcf4920a21119697a60a/rpds_py-0.27.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:190d7285cd3bb6d31d37a0534d7359c1ee191eb194c511c301f32a4afa5a1dd4", size = 381485, upload-time = "2025-08-07T08:23:27.869Z" },
-    { url = "https://files.pythonhosted.org/packages/40/51/0d308eb0b558309ca0598bcba4243f52c4cd20e15fe991b5bd75824f2e61/rpds_py-0.27.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c10d92fb6d7fd827e44055fcd932ad93dac6a11e832d51534d77b97d1d85400f", size = 396816, upload-time = "2025-08-07T08:23:29.424Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/aa/2d585ec911d78f66458b2c91252134ca0c7c70f687a72c87283173dc0c96/rpds_py-0.27.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dd2c1d27ebfe6a015cfa2005b7fe8c52d5019f7bbdd801bc6f7499aab9ae739e", size = 514950, upload-time = "2025-08-07T08:23:30.576Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/ef/aced551cc1148179557aed84343073adadf252c91265263ee6203458a186/rpds_py-0.27.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4790c9d5dd565ddb3e9f656092f57268951398cef52e364c405ed3112dc7c7c1", size = 402132, upload-time = "2025-08-07T08:23:32.428Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/ac/cf644803d8d417653fe2b3604186861d62ea6afaef1b2284045741baef17/rpds_py-0.27.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4300e15e7d03660f04be84a125d1bdd0e6b2f674bc0723bc0fd0122f1a4585dc", size = 383660, upload-time = "2025-08-07T08:23:33.829Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/ec/caf47c55ce02b76cbaeeb2d3b36a73da9ca2e14324e3d75cf72b59dcdac5/rpds_py-0.27.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:59195dc244fc183209cf8a93406889cadde47dfd2f0a6b137783aa9c56d67c85", size = 401730, upload-time = "2025-08-07T08:23:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/71/c1f355afdcd5b99ffc253422aa4bdcb04ccf1491dcd1bda3688a0c07fd61/rpds_py-0.27.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fae4a01ef8c4cb2bbe92ef2063149596907dc4a881a8d26743b3f6b304713171", size = 416122, upload-time = "2025-08-07T08:23:36.062Z" },
-    { url = "https://files.pythonhosted.org/packages/38/0f/f4b5b1eda724ed0e04d2b26d8911cdc131451a7ee4c4c020a1387e5c6ded/rpds_py-0.27.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e3dc8d4ede2dbae6c0fc2b6c958bf51ce9fd7e9b40c0f5b8835c3fde44f5807d", size = 558771, upload-time = "2025-08-07T08:23:37.478Z" },
-    { url = "https://files.pythonhosted.org/packages/93/c0/5f8b834db2289ab48d5cffbecbb75e35410103a77ac0b8da36bf9544ec1c/rpds_py-0.27.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c3782fb753aa825b4ccabc04292e07897e2fd941448eabf666856c5530277626", size = 587876, upload-time = "2025-08-07T08:23:38.662Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/dd/1a1df02ab8eb970115cff2ae31a6f73916609b900dc86961dc382b8c2e5e/rpds_py-0.27.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:887ab1f12b0d227e9260558a4a2320024b20102207ada65c43e1ffc4546df72e", size = 554359, upload-time = "2025-08-07T08:23:39.897Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/e4/95a014ab0d51ab6e3bebbdb476a42d992d2bbf9c489d24cff9fda998e925/rpds_py-0.27.0-cp311-cp311-win32.whl", hash = "sha256:5d6790ff400254137b81b8053b34417e2c46921e302d655181d55ea46df58cf7", size = 218084, upload-time = "2025-08-07T08:23:41.086Z" },
-    { url = "https://files.pythonhosted.org/packages/49/78/f8d5b71ec65a0376b0de31efcbb5528ce17a9b7fdd19c3763303ccfdedec/rpds_py-0.27.0-cp311-cp311-win_amd64.whl", hash = "sha256:e24d8031a2c62f34853756d9208eeafa6b940a1efcbfe36e8f57d99d52bb7261", size = 230085, upload-time = "2025-08-07T08:23:42.143Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/d3/84429745184091e06b4cc70f8597408e314c2d2f7f5e13249af9ffab9e3d/rpds_py-0.27.0-cp311-cp311-win_arm64.whl", hash = "sha256:08680820d23df1df0a0260f714d12966bc6c42d02e8055a91d61e03f0c47dda0", size = 222112, upload-time = "2025-08-07T08:23:43.233Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/17/e67309ca1ac993fa1888a0d9b2f5ccc1f67196ace32e76c9f8e1dbbbd50c/rpds_py-0.27.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:19c990fdf5acecbf0623e906ae2e09ce1c58947197f9bced6bbd7482662231c4", size = 362611, upload-time = "2025-08-07T08:23:44.773Z" },
-    { url = "https://files.pythonhosted.org/packages/93/2e/28c2fb84aa7aa5d75933d1862d0f7de6198ea22dfd9a0cca06e8a4e7509e/rpds_py-0.27.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6c27a7054b5224710fcfb1a626ec3ff4f28bcb89b899148c72873b18210e446b", size = 347680, upload-time = "2025-08-07T08:23:46.014Z" },
-    { url = "https://files.pythonhosted.org/packages/44/3e/9834b4c8f4f5fe936b479e623832468aa4bd6beb8d014fecaee9eac6cdb1/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09965b314091829b378b60607022048953e25f0b396c2b70e7c4c81bcecf932e", size = 384600, upload-time = "2025-08-07T08:23:48Z" },
-    { url = "https://files.pythonhosted.org/packages/19/78/744123c7b38865a965cd9e6f691fde7ef989a00a256fa8bf15b75240d12f/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:14f028eb47f59e9169bfdf9f7ceafd29dd64902141840633683d0bad5b04ff34", size = 400697, upload-time = "2025-08-07T08:23:49.407Z" },
-    { url = "https://files.pythonhosted.org/packages/32/97/3c3d32fe7daee0a1f1a678b6d4dfb8c4dcf88197fa2441f9da7cb54a8466/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6168af0be75bba990a39f9431cdfae5f0ad501f4af32ae62e8856307200517b8", size = 517781, upload-time = "2025-08-07T08:23:50.557Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/be/28f0e3e733680aa13ecec1212fc0f585928a206292f14f89c0b8a684cad1/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ab47fe727c13c09d0e6f508e3a49e545008e23bf762a245b020391b621f5b726", size = 406449, upload-time = "2025-08-07T08:23:51.732Z" },
-    { url = "https://files.pythonhosted.org/packages/95/ae/5d15c83e337c082d0367053baeb40bfba683f42459f6ebff63a2fd7e5518/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fa01b3d5e3b7d97efab65bd3d88f164e289ec323a8c033c5c38e53ee25c007e", size = 386150, upload-time = "2025-08-07T08:23:52.822Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/65/944e95f95d5931112829e040912b25a77b2e7ed913ea5fe5746aa5c1ce75/rpds_py-0.27.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:6c135708e987f46053e0a1246a206f53717f9fadfba27174a9769ad4befba5c3", size = 406100, upload-time = "2025-08-07T08:23:54.339Z" },
-    { url = "https://files.pythonhosted.org/packages/21/a4/1664b83fae02894533cd11dc0b9f91d673797c2185b7be0f7496107ed6c5/rpds_py-0.27.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc327f4497b7087d06204235199daf208fd01c82d80465dc5efa4ec9df1c5b4e", size = 421345, upload-time = "2025-08-07T08:23:55.832Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/26/b7303941c2b0823bfb34c71378249f8beedce57301f400acb04bb345d025/rpds_py-0.27.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7e57906e38583a2cba67046a09c2637e23297618dc1f3caddbc493f2be97c93f", size = 561891, upload-time = "2025-08-07T08:23:56.951Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/c8/48623d64d4a5a028fa99576c768a6159db49ab907230edddc0b8468b998b/rpds_py-0.27.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f4f69d7a4300fbf91efb1fb4916421bd57804c01ab938ab50ac9c4aa2212f03", size = 591756, upload-time = "2025-08-07T08:23:58.146Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/51/18f62617e8e61cc66334c9fb44b1ad7baae3438662098efbc55fb3fda453/rpds_py-0.27.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b4c4fbbcff474e1e5f38be1bf04511c03d492d42eec0babda5d03af3b5589374", size = 557088, upload-time = "2025-08-07T08:23:59.6Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/4c/e84c3a276e2496a93d245516be6b49e20499aa8ca1c94d59fada0d79addc/rpds_py-0.27.0-cp312-cp312-win32.whl", hash = "sha256:27bac29bbbf39601b2aab474daf99dbc8e7176ca3389237a23944b17f8913d97", size = 221926, upload-time = "2025-08-07T08:24:00.695Z" },
-    { url = "https://files.pythonhosted.org/packages/83/89/9d0fbcef64340db0605eb0a0044f258076f3ae0a3b108983b2c614d96212/rpds_py-0.27.0-cp312-cp312-win_amd64.whl", hash = "sha256:8a06aa1197ec0281eb1d7daf6073e199eb832fe591ffa329b88bae28f25f5fe5", size = 233235, upload-time = "2025-08-07T08:24:01.846Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/b0/e177aa9f39cbab060f96de4a09df77d494f0279604dc2f509263e21b05f9/rpds_py-0.27.0-cp312-cp312-win_arm64.whl", hash = "sha256:e14aab02258cb776a108107bd15f5b5e4a1bbaa61ef33b36693dfab6f89d54f9", size = 223315, upload-time = "2025-08-07T08:24:03.337Z" },
-    { url = "https://files.pythonhosted.org/packages/47/55/287068956f9ba1cb40896d291213f09fdd4527630709058b45a592bc09dc/rpds_py-0.27.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:46f48482c1a4748ab2773f75fffbdd1951eb59794e32788834b945da857c47a8", size = 371566, upload-time = "2025-08-07T08:25:43.95Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/fb/443af59cbe552e89680bb0f1d1ba47f6387b92083e28a45b8c8863b86c5a/rpds_py-0.27.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:419dd9c98bcc9fb0242be89e0c6e922df333b975d4268faa90d58499fd9c9ebe", size = 355781, upload-time = "2025-08-07T08:25:45.256Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/f0/35f48bb073b5ca42b1dcc55cb148f4a3bd4411a3e584f6a18d26f0ea8832/rpds_py-0.27.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55d42a0ef2bdf6bc81e1cc2d49d12460f63c6ae1423c4f4851b828e454ccf6f1", size = 382575, upload-time = "2025-08-07T08:25:46.524Z" },
-    { url = "https://files.pythonhosted.org/packages/51/e1/5f5296a21d1189f0f116a938af2e346d83172bf814d373695e54004a936f/rpds_py-0.27.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2e39169ac6aae06dd79c07c8a69d9da867cef6a6d7883a0186b46bb46ccfb0c3", size = 397435, upload-time = "2025-08-07T08:25:48.204Z" },
-    { url = "https://files.pythonhosted.org/packages/97/79/3af99b7852b2b55cad8a08863725cbe9dc14781bcf7dc6ecead0c3e1dc54/rpds_py-0.27.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:935afcdea4751b0ac918047a2df3f720212892347767aea28f5b3bf7be4f27c0", size = 514861, upload-time = "2025-08-07T08:25:49.814Z" },
-    { url = "https://files.pythonhosted.org/packages/df/3e/11fd6033708ed3ae0e6947bb94f762f56bb46bf59a1b16eef6944e8a62ee/rpds_py-0.27.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8de567dec6d451649a781633d36f5c7501711adee329d76c095be2178855b042", size = 402776, upload-time = "2025-08-07T08:25:51.135Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/89/f9375ceaa996116de9cbc949874804c7874d42fb258c384c037a46d730b8/rpds_py-0.27.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:555ed147cbe8c8f76e72a4c6cd3b7b761cbf9987891b9448808148204aed74a5", size = 384665, upload-time = "2025-08-07T08:25:52.82Z" },
-    { url = "https://files.pythonhosted.org/packages/48/bf/0061e55c6f1f573a63c0f82306b8984ed3b394adafc66854a936d5db3522/rpds_py-0.27.0-pp310-pypy310_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:d2cc2b34f9e1d31ce255174da82902ad75bd7c0d88a33df54a77a22f2ef421ee", size = 402518, upload-time = "2025-08-07T08:25:54.073Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/dc/8d506676bfe87b3b683332ec8e6ab2b0be118a3d3595ed021e3274a63191/rpds_py-0.27.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cb0702c12983be3b2fab98ead349ac63a98216d28dda6f518f52da5498a27a1b", size = 416247, upload-time = "2025-08-07T08:25:55.433Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/02/9a89eea1b75c69e81632de7963076e455b1e00e1cfb46dfdabb055fa03e3/rpds_py-0.27.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:ba783541be46f27c8faea5a6645e193943c17ea2f0ffe593639d906a327a9bcc", size = 559456, upload-time = "2025-08-07T08:25:56.866Z" },
-    { url = "https://files.pythonhosted.org/packages/38/4a/0f3ac4351957847c0d322be6ec72f916e43804a2c1d04e9672ea4a67c315/rpds_py-0.27.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:2406d034635d1497c596c40c85f86ecf2bf9611c1df73d14078af8444fe48031", size = 587778, upload-time = "2025-08-07T08:25:58.202Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/8e/39d0d7401095bed5a5ad5ef304fae96383f9bef40ca3f3a0807ff5b68d9d/rpds_py-0.27.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:dea0808153f1fbbad772669d906cddd92100277533a03845de6893cadeffc8be", size = 555247, upload-time = "2025-08-07T08:25:59.707Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/04/6b8311e811e620b9eaca67cd80a118ff9159558a719201052a7b2abb88bf/rpds_py-0.27.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d2a81bdcfde4245468f7030a75a37d50400ac2455c3a4819d9d550c937f90ab5", size = 230256, upload-time = "2025-08-07T08:26:01.07Z" },
-    { url = "https://files.pythonhosted.org/packages/59/64/72ab5b911fdcc48058359b0e786e5363e3fde885156116026f1a2ba9a5b5/rpds_py-0.27.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e6491658dd2569f05860bad645569145c8626ac231877b0fb2d5f9bcb7054089", size = 371658, upload-time = "2025-08-07T08:26:02.369Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/4b/90ff04b4da055db53d8fea57640d8d5d55456343a1ec9a866c0ecfe10fd1/rpds_py-0.27.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:bec77545d188f8bdd29d42bccb9191682a46fb2e655e3d1fb446d47c55ac3b8d", size = 355529, upload-time = "2025-08-07T08:26:03.83Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/be/527491fb1afcd86fc5ce5812eb37bc70428ee017d77fee20de18155c3937/rpds_py-0.27.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25a4aebf8ca02bbb90a9b3e7a463bbf3bee02ab1c446840ca07b1695a68ce424", size = 382822, upload-time = "2025-08-07T08:26:05.52Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/a5/dcdb8725ce11e6d0913e6fcf782a13f4b8a517e8acc70946031830b98441/rpds_py-0.27.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:44524b96481a4c9b8e6c46d6afe43fa1fb485c261e359fbe32b63ff60e3884d8", size = 397233, upload-time = "2025-08-07T08:26:07.179Z" },
-    { url = "https://files.pythonhosted.org/packages/33/f9/0947920d1927e9f144660590cc38cadb0795d78fe0d9aae0ef71c1513b7c/rpds_py-0.27.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:45d04a73c54b6a5fd2bab91a4b5bc8b426949586e61340e212a8484919183859", size = 514892, upload-time = "2025-08-07T08:26:08.622Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/ed/d1343398c1417c68f8daa1afce56ef6ce5cc587daaf98e29347b00a80ff2/rpds_py-0.27.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:343cf24de9ed6c728abefc5d5c851d5de06497caa7ac37e5e65dd572921ed1b5", size = 402733, upload-time = "2025-08-07T08:26:10.433Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/0b/646f55442cd14014fb64d143428f25667a100f82092c90087b9ea7101c74/rpds_py-0.27.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7aed8118ae20515974650d08eb724150dc2e20c2814bcc307089569995e88a14", size = 384447, upload-time = "2025-08-07T08:26:11.847Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/15/0596ef7529828e33a6c81ecf5013d1dd33a511a3e0be0561f83079cda227/rpds_py-0.27.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:af9d4fd79ee1cc8e7caf693ee02737daabfc0fcf2773ca0a4735b356c8ad6f7c", size = 402502, upload-time = "2025-08-07T08:26:13.537Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/8d/986af3c42f8454a6cafff8729d99fb178ae9b08a9816325ac7a8fa57c0c0/rpds_py-0.27.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f0396e894bd1e66c74ecbc08b4f6a03dc331140942c4b1d345dd131b68574a60", size = 416651, upload-time = "2025-08-07T08:26:14.923Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/9a/b4ec3629b7b447e896eec574469159b5b60b7781d3711c914748bf32de05/rpds_py-0.27.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:59714ab0a5af25d723d8e9816638faf7f4254234decb7d212715c1aa71eee7be", size = 559460, upload-time = "2025-08-07T08:26:16.295Z" },
-    { url = "https://files.pythonhosted.org/packages/61/63/d1e127b40c3e4733b3a6f26ae7a063cdf2bc1caa5272c89075425c7d397a/rpds_py-0.27.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:88051c3b7d5325409f433c5a40328fcb0685fc04e5db49ff936e910901d10114", size = 588072, upload-time = "2025-08-07T08:26:17.776Z" },
-    { url = "https://files.pythonhosted.org/packages/04/7e/8ffc71a8f6833d9c9fb999f5b0ee736b8b159fd66968e05c7afc2dbcd57e/rpds_py-0.27.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:181bc29e59e5e5e6e9d63b143ff4d5191224d355e246b5a48c88ce6b35c4e466", size = 555083, upload-time = "2025-08-07T08:26:19.301Z" },
-]
-
-[[package]]
-name = "s3transfer"
-version = "0.13.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "botocore" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/05/d52bf1e65044b4e5e27d4e63e8d1579dbdec54fce685908ae09bc3720030/s3transfer-0.13.1.tar.gz", hash = "sha256:c3fdba22ba1bd367922f27ec8032d6a1cf5f10c934fb5d68cf60fd5a23d936cf", size = 150589, upload-time = "2025-07-18T19:22:42.31Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6d/4f/d073e09df851cfa251ef7840007d04db3293a0482ce607d2b993926089be/s3transfer-0.13.1-py3-none-any.whl", hash = "sha256:a981aa7429be23fe6dfc13e80e4020057cbab622b08c0315288758d67cabc724", size = 85308, upload-time = "2025-07-18T19:22:40.947Z" },
-]
-
-[[package]]
-name = "schedule"
-version = "1.2.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0c/91/b525790063015759f34447d4cf9d2ccb52cdee0f1dd6ff8764e863bcb74c/schedule-1.2.2.tar.gz", hash = "sha256:15fe9c75fe5fd9b9627f3f19cc0ef1420508f9f9a46f45cd0769ef75ede5f0b7", size = 26452, upload-time = "2024-06-18T20:03:14.633Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/a7/84c96b61fd13205f2cafbe263cdb2745965974bdf3e0078f121dfeca5f02/schedule-1.2.2-py3-none-any.whl", hash = "sha256:5bef4a2a0183abf44046ae0d164cadcac21b1db011bdd8102e4a0c1e91e06a7d", size = 12220, upload-time = "2024-05-25T18:41:59.121Z" },
-]
-
-[[package]]
-name = "scipy"
-version = "1.15.3"
-source = { registry = "https://pypi.org/simple" }
-resolution-markers = [
-    "python_full_version < '3.11'",
-]
-dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/2f/4966032c5f8cc7e6a60f1b2e0ad686293b9474b65246b0c642e3ef3badd0/scipy-1.15.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a345928c86d535060c9c2b25e71e87c39ab2f22fc96e9636bd74d1dbf9de448c", size = 38702770, upload-time = "2025-05-08T16:04:20.849Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/6e/0c3bf90fae0e910c274db43304ebe25a6b391327f3f10b5dcc638c090795/scipy-1.15.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:ad3432cb0f9ed87477a8d97f03b763fd1d57709f1bbde3c9369b1dff5503b253", size = 30094511, upload-time = "2025-05-08T16:04:27.103Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/b1/4deb37252311c1acff7f101f6453f0440794f51b6eacb1aad4459a134081/scipy-1.15.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:aef683a9ae6eb00728a542b796f52a5477b78252edede72b8327a886ab63293f", size = 22368151, upload-time = "2025-05-08T16:04:31.731Z" },
-    { url = "https://files.pythonhosted.org/packages/38/7d/f457626e3cd3c29b3a49ca115a304cebb8cc6f31b04678f03b216899d3c6/scipy-1.15.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:1c832e1bd78dea67d5c16f786681b28dd695a8cb1fb90af2e27580d3d0967e92", size = 25121732, upload-time = "2025-05-08T16:04:36.596Z" },
-    { url = "https://files.pythonhosted.org/packages/db/0a/92b1de4a7adc7a15dcf5bddc6e191f6f29ee663b30511ce20467ef9b82e4/scipy-1.15.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:263961f658ce2165bbd7b99fa5135195c3a12d9bef045345016b8b50c315cb82", size = 35547617, upload-time = "2025-05-08T16:04:43.546Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/6d/41991e503e51fc1134502694c5fa7a1671501a17ffa12716a4a9151af3df/scipy-1.15.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2abc762b0811e09a0d3258abee2d98e0c703eee49464ce0069590846f31d40", size = 37662964, upload-time = "2025-05-08T16:04:49.431Z" },
-    { url = "https://files.pythonhosted.org/packages/25/e1/3df8f83cb15f3500478c889be8fb18700813b95e9e087328230b98d547ff/scipy-1.15.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed7284b21a7a0c8f1b6e5977ac05396c0d008b89e05498c8b7e8f4a1423bba0e", size = 37238749, upload-time = "2025-05-08T16:04:55.215Z" },
-    { url = "https://files.pythonhosted.org/packages/93/3e/b3257cf446f2a3533ed7809757039016b74cd6f38271de91682aa844cfc5/scipy-1.15.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5380741e53df2c566f4d234b100a484b420af85deb39ea35a1cc1be84ff53a5c", size = 40022383, upload-time = "2025-05-08T16:05:01.914Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/84/55bc4881973d3f79b479a5a2e2df61c8c9a04fcb986a213ac9c02cfb659b/scipy-1.15.3-cp310-cp310-win_amd64.whl", hash = "sha256:9d61e97b186a57350f6d6fd72640f9e99d5a4a2b8fbf4b9ee9a841eab327dc13", size = 41259201, upload-time = "2025-05-08T16:05:08.166Z" },
-    { url = "https://files.pythonhosted.org/packages/96/ab/5cc9f80f28f6a7dff646c5756e559823614a42b1939d86dd0ed550470210/scipy-1.15.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:993439ce220d25e3696d1b23b233dd010169b62f6456488567e830654ee37a6b", size = 38714255, upload-time = "2025-05-08T16:05:14.596Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/4a/66ba30abe5ad1a3ad15bfb0b59d22174012e8056ff448cb1644deccbfed2/scipy-1.15.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:34716e281f181a02341ddeaad584205bd2fd3c242063bd3423d61ac259ca7eba", size = 30111035, upload-time = "2025-05-08T16:05:20.152Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/fa/a7e5b95afd80d24313307f03624acc65801846fa75599034f8ceb9e2cbf6/scipy-1.15.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3b0334816afb8b91dab859281b1b9786934392aa3d527cd847e41bb6f45bee65", size = 22384499, upload-time = "2025-05-08T16:05:24.494Z" },
-    { url = "https://files.pythonhosted.org/packages/17/99/f3aaddccf3588bb4aea70ba35328c204cadd89517a1612ecfda5b2dd9d7a/scipy-1.15.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:6db907c7368e3092e24919b5e31c76998b0ce1684d51a90943cb0ed1b4ffd6c1", size = 25152602, upload-time = "2025-05-08T16:05:29.313Z" },
-    { url = "https://files.pythonhosted.org/packages/56/c5/1032cdb565f146109212153339f9cb8b993701e9fe56b1c97699eee12586/scipy-1.15.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721d6b4ef5dc82ca8968c25b111e307083d7ca9091bc38163fb89243e85e3889", size = 35503415, upload-time = "2025-05-08T16:05:34.699Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/37/89f19c8c05505d0601ed5650156e50eb881ae3918786c8fd7262b4ee66d3/scipy-1.15.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39cb9c62e471b1bb3750066ecc3a3f3052b37751c7c3dfd0fd7e48900ed52982", size = 37652622, upload-time = "2025-05-08T16:05:40.762Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/31/be59513aa9695519b18e1851bb9e487de66f2d31f835201f1b42f5d4d475/scipy-1.15.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:795c46999bae845966368a3c013e0e00947932d68e235702b5c3f6ea799aa8c9", size = 37244796, upload-time = "2025-05-08T16:05:48.119Z" },
-    { url = "https://files.pythonhosted.org/packages/10/c0/4f5f3eeccc235632aab79b27a74a9130c6c35df358129f7ac8b29f562ac7/scipy-1.15.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:18aaacb735ab38b38db42cb01f6b92a2d0d4b6aabefeb07f02849e47f8fb3594", size = 40047684, upload-time = "2025-05-08T16:05:54.22Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/a7/0ddaf514ce8a8714f6ed243a2b391b41dbb65251affe21ee3077ec45ea9a/scipy-1.15.3-cp311-cp311-win_amd64.whl", hash = "sha256:ae48a786a28412d744c62fd7816a4118ef97e5be0bee968ce8f0a2fba7acf3bb", size = 41246504, upload-time = "2025-05-08T16:06:00.437Z" },
-    { url = "https://files.pythonhosted.org/packages/37/4b/683aa044c4162e10ed7a7ea30527f2cbd92e6999c10a8ed8edb253836e9c/scipy-1.15.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6ac6310fdbfb7aa6612408bd2f07295bcbd3fda00d2d702178434751fe48e019", size = 38766735, upload-time = "2025-05-08T16:06:06.471Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/7e/f30be3d03de07f25dc0ec926d1681fed5c732d759ac8f51079708c79e680/scipy-1.15.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:185cd3d6d05ca4b44a8f1595af87f9c372bb6acf9c808e99aa3e9aa03bd98cf6", size = 30173284, upload-time = "2025-05-08T16:06:11.686Z" },
-    { url = "https://files.pythonhosted.org/packages/07/9c/0ddb0d0abdabe0d181c1793db51f02cd59e4901da6f9f7848e1f96759f0d/scipy-1.15.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:05dc6abcd105e1a29f95eada46d4a3f251743cfd7d3ae8ddb4088047f24ea477", size = 22446958, upload-time = "2025-05-08T16:06:15.97Z" },
-    { url = "https://files.pythonhosted.org/packages/af/43/0bce905a965f36c58ff80d8bea33f1f9351b05fad4beaad4eae34699b7a1/scipy-1.15.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:06efcba926324df1696931a57a176c80848ccd67ce6ad020c810736bfd58eb1c", size = 25242454, upload-time = "2025-05-08T16:06:20.394Z" },
-    { url = "https://files.pythonhosted.org/packages/56/30/a6f08f84ee5b7b28b4c597aca4cbe545535c39fe911845a96414700b64ba/scipy-1.15.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05045d8b9bfd807ee1b9f38761993297b10b245f012b11b13b91ba8945f7e45", size = 35210199, upload-time = "2025-05-08T16:06:26.159Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/1f/03f52c282437a168ee2c7c14a1a0d0781a9a4a8962d84ac05c06b4c5b555/scipy-1.15.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:271e3713e645149ea5ea3e97b57fdab61ce61333f97cfae392c28ba786f9bb49", size = 37309455, upload-time = "2025-05-08T16:06:32.778Z" },
-    { url = "https://files.pythonhosted.org/packages/89/b1/fbb53137f42c4bf630b1ffdfc2151a62d1d1b903b249f030d2b1c0280af8/scipy-1.15.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6cfd56fc1a8e53f6e89ba3a7a7251f7396412d655bca2aa5611c8ec9a6784a1e", size = 36885140, upload-time = "2025-05-08T16:06:39.249Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/2e/025e39e339f5090df1ff266d021892694dbb7e63568edcfe43f892fa381d/scipy-1.15.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ff17c0bb1cb32952c09217d8d1eed9b53d1463e5f1dd6052c7857f83127d539", size = 39710549, upload-time = "2025-05-08T16:06:45.729Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/eb/3bf6ea8ab7f1503dca3a10df2e4b9c3f6b3316df07f6c0ded94b281c7101/scipy-1.15.3-cp312-cp312-win_amd64.whl", hash = "sha256:52092bc0472cfd17df49ff17e70624345efece4e1a12b23783a1ac59a1b728ed", size = 40966184, upload-time = "2025-05-08T16:06:52.623Z" },
-]
-
-[[package]]
-name = "scipy"
-version = "1.16.1"
-source = { registry = "https://pypi.org/simple" }
-resolution-markers = [
-    "python_full_version >= '3.12'",
-    "python_full_version == '3.11.*'",
-]
-dependencies = [
-    { name = "numpy", version = "2.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f5/4a/b927028464795439faec8eaf0b03b011005c487bb2d07409f28bf30879c4/scipy-1.16.1.tar.gz", hash = "sha256:44c76f9e8b6e8e488a586190ab38016e4ed2f8a038af7cd3defa903c0a2238b3", size = 30580861, upload-time = "2025-07-27T16:33:30.834Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/da/91/812adc6f74409b461e3a5fa97f4f74c769016919203138a3bf6fc24ba4c5/scipy-1.16.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:c033fa32bab91dc98ca59d0cf23bb876454e2bb02cbe592d5023138778f70030", size = 36552519, upload-time = "2025-07-27T16:26:29.658Z" },
-    { url = "https://files.pythonhosted.org/packages/47/18/8e355edcf3b71418d9e9f9acd2708cc3a6c27e8f98fde0ac34b8a0b45407/scipy-1.16.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:6e5c2f74e5df33479b5cd4e97a9104c511518fbd979aa9b8f6aec18b2e9ecae7", size = 28638010, upload-time = "2025-07-27T16:26:38.196Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/eb/e931853058607bdfbc11b86df19ae7a08686121c203483f62f1ecae5989c/scipy-1.16.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:0a55ffe0ba0f59666e90951971a884d1ff6f4ec3275a48f472cfb64175570f77", size = 20909790, upload-time = "2025-07-27T16:26:43.93Z" },
-    { url = "https://files.pythonhosted.org/packages/45/0c/be83a271d6e96750cd0be2e000f35ff18880a46f05ce8b5d3465dc0f7a2a/scipy-1.16.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:f8a5d6cd147acecc2603fbd382fed6c46f474cccfcf69ea32582e033fb54dcfe", size = 23513352, upload-time = "2025-07-27T16:26:50.017Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/bf/fe6eb47e74f762f933cca962db7f2c7183acfdc4483bd1c3813cfe83e538/scipy-1.16.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb18899127278058bcc09e7b9966d41a5a43740b5bb8dcba401bd983f82e885b", size = 33534643, upload-time = "2025-07-27T16:26:57.503Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/ba/63f402e74875486b87ec6506a4f93f6d8a0d94d10467280f3d9d7837ce3a/scipy-1.16.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adccd93a2fa937a27aae826d33e3bfa5edf9aa672376a4852d23a7cd67a2e5b7", size = 35376776, upload-time = "2025-07-27T16:27:06.639Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/b4/04eb9d39ec26a1b939689102da23d505ea16cdae3dbb18ffc53d1f831044/scipy-1.16.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:18aca1646a29ee9a0625a1be5637fa798d4d81fdf426481f06d69af828f16958", size = 35698906, upload-time = "2025-07-27T16:27:14.943Z" },
-    { url = "https://files.pythonhosted.org/packages/04/d6/bb5468da53321baeb001f6e4e0d9049eadd175a4a497709939128556e3ec/scipy-1.16.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d85495cef541729a70cdddbbf3e6b903421bc1af3e8e3a9a72a06751f33b7c39", size = 38129275, upload-time = "2025-07-27T16:27:23.873Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/94/994369978509f227cba7dfb9e623254d0d5559506fe994aef4bea3ed469c/scipy-1.16.1-cp311-cp311-win_amd64.whl", hash = "sha256:226652fca853008119c03a8ce71ffe1b3f6d2844cc1686e8f9806edafae68596", size = 38644572, upload-time = "2025-07-27T16:27:32.637Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/d9/ec4864f5896232133f51382b54a08de91a9d1af7a76dfa372894026dfee2/scipy-1.16.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:81b433bbeaf35728dad619afc002db9b189e45eebe2cd676effe1fb93fef2b9c", size = 36575194, upload-time = "2025-07-27T16:27:41.321Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/6d/40e81ecfb688e9d25d34a847dca361982a6addf8e31f0957b1a54fbfa994/scipy-1.16.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:886cc81fdb4c6903a3bb0464047c25a6d1016fef77bb97949817d0c0d79f9e04", size = 28594590, upload-time = "2025-07-27T16:27:49.204Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/37/9f65178edfcc629377ce9a64fc09baebea18c80a9e57ae09a52edf84880b/scipy-1.16.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:15240c3aac087a522b4eaedb09f0ad061753c5eebf1ea430859e5bf8640d5919", size = 20866458, upload-time = "2025-07-27T16:27:54.98Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/7b/749a66766871ea4cb1d1ea10f27004db63023074c22abed51f22f09770e0/scipy-1.16.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:65f81a25805f3659b48126b5053d9e823d3215e4a63730b5e1671852a1705921", size = 23539318, upload-time = "2025-07-27T16:28:01.604Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/db/8d4afec60eb833a666434d4541a3151eedbf2494ea6d4d468cbe877f00cd/scipy-1.16.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6c62eea7f607f122069b9bad3f99489ddca1a5173bef8a0c75555d7488b6f725", size = 33292899, upload-time = "2025-07-27T16:28:09.147Z" },
-    { url = "https://files.pythonhosted.org/packages/51/1e/79023ca3bbb13a015d7d2757ecca3b81293c663694c35d6541b4dca53e98/scipy-1.16.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f965bbf3235b01c776115ab18f092a95aa74c271a52577bcb0563e85738fd618", size = 35162637, upload-time = "2025-07-27T16:28:17.535Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/49/0648665f9c29fdaca4c679182eb972935b3b4f5ace41d323c32352f29816/scipy-1.16.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f006e323874ffd0b0b816d8c6a8e7f9a73d55ab3b8c3f72b752b226d0e3ac83d", size = 35490507, upload-time = "2025-07-27T16:28:25.705Z" },
-    { url = "https://files.pythonhosted.org/packages/62/8f/66cbb9d6bbb18d8c658f774904f42a92078707a7c71e5347e8bf2f52bb89/scipy-1.16.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8fd15fc5085ab4cca74cb91fe0a4263b1f32e4420761ddae531ad60934c2119", size = 37923998, upload-time = "2025-07-27T16:28:34.339Z" },
-    { url = "https://files.pythonhosted.org/packages/14/c3/61f273ae550fbf1667675701112e380881905e28448c080b23b5a181df7c/scipy-1.16.1-cp312-cp312-win_amd64.whl", hash = "sha256:f7b8013c6c066609577d910d1a2a077021727af07b6fab0ee22c2f901f22352a", size = 38508060, upload-time = "2025-07-27T16:28:43.242Z" },
-]
-
-[[package]]
-name = "six"
-version = "1.17.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
-]
-
-[[package]]
-name = "sniffio"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
-]
-
-[[package]]
-name = "sqlalchemy"
-version = "2.0.43"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d7/bc/d59b5d97d27229b0e009bd9098cd81af71c2fa5549c580a0a67b9bed0496/sqlalchemy-2.0.43.tar.gz", hash = "sha256:788bfcef6787a7764169cfe9859fe425bf44559619e1d9f56f5bddf2ebf6f417", size = 9762949, upload-time = "2025-08-11T14:24:58.438Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8f/4e/985f7da36f09592c5ade99321c72c15101d23c0bb7eecfd1daaca5714422/sqlalchemy-2.0.43-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:70322986c0c699dca241418fcf18e637a4369e0ec50540a2b907b184c8bca069", size = 2133162, upload-time = "2025-08-11T15:52:17.854Z" },
-    { url = "https://files.pythonhosted.org/packages/37/34/798af8db3cae069461e3bc0898a1610dc469386a97048471d364dc8aae1c/sqlalchemy-2.0.43-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:87accdbba88f33efa7b592dc2e8b2a9c2cdbca73db2f9d5c510790428c09c154", size = 2123082, upload-time = "2025-08-11T15:52:19.181Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/0f/79cf4d9dad42f61ec5af1e022c92f66c2d110b93bb1dc9b033892971abfa/sqlalchemy-2.0.43-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c00e7845d2f692ebfc7d5e4ec1a3fd87698e4337d09e58d6749a16aedfdf8612", size = 3208871, upload-time = "2025-08-11T15:50:30.656Z" },
-    { url = "https://files.pythonhosted.org/packages/56/b3/59befa58fb0e1a9802c87df02344548e6d007e77e87e6084e2131c29e033/sqlalchemy-2.0.43-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:022e436a1cb39b13756cf93b48ecce7aa95382b9cfacceb80a7d263129dfd019", size = 3209583, upload-time = "2025-08-11T15:57:47.697Z" },
-    { url = "https://files.pythonhosted.org/packages/29/d2/124b50c0eb8146e8f0fe16d01026c1a073844f0b454436d8544fe9b33bd7/sqlalchemy-2.0.43-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c5e73ba0d76eefc82ec0219d2301cb33bfe5205ed7a2602523111e2e56ccbd20", size = 3148177, upload-time = "2025-08-11T15:50:32.078Z" },
-    { url = "https://files.pythonhosted.org/packages/83/f5/e369cd46aa84278107624617034a5825fedfc5c958b2836310ced4d2eadf/sqlalchemy-2.0.43-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9c2e02f06c68092b875d5cbe4824238ab93a7fa35d9c38052c033f7ca45daa18", size = 3172276, upload-time = "2025-08-11T15:57:49.477Z" },
-    { url = "https://files.pythonhosted.org/packages/de/2b/4602bf4c3477fa4c837c9774e6dd22e0389fc52310c4c4dfb7e7ba05e90d/sqlalchemy-2.0.43-cp310-cp310-win32.whl", hash = "sha256:e7a903b5b45b0d9fa03ac6a331e1c1d6b7e0ab41c63b6217b3d10357b83c8b00", size = 2101491, upload-time = "2025-08-11T15:54:59.191Z" },
-    { url = "https://files.pythonhosted.org/packages/38/2d/bfc6b6143adef553a08295490ddc52607ee435b9c751c714620c1b3dd44d/sqlalchemy-2.0.43-cp310-cp310-win_amd64.whl", hash = "sha256:4bf0edb24c128b7be0c61cd17eef432e4bef507013292415f3fb7023f02b7d4b", size = 2125148, upload-time = "2025-08-11T15:55:00.593Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/77/fa7189fe44114658002566c6fe443d3ed0ec1fa782feb72af6ef7fbe98e7/sqlalchemy-2.0.43-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:52d9b73b8fb3e9da34c2b31e6d99d60f5f99fd8c1225c9dad24aeb74a91e1d29", size = 2136472, upload-time = "2025-08-11T15:52:21.789Z" },
-    { url = "https://files.pythonhosted.org/packages/99/ea/92ac27f2fbc2e6c1766bb807084ca455265707e041ba027c09c17d697867/sqlalchemy-2.0.43-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f42f23e152e4545157fa367b2435a1ace7571cab016ca26038867eb7df2c3631", size = 2126535, upload-time = "2025-08-11T15:52:23.109Z" },
-    { url = "https://files.pythonhosted.org/packages/94/12/536ede80163e295dc57fff69724caf68f91bb40578b6ac6583a293534849/sqlalchemy-2.0.43-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fb1a8c5438e0c5ea51afe9c6564f951525795cf432bed0c028c1cb081276685", size = 3297521, upload-time = "2025-08-11T15:50:33.536Z" },
-    { url = "https://files.pythonhosted.org/packages/03/b5/cacf432e6f1fc9d156eca0560ac61d4355d2181e751ba8c0cd9cb232c8c1/sqlalchemy-2.0.43-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db691fa174e8f7036afefe3061bc40ac2b770718be2862bfb03aabae09051aca", size = 3297343, upload-time = "2025-08-11T15:57:51.186Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/ba/d4c9b526f18457667de4c024ffbc3a0920c34237b9e9dd298e44c7c00ee5/sqlalchemy-2.0.43-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fe2b3b4927d0bc03d02ad883f402d5de201dbc8894ac87d2e981e7d87430e60d", size = 3232113, upload-time = "2025-08-11T15:50:34.949Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/79/c0121b12b1b114e2c8a10ea297a8a6d5367bc59081b2be896815154b1163/sqlalchemy-2.0.43-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4d3d9b904ad4a6b175a2de0738248822f5ac410f52c2fd389ada0b5262d6a1e3", size = 3258240, upload-time = "2025-08-11T15:57:52.983Z" },
-    { url = "https://files.pythonhosted.org/packages/79/99/a2f9be96fb382f3ba027ad42f00dbe30fdb6ba28cda5f11412eee346bec5/sqlalchemy-2.0.43-cp311-cp311-win32.whl", hash = "sha256:5cda6b51faff2639296e276591808c1726c4a77929cfaa0f514f30a5f6156921", size = 2101248, upload-time = "2025-08-11T15:55:01.855Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/13/744a32ebe3b4a7a9c7ea4e57babae7aa22070d47acf330d8e5a1359607f1/sqlalchemy-2.0.43-cp311-cp311-win_amd64.whl", hash = "sha256:c5d1730b25d9a07727d20ad74bc1039bbbb0a6ca24e6769861c1aa5bf2c4c4a8", size = 2126109, upload-time = "2025-08-11T15:55:04.092Z" },
-    { url = "https://files.pythonhosted.org/packages/61/db/20c78f1081446095450bdc6ee6cc10045fce67a8e003a5876b6eaafc5cc4/sqlalchemy-2.0.43-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:20d81fc2736509d7a2bd33292e489b056cbae543661bb7de7ce9f1c0cd6e7f24", size = 2134891, upload-time = "2025-08-11T15:51:13.019Z" },
-    { url = "https://files.pythonhosted.org/packages/45/0a/3d89034ae62b200b4396f0f95319f7d86e9945ee64d2343dcad857150fa2/sqlalchemy-2.0.43-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25b9fc27650ff5a2c9d490c13c14906b918b0de1f8fcbb4c992712d8caf40e83", size = 2123061, upload-time = "2025-08-11T15:51:14.319Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/10/2711f7ff1805919221ad5bee205971254845c069ee2e7036847103ca1e4c/sqlalchemy-2.0.43-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6772e3ca8a43a65a37c88e2f3e2adfd511b0b1da37ef11ed78dea16aeae85bd9", size = 3320384, upload-time = "2025-08-11T15:52:35.088Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/0e/3d155e264d2ed2778484006ef04647bc63f55b3e2d12e6a4f787747b5900/sqlalchemy-2.0.43-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a113da919c25f7f641ffbd07fbc9077abd4b3b75097c888ab818f962707eb48", size = 3329648, upload-time = "2025-08-11T15:56:34.153Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/81/635100fb19725c931622c673900da5efb1595c96ff5b441e07e3dd61f2be/sqlalchemy-2.0.43-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4286a1139f14b7d70141c67a8ae1582fc2b69105f1b09d9573494eb4bb4b2687", size = 3258030, upload-time = "2025-08-11T15:52:36.933Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/ed/a99302716d62b4965fded12520c1cbb189f99b17a6d8cf77611d21442e47/sqlalchemy-2.0.43-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:529064085be2f4d8a6e5fab12d36ad44f1909a18848fcfbdb59cc6d4bbe48efe", size = 3294469, upload-time = "2025-08-11T15:56:35.553Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/a2/3a11b06715149bf3310b55a98b5c1e84a42cfb949a7b800bc75cb4e33abc/sqlalchemy-2.0.43-cp312-cp312-win32.whl", hash = "sha256:b535d35dea8bbb8195e7e2b40059e2253acb2b7579b73c1b432a35363694641d", size = 2098906, upload-time = "2025-08-11T15:55:00.645Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/09/405c915a974814b90aa591280623adc6ad6b322f61fd5cff80aeaef216c9/sqlalchemy-2.0.43-cp312-cp312-win_amd64.whl", hash = "sha256:1c6d85327ca688dbae7e2b06d7d84cfe4f3fffa5b5f9e21bb6ce9d0e1a0e0e0a", size = 2126260, upload-time = "2025-08-11T15:55:02.965Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/d9/13bdde6521f322861fab67473cec4b1cc8999f3871953531cf61945fad92/sqlalchemy-2.0.43-py3-none-any.whl", hash = "sha256:1681c21dd2ccee222c2fe0bef671d1aef7c504087c9c4e800371cfcc8ac966fc", size = 1924759, upload-time = "2025-08-11T15:39:53.024Z" },
-]
-
-[[package]]
-name = "sse-starlette"
-version = "3.0.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/42/6f/22ed6e33f8a9e76ca0a412405f31abb844b779d52c5f96660766edcd737c/sse_starlette-3.0.2.tar.gz", hash = "sha256:ccd60b5765ebb3584d0de2d7a6e4f745672581de4f5005ab31c3a25d10b52b3a", size = 20985, upload-time = "2025-07-27T09:07:44.565Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/10/c78f463b4ef22eef8491f218f692be838282cd65480f6e423d7730dfd1fb/sse_starlette-3.0.2-py3-none-any.whl", hash = "sha256:16b7cbfddbcd4eaca11f7b586f3b8a080f1afe952c15813455b162edea619e5a", size = 11297, upload-time = "2025-07-27T09:07:43.268Z" },
-]
-
-[[package]]
-name = "starlette"
-version = "0.47.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/15/b9/cc3017f9a9c9b6e27c5106cc10cc7904653c3eec0729793aec10479dd669/starlette-0.47.3.tar.gz", hash = "sha256:6bc94f839cc176c4858894f1f8908f0ab79dfec1a6b8402f6da9be26ebea52e9", size = 2584144, upload-time = "2025-08-24T13:36:42.122Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ce/fd/901cfa59aaa5b30a99e16876f11abe38b59a1a2c51ffb3d7142bb6089069/starlette-0.47.3-py3-none-any.whl", hash = "sha256:89c0778ca62a76b826101e7c709e70680a1699ca7da6b44d38eb0a7e61fe4b51", size = 72991, upload-time = "2025-08-24T13:36:40.887Z" },
-]
-
-[[package]]
-name = "tenacity"
-version = "9.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036, upload-time = "2025-04-02T08:25:09.966Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248, upload-time = "2025-04-02T08:25:07.678Z" },
-]
-
-[[package]]
-name = "tqdm"
-version = "4.67.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
-]
-
-[[package]]
-name = "types-requests"
-version = "2.32.4.20250809"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "urllib3" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ed/b0/9355adb86ec84d057fea765e4c49cce592aaf3d5117ce5609a95a7fc3dac/types_requests-2.32.4.20250809.tar.gz", hash = "sha256:d8060de1c8ee599311f56ff58010fb4902f462a1470802cf9f6ed27bc46c4df3", size = 23027, upload-time = "2025-08-09T03:17:10.664Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2b/6f/ec0012be842b1d888d46884ac5558fd62aeae1f0ec4f7a581433d890d4b5/types_requests-2.32.4.20250809-py3-none-any.whl", hash = "sha256:f73d1832fb519ece02c85b1f09d5f0dd3108938e7d47e7f94bbfa18a6782b163", size = 20644, upload-time = "2025-08-09T03:17:09.716Z" },
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.14.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/98/5a/da40306b885cc8c09109dc2e1abd358d5684b1425678151cdaed4731c822/typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36", size = 107673, upload-time = "2025-07-04T13:28:34.16Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b5/00/d631e67a838026495268c2f6884f3711a15a9a2a96cd244fdaea53b823fb/typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76", size = 43906, upload-time = "2025-07-04T13:28:32.743Z" },
-]
-
-[[package]]
-name = "typing-inspection"
-version = "0.4.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" },
-]
-
-[[package]]
-name = "tzdata"
-version = "2025.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" },
-]
-
-[[package]]
-name = "urllib3"
-version = "2.5.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" },
-]
-
-[[package]]
-name = "uvicorn"
-version = "0.35.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "h11" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5e/42/e0e305207bb88c6b8d3061399c6a961ffe5fbb7e2aa63c9234df7259e9cd/uvicorn-0.35.0.tar.gz", hash = "sha256:bc662f087f7cf2ce11a1d7fd70b90c9f98ef2e2831556dd078d131b96cc94a01", size = 78473, upload-time = "2025-06-28T16:15:46.058Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/e2/dc81b1bd1dcfe91735810265e9d26bc8ec5da45b4c0f6237e286819194c3/uvicorn-0.35.0-py3-none-any.whl", hash = "sha256:197535216b25ff9b785e29a0b79199f55222193d47f820816e7da751e9bc8d4a", size = 66406, upload-time = "2025-06-28T16:15:44.816Z" },
-]
-
-[[package]]
-name = "websocket-client"
-version = "1.8.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e6/30/fba0d96b4b5fbf5948ed3f4681f7da2f9f64512e1d303f94b4cc174c24a5/websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da", size = 54648, upload-time = "2024-04-23T22:16:16.976Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826, upload-time = "2024-04-23T22:16:14.422Z" },
-]
-
-[[package]]
-name = "websockets"
-version = "15.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/da/6462a9f510c0c49837bbc9345aca92d767a56c1fb2939e1579df1e1cdcf7/websockets-15.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d63efaa0cd96cf0c5fe4d581521d9fa87744540d4bc999ae6e08595a1014b45b", size = 175423, upload-time = "2025-03-05T20:01:35.363Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/9f/9d11c1a4eb046a9e106483b9ff69bce7ac880443f00e5ce64261b47b07e7/websockets-15.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac60e3b188ec7574cb761b08d50fcedf9d77f1530352db4eef1707fe9dee7205", size = 173080, upload-time = "2025-03-05T20:01:37.304Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/4f/b462242432d93ea45f297b6179c7333dd0402b855a912a04e7fc61c0d71f/websockets-15.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5756779642579d902eed757b21b0164cd6fe338506a8083eb58af5c372e39d9a", size = 173329, upload-time = "2025-03-05T20:01:39.668Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/0c/6afa1f4644d7ed50284ac59cc70ef8abd44ccf7d45850d989ea7310538d0/websockets-15.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fdfe3e2a29e4db3659dbd5bbf04560cea53dd9610273917799f1cde46aa725e", size = 182312, upload-time = "2025-03-05T20:01:41.815Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/d4/ffc8bd1350b229ca7a4db2a3e1c482cf87cea1baccd0ef3e72bc720caeec/websockets-15.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c2529b320eb9e35af0fa3016c187dffb84a3ecc572bcee7c3ce302bfeba52bf", size = 181319, upload-time = "2025-03-05T20:01:43.967Z" },
-    { url = "https://files.pythonhosted.org/packages/97/3a/5323a6bb94917af13bbb34009fac01e55c51dfde354f63692bf2533ffbc2/websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac1e5c9054fe23226fb11e05a6e630837f074174c4c2f0fe442996112a6de4fb", size = 181631, upload-time = "2025-03-05T20:01:46.104Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/cc/1aeb0f7cee59ef065724041bb7ed667b6ab1eeffe5141696cccec2687b66/websockets-15.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5df592cd503496351d6dc14f7cdad49f268d8e618f80dce0cd5a36b93c3fc08d", size = 182016, upload-time = "2025-03-05T20:01:47.603Z" },
-    { url = "https://files.pythonhosted.org/packages/79/f9/c86f8f7af208e4161a7f7e02774e9d0a81c632ae76db2ff22549e1718a51/websockets-15.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a34631031a8f05657e8e90903e656959234f3a04552259458aac0b0f9ae6fd9", size = 181426, upload-time = "2025-03-05T20:01:48.949Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/b9/828b0bc6753db905b91df6ae477c0b14a141090df64fb17f8a9d7e3516cf/websockets-15.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d00075aa65772e7ce9e990cab3ff1de702aa09be3940d1dc88d5abf1ab8a09c", size = 181360, upload-time = "2025-03-05T20:01:50.938Z" },
-    { url = "https://files.pythonhosted.org/packages/89/fb/250f5533ec468ba6327055b7d98b9df056fb1ce623b8b6aaafb30b55d02e/websockets-15.0.1-cp310-cp310-win32.whl", hash = "sha256:1234d4ef35db82f5446dca8e35a7da7964d02c127b095e172e54397fb6a6c256", size = 176388, upload-time = "2025-03-05T20:01:52.213Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/46/aca7082012768bb98e5608f01658ff3ac8437e563eca41cf068bd5849a5e/websockets-15.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:39c1fec2c11dc8d89bba6b2bf1556af381611a173ac2b511cf7231622058af41", size = 176830, upload-time = "2025-03-05T20:01:53.922Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
-    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
-    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
-    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
-    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
-    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
-    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
-    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
-    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
-    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
-    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
-    { url = "https://files.pythonhosted.org/packages/02/9e/d40f779fa16f74d3468357197af8d6ad07e7c5a27ea1ca74ceb38986f77a/websockets-15.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0c9e74d766f2818bb95f84c25be4dea09841ac0f734d1966f415e4edfc4ef1c3", size = 173109, upload-time = "2025-03-05T20:03:17.769Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/cd/5b887b8585a593073fd92f7c23ecd3985cd2c3175025a91b0d69b0551372/websockets-15.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1009ee0c7739c08a0cd59de430d6de452a55e42d6b522de7aa15e6f67db0b8e1", size = 173343, upload-time = "2025-03-05T20:03:19.094Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/ae/d34f7556890341e900a95acf4886833646306269f899d58ad62f588bf410/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d1f20b1c7a2fa82367e04982e708723ba0e7b8d43aa643d3dcd404d74f1475", size = 174599, upload-time = "2025-03-05T20:03:21.1Z" },
-    { url = "https://files.pythonhosted.org/packages/71/e6/5fd43993a87db364ec60fc1d608273a1a465c0caba69176dd160e197ce42/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f29d80eb9a9263b8d109135351caf568cc3f80b9928bccde535c235de55c22d9", size = 174207, upload-time = "2025-03-05T20:03:23.221Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/fb/c492d6daa5ec067c2988ac80c61359ace5c4c674c532985ac5a123436cec/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b359ed09954d7c18bbc1680f380c7301f92c60bf924171629c5db97febb12f04", size = 174155, upload-time = "2025-03-05T20:03:25.321Z" },
-    { url = "https://files.pythonhosted.org/packages/68/a1/dcb68430b1d00b698ae7a7e0194433bce4f07ded185f0ee5fb21e2a2e91e/websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122", size = 176884, upload-time = "2025-03-05T20:03:27.934Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
-]
-
-[[package]]
-name = "wrapt"
-version = "1.17.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/23/bb82321b86411eb51e5a5db3fb8f8032fd30bd7c2d74bfe936136b2fa1d6/wrapt-1.17.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88bbae4d40d5a46142e70d58bf664a89b6b4befaea7b2ecc14e03cedb8e06c04", size = 53482, upload-time = "2025-08-12T05:51:44.467Z" },
-    { url = "https://files.pythonhosted.org/packages/45/69/f3c47642b79485a30a59c63f6d739ed779fb4cc8323205d047d741d55220/wrapt-1.17.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6b13af258d6a9ad602d57d889f83b9d5543acd471eee12eb51f5b01f8eb1bc2", size = 38676, upload-time = "2025-08-12T05:51:32.636Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/71/e7e7f5670c1eafd9e990438e69d8fb46fa91a50785332e06b560c869454f/wrapt-1.17.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd341868a4b6714a5962c1af0bd44f7c404ef78720c7de4892901e540417111c", size = 38957, upload-time = "2025-08-12T05:51:54.655Z" },
-    { url = "https://files.pythonhosted.org/packages/de/17/9f8f86755c191d6779d7ddead1a53c7a8aa18bccb7cea8e7e72dfa6a8a09/wrapt-1.17.3-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f9b2601381be482f70e5d1051a5965c25fb3625455a2bf520b5a077b22afb775", size = 81975, upload-time = "2025-08-12T05:52:30.109Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/15/dd576273491f9f43dd09fce517f6c2ce6eb4fe21681726068db0d0467096/wrapt-1.17.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:343e44b2a8e60e06a7e0d29c1671a0d9951f59174f3709962b5143f60a2a98bd", size = 83149, upload-time = "2025-08-12T05:52:09.316Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/c4/5eb4ce0d4814521fee7aa806264bf7a114e748ad05110441cd5b8a5c744b/wrapt-1.17.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:33486899acd2d7d3066156b03465b949da3fd41a5da6e394ec49d271baefcf05", size = 82209, upload-time = "2025-08-12T05:52:10.331Z" },
-    { url = "https://files.pythonhosted.org/packages/31/4b/819e9e0eb5c8dc86f60dfc42aa4e2c0d6c3db8732bce93cc752e604bb5f5/wrapt-1.17.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e6f40a8aa5a92f150bdb3e1c44b7e98fb7113955b2e5394122fa5532fec4b418", size = 81551, upload-time = "2025-08-12T05:52:31.137Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/83/ed6baf89ba3a56694700139698cf703aac9f0f9eb03dab92f57551bd5385/wrapt-1.17.3-cp310-cp310-win32.whl", hash = "sha256:a36692b8491d30a8c75f1dfee65bef119d6f39ea84ee04d9f9311f83c5ad9390", size = 36464, upload-time = "2025-08-12T05:53:01.204Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/90/ee61d36862340ad7e9d15a02529df6b948676b9a5829fd5e16640156627d/wrapt-1.17.3-cp310-cp310-win_amd64.whl", hash = "sha256:afd964fd43b10c12213574db492cb8f73b2f0826c8df07a68288f8f19af2ebe6", size = 38748, upload-time = "2025-08-12T05:53:00.209Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/c3/cefe0bd330d389c9983ced15d326f45373f4073c9f4a8c2f99b50bfea329/wrapt-1.17.3-cp310-cp310-win_arm64.whl", hash = "sha256:af338aa93554be859173c39c85243970dc6a289fa907402289eeae7543e1ae18", size = 36810, upload-time = "2025-08-12T05:52:51.906Z" },
-    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
-    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
-    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
-    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
-    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
-    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
-    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
-]
-
-[[package]]
-name = "xmltodict"
-version = "0.14.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/50/05/51dcca9a9bf5e1bce52582683ce50980bcadbc4fa5143b9f2b19ab99958f/xmltodict-0.14.2.tar.gz", hash = "sha256:201e7c28bb210e374999d1dde6382923ab0ed1a8a5faeece48ab525b7810a553", size = 51942, upload-time = "2024-10-16T06:10:29.683Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d6/45/fc303eb433e8a2a271739c98e953728422fa61a3c1f36077a49e395c972e/xmltodict-0.14.2-py2.py3-none-any.whl", hash = "sha256:20cc7d723ed729276e808f26fb6b3599f786cbc37e06c65e192ba77c40f20aac", size = 9981, upload-time = "2024-10-16T06:10:27.649Z" },
-]
-
-[[package]]
-name = "yarl"
-version = "1.20.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "idna" },
-    { name = "multidict" },
-    { name = "propcache" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/3c/fb/efaa23fa4e45537b827620f04cf8f3cd658b76642205162e072703a5b963/yarl-1.20.1.tar.gz", hash = "sha256:d017a4997ee50c91fd5466cef416231bb82177b93b029906cefc542ce14c35ac", size = 186428, upload-time = "2025-06-10T00:46:09.923Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/65/7fed0d774abf47487c64be14e9223749468922817b5e8792b8a64792a1bb/yarl-1.20.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:6032e6da6abd41e4acda34d75a816012717000fa6839f37124a47fcefc49bec4", size = 132910, upload-time = "2025-06-10T00:42:31.108Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/7b/988f55a52da99df9e56dc733b8e4e5a6ae2090081dc2754fc8fd34e60aa0/yarl-1.20.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2c7b34d804b8cf9b214f05015c4fee2ebe7ed05cf581e7192c06555c71f4446a", size = 90644, upload-time = "2025-06-10T00:42:33.851Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/de/30d98f03e95d30c7e3cc093759982d038c8833ec2451001d45ef4854edc1/yarl-1.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0c869f2651cc77465f6cd01d938d91a11d9ea5d798738c1dc077f3de0b5e5fed", size = 89322, upload-time = "2025-06-10T00:42:35.688Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/7a/f2f314f5ebfe9200724b0b748de2186b927acb334cf964fd312eb86fc286/yarl-1.20.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62915e6688eb4d180d93840cda4110995ad50c459bf931b8b3775b37c264af1e", size = 323786, upload-time = "2025-06-10T00:42:37.817Z" },
-    { url = "https://files.pythonhosted.org/packages/15/3f/718d26f189db96d993d14b984ce91de52e76309d0fd1d4296f34039856aa/yarl-1.20.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:41ebd28167bc6af8abb97fec1a399f412eec5fd61a3ccbe2305a18b84fb4ca73", size = 319627, upload-time = "2025-06-10T00:42:39.937Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/76/8fcfbf5fa2369157b9898962a4a7d96764b287b085b5b3d9ffae69cdefd1/yarl-1.20.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:21242b4288a6d56f04ea193adde174b7e347ac46ce6bc84989ff7c1b1ecea84e", size = 339149, upload-time = "2025-06-10T00:42:42.627Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/95/d7fc301cc4661785967acc04f54a4a42d5124905e27db27bb578aac49b5c/yarl-1.20.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bea21cdae6c7eb02ba02a475f37463abfe0a01f5d7200121b03e605d6a0439f8", size = 333327, upload-time = "2025-06-10T00:42:44.842Z" },
-    { url = "https://files.pythonhosted.org/packages/65/94/e21269718349582eee81efc5c1c08ee71c816bfc1585b77d0ec3f58089eb/yarl-1.20.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f8a891e4a22a89f5dde7862994485e19db246b70bb288d3ce73a34422e55b23", size = 326054, upload-time = "2025-06-10T00:42:47.149Z" },
-    { url = "https://files.pythonhosted.org/packages/32/ae/8616d1f07853704523519f6131d21f092e567c5af93de7e3e94b38d7f065/yarl-1.20.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dd803820d44c8853a109a34e3660e5a61beae12970da479cf44aa2954019bf70", size = 315035, upload-time = "2025-06-10T00:42:48.852Z" },
-    { url = "https://files.pythonhosted.org/packages/48/aa/0ace06280861ef055855333707db5e49c6e3a08840a7ce62682259d0a6c0/yarl-1.20.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b982fa7f74c80d5c0c7b5b38f908971e513380a10fecea528091405f519b9ebb", size = 338962, upload-time = "2025-06-10T00:42:51.024Z" },
-    { url = "https://files.pythonhosted.org/packages/20/52/1e9d0e6916f45a8fb50e6844f01cb34692455f1acd548606cbda8134cd1e/yarl-1.20.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:33f29ecfe0330c570d997bcf1afd304377f2e48f61447f37e846a6058a4d33b2", size = 335399, upload-time = "2025-06-10T00:42:53.007Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/65/60452df742952c630e82f394cd409de10610481d9043aa14c61bf846b7b1/yarl-1.20.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:835ab2cfc74d5eb4a6a528c57f05688099da41cf4957cf08cad38647e4a83b30", size = 338649, upload-time = "2025-06-10T00:42:54.964Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/f5/6cd4ff38dcde57a70f23719a838665ee17079640c77087404c3d34da6727/yarl-1.20.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:46b5e0ccf1943a9a6e766b2c2b8c732c55b34e28be57d8daa2b3c1d1d4009309", size = 358563, upload-time = "2025-06-10T00:42:57.28Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/90/c42eefd79d0d8222cb3227bdd51b640c0c1d0aa33fe4cc86c36eccba77d3/yarl-1.20.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:df47c55f7d74127d1b11251fe6397d84afdde0d53b90bedb46a23c0e534f9d24", size = 357609, upload-time = "2025-06-10T00:42:59.055Z" },
-    { url = "https://files.pythonhosted.org/packages/03/c8/cea6b232cb4617514232e0f8a718153a95b5d82b5290711b201545825532/yarl-1.20.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:76d12524d05841276b0e22573f28d5fbcb67589836772ae9244d90dd7d66aa13", size = 350224, upload-time = "2025-06-10T00:43:01.248Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/a3/eaa0ab9712f1f3d01faf43cf6f1f7210ce4ea4a7e9b28b489a2261ca8db9/yarl-1.20.1-cp310-cp310-win32.whl", hash = "sha256:6c4fbf6b02d70e512d7ade4b1f998f237137f1417ab07ec06358ea04f69134f8", size = 81753, upload-time = "2025-06-10T00:43:03.486Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/34/e4abde70a9256465fe31c88ed02c3f8502b7b5dead693a4f350a06413f28/yarl-1.20.1-cp310-cp310-win_amd64.whl", hash = "sha256:aef6c4d69554d44b7f9d923245f8ad9a707d971e6209d51279196d8e8fe1ae16", size = 86817, upload-time = "2025-06-10T00:43:05.231Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/18/893b50efc2350e47a874c5c2d67e55a0ea5df91186b2a6f5ac52eff887cd/yarl-1.20.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:47ee6188fea634bdfaeb2cc420f5b3b17332e6225ce88149a17c413c77ff269e", size = 133833, upload-time = "2025-06-10T00:43:07.393Z" },
-    { url = "https://files.pythonhosted.org/packages/89/ed/b8773448030e6fc47fa797f099ab9eab151a43a25717f9ac043844ad5ea3/yarl-1.20.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d0f6500f69e8402d513e5eedb77a4e1818691e8f45e6b687147963514d84b44b", size = 91070, upload-time = "2025-06-10T00:43:09.538Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/e3/409bd17b1e42619bf69f60e4f031ce1ccb29bd7380117a55529e76933464/yarl-1.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7a8900a42fcdaad568de58887c7b2f602962356908eedb7628eaf6021a6e435b", size = 89818, upload-time = "2025-06-10T00:43:11.575Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/77/64d8431a4d77c856eb2d82aa3de2ad6741365245a29b3a9543cd598ed8c5/yarl-1.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bad6d131fda8ef508b36be3ece16d0902e80b88ea7200f030a0f6c11d9e508d4", size = 347003, upload-time = "2025-06-10T00:43:14.088Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/d2/0c7e4def093dcef0bd9fa22d4d24b023788b0a33b8d0088b51aa51e21e99/yarl-1.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:df018d92fe22aaebb679a7f89fe0c0f368ec497e3dda6cb81a567610f04501f1", size = 336537, upload-time = "2025-06-10T00:43:16.431Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/f3/fc514f4b2cf02cb59d10cbfe228691d25929ce8f72a38db07d3febc3f706/yarl-1.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f969afbb0a9b63c18d0feecf0db09d164b7a44a053e78a7d05f5df163e43833", size = 362358, upload-time = "2025-06-10T00:43:18.704Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/6d/a313ac8d8391381ff9006ac05f1d4331cee3b1efaa833a53d12253733255/yarl-1.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:812303eb4aa98e302886ccda58d6b099e3576b1b9276161469c25803a8db277d", size = 357362, upload-time = "2025-06-10T00:43:20.888Z" },
-    { url = "https://files.pythonhosted.org/packages/00/70/8f78a95d6935a70263d46caa3dd18e1f223cf2f2ff2037baa01a22bc5b22/yarl-1.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98c4a7d166635147924aa0bf9bfe8d8abad6fffa6102de9c99ea04a1376f91e8", size = 348979, upload-time = "2025-06-10T00:43:23.169Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/05/42773027968968f4f15143553970ee36ead27038d627f457cc44bbbeecf3/yarl-1.20.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12e768f966538e81e6e7550f9086a6236b16e26cd964cf4df35349970f3551cf", size = 337274, upload-time = "2025-06-10T00:43:27.111Z" },
-    { url = "https://files.pythonhosted.org/packages/05/be/665634aa196954156741ea591d2f946f1b78ceee8bb8f28488bf28c0dd62/yarl-1.20.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fe41919b9d899661c5c28a8b4b0acf704510b88f27f0934ac7a7bebdd8938d5e", size = 363294, upload-time = "2025-06-10T00:43:28.96Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/90/73448401d36fa4e210ece5579895731f190d5119c4b66b43b52182e88cd5/yarl-1.20.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:8601bc010d1d7780592f3fc1bdc6c72e2b6466ea34569778422943e1a1f3c389", size = 358169, upload-time = "2025-06-10T00:43:30.701Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/b0/fce922d46dc1eb43c811f1889f7daa6001b27a4005587e94878570300881/yarl-1.20.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:daadbdc1f2a9033a2399c42646fbd46da7992e868a5fe9513860122d7fe7a73f", size = 362776, upload-time = "2025-06-10T00:43:32.51Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/0d/b172628fce039dae8977fd22caeff3eeebffd52e86060413f5673767c427/yarl-1.20.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:03aa1e041727cb438ca762628109ef1333498b122e4c76dd858d186a37cec845", size = 381341, upload-time = "2025-06-10T00:43:34.543Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/9b/5b886d7671f4580209e855974fe1cecec409aa4a89ea58b8f0560dc529b1/yarl-1.20.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:642980ef5e0fa1de5fa96d905c7e00cb2c47cb468bfcac5a18c58e27dbf8d8d1", size = 379988, upload-time = "2025-06-10T00:43:36.489Z" },
-    { url = "https://files.pythonhosted.org/packages/73/be/75ef5fd0fcd8f083a5d13f78fd3f009528132a1f2a1d7c925c39fa20aa79/yarl-1.20.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:86971e2795584fe8c002356d3b97ef6c61862720eeff03db2a7c86b678d85b3e", size = 371113, upload-time = "2025-06-10T00:43:38.592Z" },
-    { url = "https://files.pythonhosted.org/packages/50/4f/62faab3b479dfdcb741fe9e3f0323e2a7d5cd1ab2edc73221d57ad4834b2/yarl-1.20.1-cp311-cp311-win32.whl", hash = "sha256:597f40615b8d25812f14562699e287f0dcc035d25eb74da72cae043bb884d773", size = 81485, upload-time = "2025-06-10T00:43:41.038Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/09/d9c7942f8f05c32ec72cd5c8e041c8b29b5807328b68b4801ff2511d4d5e/yarl-1.20.1-cp311-cp311-win_amd64.whl", hash = "sha256:26ef53a9e726e61e9cd1cda6b478f17e350fb5800b4bd1cd9fe81c4d91cfeb2e", size = 86686, upload-time = "2025-06-10T00:43:42.692Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/9a/cb7fad7d73c69f296eda6815e4a2c7ed53fc70c2f136479a91c8e5fbdb6d/yarl-1.20.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdcc4cd244e58593a4379fe60fdee5ac0331f8eb70320a24d591a3be197b94a9", size = 133667, upload-time = "2025-06-10T00:43:44.369Z" },
-    { url = "https://files.pythonhosted.org/packages/67/38/688577a1cb1e656e3971fb66a3492501c5a5df56d99722e57c98249e5b8a/yarl-1.20.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b29a2c385a5f5b9c7d9347e5812b6f7ab267193c62d282a540b4fc528c8a9d2a", size = 91025, upload-time = "2025-06-10T00:43:46.295Z" },
-    { url = "https://files.pythonhosted.org/packages/50/ec/72991ae51febeb11a42813fc259f0d4c8e0507f2b74b5514618d8b640365/yarl-1.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1112ae8154186dfe2de4732197f59c05a83dc814849a5ced892b708033f40dc2", size = 89709, upload-time = "2025-06-10T00:43:48.22Z" },
-    { url = "https://files.pythonhosted.org/packages/99/da/4d798025490e89426e9f976702e5f9482005c548c579bdae792a4c37769e/yarl-1.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90bbd29c4fe234233f7fa2b9b121fb63c321830e5d05b45153a2ca68f7d310ee", size = 352287, upload-time = "2025-06-10T00:43:49.924Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/26/54a15c6a567aac1c61b18aa0f4b8aa2e285a52d547d1be8bf48abe2b3991/yarl-1.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:680e19c7ce3710ac4cd964e90dad99bf9b5029372ba0c7cbfcd55e54d90ea819", size = 345429, upload-time = "2025-06-10T00:43:51.7Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/95/9dcf2386cb875b234353b93ec43e40219e14900e046bf6ac118f94b1e353/yarl-1.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a979218c1fdb4246a05efc2cc23859d47c89af463a90b99b7c56094daf25a16", size = 365429, upload-time = "2025-06-10T00:43:53.494Z" },
-    { url = "https://files.pythonhosted.org/packages/91/b2/33a8750f6a4bc224242a635f5f2cff6d6ad5ba651f6edcccf721992c21a0/yarl-1.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255b468adf57b4a7b65d8aad5b5138dce6a0752c139965711bdcb81bc370e1b6", size = 363862, upload-time = "2025-06-10T00:43:55.766Z" },
-    { url = "https://files.pythonhosted.org/packages/98/28/3ab7acc5b51f4434b181b0cee8f1f4b77a65919700a355fb3617f9488874/yarl-1.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a97d67108e79cfe22e2b430d80d7571ae57d19f17cda8bb967057ca8a7bf5bfd", size = 355616, upload-time = "2025-06-10T00:43:58.056Z" },
-    { url = "https://files.pythonhosted.org/packages/36/a3/f666894aa947a371724ec7cd2e5daa78ee8a777b21509b4252dd7bd15e29/yarl-1.20.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8570d998db4ddbfb9a590b185a0a33dbf8aafb831d07a5257b4ec9948df9cb0a", size = 339954, upload-time = "2025-06-10T00:43:59.773Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/81/5f466427e09773c04219d3450d7a1256138a010b6c9f0af2d48565e9ad13/yarl-1.20.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:97c75596019baae7c71ccf1d8cc4738bc08134060d0adfcbe5642f778d1dca38", size = 365575, upload-time = "2025-06-10T00:44:02.051Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/e3/e4b0ad8403e97e6c9972dd587388940a032f030ebec196ab81a3b8e94d31/yarl-1.20.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1c48912653e63aef91ff988c5432832692ac5a1d8f0fb8a33091520b5bbe19ef", size = 365061, upload-time = "2025-06-10T00:44:04.196Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/99/b8a142e79eb86c926f9f06452eb13ecb1bb5713bd01dc0038faf5452e544/yarl-1.20.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4c3ae28f3ae1563c50f3d37f064ddb1511ecc1d5584e88c6b7c63cf7702a6d5f", size = 364142, upload-time = "2025-06-10T00:44:06.527Z" },
-    { url = "https://files.pythonhosted.org/packages/34/f2/08ed34a4a506d82a1a3e5bab99ccd930a040f9b6449e9fd050320e45845c/yarl-1.20.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c5e9642f27036283550f5f57dc6156c51084b458570b9d0d96100c8bebb186a8", size = 381894, upload-time = "2025-06-10T00:44:08.379Z" },
-    { url = "https://files.pythonhosted.org/packages/92/f8/9a3fbf0968eac704f681726eff595dce9b49c8a25cd92bf83df209668285/yarl-1.20.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:2c26b0c49220d5799f7b22c6838409ee9bc58ee5c95361a4d7831f03cc225b5a", size = 383378, upload-time = "2025-06-10T00:44:10.51Z" },
-    { url = "https://files.pythonhosted.org/packages/af/85/9363f77bdfa1e4d690957cd39d192c4cacd1c58965df0470a4905253b54f/yarl-1.20.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:564ab3d517e3d01c408c67f2e5247aad4019dcf1969982aba3974b4093279004", size = 374069, upload-time = "2025-06-10T00:44:12.834Z" },
-    { url = "https://files.pythonhosted.org/packages/35/99/9918c8739ba271dcd935400cff8b32e3cd319eaf02fcd023d5dcd487a7c8/yarl-1.20.1-cp312-cp312-win32.whl", hash = "sha256:daea0d313868da1cf2fac6b2d3a25c6e3a9e879483244be38c8e6a41f1d876a5", size = 81249, upload-time = "2025-06-10T00:44:14.731Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/83/5d9092950565481b413b31a23e75dd3418ff0a277d6e0abf3729d4d1ce25/yarl-1.20.1-cp312-cp312-win_amd64.whl", hash = "sha256:48ea7d7f9be0487339828a4de0360d7ce0efc06524a48e1810f945c45b813698", size = 86710, upload-time = "2025-06-10T00:44:16.716Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/2d/2345fce04cfd4bee161bf1e7d9cdc702e3e16109021035dbb24db654a622/yarl-1.20.1-py3-none-any.whl", hash = "sha256:83b8eb083fe4683c6115795d9fc1cfaf2cbbefb19b3a1cb68f6527460f483a77", size = 46542, upload-time = "2025-06-10T00:46:07.521Z" },
-]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
-
-[[package]]
-name = "zstandard"
-version = "0.24.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/09/1b/c20b2ef1d987627765dcd5bf1dadb8ef6564f00a87972635099bb76b7a05/zstandard-0.24.0.tar.gz", hash = "sha256:fe3198b81c00032326342d973e526803f183f97aa9e9a98e3f897ebafe21178f", size = 905681, upload-time = "2025-08-17T18:36:36.352Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/63/9d/d1ca1e7bff6a7938e81180322c053c080ae9e31b0e3b393434deae7a1ae5/zstandard-0.24.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:af1394c2c5febc44e0bbf0fc6428263fa928b50d1b1982ce1d870dc793a8e5f4", size = 795228, upload-time = "2025-08-17T18:21:12.444Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/ba/a40ddfbbb9f0773127701a802338f215211b018f9222b9fab1e2d498f9cd/zstandard-0.24.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5e941654cef13a1d53634ec30933722eda11f44f99e1d0bc62bbce3387580d50", size = 640522, upload-time = "2025-08-17T18:21:14.133Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/7c/edeee3ef8d469a1345edd86f8d123a3825d60df033bcbbd16df417bdb9e7/zstandard-0.24.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:561123d05681197c0e24eb8ab3cfdaf299e2b59c293d19dad96e1610ccd8fbc6", size = 5344625, upload-time = "2025-08-17T18:21:16.067Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/2c/2f76e5058435d96ab0187303d4e9663372893cdcc95d64fdb60824951162/zstandard-0.24.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0f6d9a146e07458cb41423ca2d783aefe3a3a97fe72838973c13b8f1ecc7343a", size = 5055074, upload-time = "2025-08-17T18:21:18.483Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/87/3962530a568d38e64f287e11b9a38936d873617120589611c49c29af94a8/zstandard-0.24.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:bf02f915fa7934ea5dfc8d96757729c99a8868b7c340b97704795d6413cf5fe6", size = 5401308, upload-time = "2025-08-17T18:21:20.859Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/69/85e65f0fb05b4475130888cf7934ff30ac14b5979527e8f1ccb6f56e21ec/zstandard-0.24.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:35f13501a8accf834457d8e40e744568287a215818778bc4d79337af2f3f0d97", size = 5448948, upload-time = "2025-08-17T18:21:23.015Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/2f/1b607274bf20ea8bcd13bea3edc0a48f984c438c09d0a050b9667dadcaed/zstandard-0.24.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:92be52ca4e6e604f03d5daa079caec9e04ab4cbf6972b995aaebb877d3d24e13", size = 5555870, upload-time = "2025-08-17T18:21:24.985Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/9a/fadd5ffded6ab113b26704658a40444865b914de072fb460b6b51aa5fa2f/zstandard-0.24.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0c9c3cba57f5792532a3df3f895980d47d78eda94b0e5b800651b53e96e0b604", size = 5044917, upload-time = "2025-08-17T18:21:27.082Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/0d/c5edc3b00e070d0b4156993bd7bef9cba58c5f2571bd0003054cbe90005c/zstandard-0.24.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:dd91b0134a32dfcd8be504e8e46de44ad0045a569efc25101f2a12ccd41b5759", size = 5571834, upload-time = "2025-08-17T18:21:29.239Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/7e/9e353ed08c3d7a93050bbadbebe2f5f783b13393e0e8e08e970ef3396390/zstandard-0.24.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d6975f2d903bc354916a17b91a7aaac7299603f9ecdb788145060dde6e573a16", size = 4959108, upload-time = "2025-08-17T18:21:31.228Z" },
-    { url = "https://files.pythonhosted.org/packages/af/28/135dffba375ab1f4d2c569de804647eba8bd682f36d3c01b5a012c560ff2/zstandard-0.24.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:7ac6e4d727521d86d20ec291a3f4e64a478e8a73eaee80af8f38ec403e77a409", size = 5265997, upload-time = "2025-08-17T18:21:33.369Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/7a/702e7cbc51c39ce104c198ea6d069fb6a918eb24c5709ac79fe9371f7a55/zstandard-0.24.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:87ae1684bc3c02d5c35884b3726525eda85307073dbefe68c3c779e104a59036", size = 5440015, upload-time = "2025-08-17T18:21:35.023Z" },
-    { url = "https://files.pythonhosted.org/packages/77/40/4a2d0faa2ae6f4c847c7f77ec626abed80873035891c4a4349b735a36fb4/zstandard-0.24.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:7de5869e616d426b56809be7dc6dba4d37b95b90411ccd3de47f421a42d4d42c", size = 5819056, upload-time = "2025-08-17T18:21:39.661Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/fc/580504a2d7c71411a8e403b83f2388ee083819a68e0e740bf974e78839f8/zstandard-0.24.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:388aad2d693707f4a0f6cc687eb457b33303d6b57ecf212c8ff4468c34426892", size = 5362621, upload-time = "2025-08-17T18:21:42.605Z" },
-    { url = "https://files.pythonhosted.org/packages/70/66/97f6b38eeda955eaa6b5e7cfc0528039bfcb9eb8338016aacf6d83d8a75e/zstandard-0.24.0-cp310-cp310-win32.whl", hash = "sha256:962ea3aecedcc944f8034812e23d7200d52c6e32765b8da396eeb8b8ffca71ce", size = 435575, upload-time = "2025-08-17T18:21:45.477Z" },
-    { url = "https://files.pythonhosted.org/packages/68/a2/5814bdd22d879b10fcc5dc37366e39603767063f06ae970f2a657f76ddac/zstandard-0.24.0-cp310-cp310-win_amd64.whl", hash = "sha256:869bf13f66b124b13be37dd6e08e4b728948ff9735308694e0b0479119e08ea7", size = 505115, upload-time = "2025-08-17T18:21:44.011Z" },
-    { url = "https://files.pythonhosted.org/packages/01/1f/5c72806f76043c0ef9191a2b65281dacdf3b65b0828eb13bb2c987c4fb90/zstandard-0.24.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:addfc23e3bd5f4b6787b9ca95b2d09a1a67ad5a3c318daaa783ff90b2d3a366e", size = 795228, upload-time = "2025-08-17T18:21:46.978Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/ba/3059bd5cd834666a789251d14417621b5c61233bd46e7d9023ea8bc1043a/zstandard-0.24.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6b005bcee4be9c3984b355336283afe77b2defa76ed6b89332eced7b6fa68b68", size = 640520, upload-time = "2025-08-17T18:21:48.162Z" },
-    { url = "https://files.pythonhosted.org/packages/57/07/f0e632bf783f915c1fdd0bf68614c4764cae9dd46ba32cbae4dd659592c3/zstandard-0.24.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:3f96a9130171e01dbb6c3d4d9925d604e2131a97f540e223b88ba45daf56d6fb", size = 5347682, upload-time = "2025-08-17T18:21:50.266Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/4c/63523169fe84773a7462cd090b0989cb7c7a7f2a8b0a5fbf00009ba7d74d/zstandard-0.24.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd0d3d16e63873253bad22b413ec679cf6586e51b5772eb10733899832efec42", size = 5057650, upload-time = "2025-08-17T18:21:52.634Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/16/49013f7ef80293f5cebf4c4229535a9f4c9416bbfd238560edc579815dbe/zstandard-0.24.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:b7a8c30d9bf4bd5e4dcfe26900bef0fcd9749acde45cdf0b3c89e2052fda9a13", size = 5404893, upload-time = "2025-08-17T18:21:54.54Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/38/78e8bcb5fc32a63b055f2b99e0be49b506f2351d0180173674f516cf8a7a/zstandard-0.24.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:52cd7d9fa0a115c9446abb79b06a47171b7d916c35c10e0c3aa6f01d57561382", size = 5452389, upload-time = "2025-08-17T18:21:56.822Z" },
-    { url = "https://files.pythonhosted.org/packages/55/8a/81671f05619edbacd49bd84ce6899a09fc8299be20c09ae92f6618ccb92d/zstandard-0.24.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a0f6fc2ea6e07e20df48752e7700e02e1892c61f9a6bfbacaf2c5b24d5ad504b", size = 5558888, upload-time = "2025-08-17T18:21:58.68Z" },
-    { url = "https://files.pythonhosted.org/packages/49/cc/e83feb2d7d22d1f88434defbaeb6e5e91f42a4f607b5d4d2d58912b69d67/zstandard-0.24.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e46eb6702691b24ddb3e31e88b4a499e31506991db3d3724a85bd1c5fc3cfe4e", size = 5048038, upload-time = "2025-08-17T18:22:00.642Z" },
-    { url = "https://files.pythonhosted.org/packages/08/c3/7a5c57ff49ef8943877f85c23368c104c2aea510abb339a2dc31ad0a27c3/zstandard-0.24.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d5e3b9310fd7f0d12edc75532cd9a56da6293840c84da90070d692e0bb15f186", size = 5573833, upload-time = "2025-08-17T18:22:02.402Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/00/64519983cd92535ba4bdd4ac26ac52db00040a52d6c4efb8d1764abcc343/zstandard-0.24.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:76cdfe7f920738ea871f035568f82bad3328cbc8d98f1f6988264096b5264efd", size = 4961072, upload-time = "2025-08-17T18:22:04.384Z" },
-    { url = "https://files.pythonhosted.org/packages/72/ab/3a08a43067387d22994fc87c3113636aa34ccd2914a4d2d188ce365c5d85/zstandard-0.24.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3f2fe35ec84908dddf0fbf66b35d7c2878dbe349552dd52e005c755d3493d61c", size = 5268462, upload-time = "2025-08-17T18:22:06.095Z" },
-    { url = "https://files.pythonhosted.org/packages/49/cf/2abb3a1ad85aebe18c53e7eca73223f1546ddfa3bf4d2fb83fc5a064c5ca/zstandard-0.24.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:aa705beb74ab116563f4ce784fa94771f230c05d09ab5de9c397793e725bb1db", size = 5443319, upload-time = "2025-08-17T18:22:08.572Z" },
-    { url = "https://files.pythonhosted.org/packages/40/42/0dd59fc2f68f1664cda11c3b26abdf987f4e57cb6b6b0f329520cd074552/zstandard-0.24.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:aadf32c389bb7f02b8ec5c243c38302b92c006da565e120dfcb7bf0378f4f848", size = 5822355, upload-time = "2025-08-17T18:22:10.537Z" },
-    { url = "https://files.pythonhosted.org/packages/99/c0/ea4e640fd4f7d58d6f87a1e7aca11fb886ac24db277fbbb879336c912f63/zstandard-0.24.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e40cd0fc734aa1d4bd0e7ad102fd2a1aefa50ce9ef570005ffc2273c5442ddc3", size = 5365257, upload-time = "2025-08-17T18:22:13.159Z" },
-    { url = "https://files.pythonhosted.org/packages/27/a9/92da42a5c4e7e4003271f2e1f0efd1f37cfd565d763ad3604e9597980a1c/zstandard-0.24.0-cp311-cp311-win32.whl", hash = "sha256:cda61c46343809ecda43dc620d1333dd7433a25d0a252f2dcc7667f6331c7b61", size = 435559, upload-time = "2025-08-17T18:22:17.29Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/8e/2c8e5c681ae4937c007938f954a060fa7c74f36273b289cabdb5ef0e9a7e/zstandard-0.24.0-cp311-cp311-win_amd64.whl", hash = "sha256:3b95fc06489aa9388400d1aab01a83652bc040c9c087bd732eb214909d7fb0dd", size = 505070, upload-time = "2025-08-17T18:22:14.808Z" },
-    { url = "https://files.pythonhosted.org/packages/52/10/a2f27a66bec75e236b575c9f7b0d7d37004a03aa2dcde8e2decbe9ed7b4d/zstandard-0.24.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad9fd176ff6800a0cf52bcf59c71e5de4fa25bf3ba62b58800e0f84885344d34", size = 461507, upload-time = "2025-08-17T18:22:15.964Z" },
-    { url = "https://files.pythonhosted.org/packages/26/e9/0bd281d9154bba7fc421a291e263911e1d69d6951aa80955b992a48289f6/zstandard-0.24.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a2bda8f2790add22773ee7a4e43c90ea05598bffc94c21c40ae0a9000b0133c3", size = 795710, upload-time = "2025-08-17T18:22:19.189Z" },
-    { url = "https://files.pythonhosted.org/packages/36/26/b250a2eef515caf492e2d86732e75240cdac9d92b04383722b9753590c36/zstandard-0.24.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cc76de75300f65b8eb574d855c12518dc25a075dadb41dd18f6322bda3fe15d5", size = 640336, upload-time = "2025-08-17T18:22:20.466Z" },
-    { url = "https://files.pythonhosted.org/packages/79/bf/3ba6b522306d9bf097aac8547556b98a4f753dc807a170becaf30dcd6f01/zstandard-0.24.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:d2b3b4bda1a025b10fe0269369475f420177f2cb06e0f9d32c95b4873c9f80b8", size = 5342533, upload-time = "2025-08-17T18:22:22.326Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/ec/22bc75bf054e25accdf8e928bc68ab36b4466809729c554ff3a1c1c8bce6/zstandard-0.24.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b84c6c210684286e504022d11ec294d2b7922d66c823e87575d8b23eba7c81f", size = 5062837, upload-time = "2025-08-17T18:22:24.416Z" },
-    { url = "https://files.pythonhosted.org/packages/48/cc/33edfc9d286e517fb5b51d9c3210e5bcfce578d02a675f994308ca587ae1/zstandard-0.24.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:c59740682a686bf835a1a4d8d0ed1eefe31ac07f1c5a7ed5f2e72cf577692b00", size = 5393855, upload-time = "2025-08-17T18:22:26.786Z" },
-    { url = "https://files.pythonhosted.org/packages/73/36/59254e9b29da6215fb3a717812bf87192d89f190f23817d88cb8868c47ac/zstandard-0.24.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6324fde5cf5120fbf6541d5ff3c86011ec056e8d0f915d8e7822926a5377193a", size = 5451058, upload-time = "2025-08-17T18:22:28.885Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/c7/31674cb2168b741bbbe71ce37dd397c9c671e73349d88ad3bca9e9fae25b/zstandard-0.24.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51a86bd963de3f36688553926a84e550d45d7f9745bd1947d79472eca27fcc75", size = 5546619, upload-time = "2025-08-17T18:22:31.115Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/01/1a9f22239f08c00c156f2266db857545ece66a6fc0303d45c298564bc20b/zstandard-0.24.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d82ac87017b734f2fb70ff93818c66f0ad2c3810f61040f077ed38d924e19980", size = 5046676, upload-time = "2025-08-17T18:22:33.077Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/91/6c0cf8fa143a4988a0361380ac2ef0d7cb98a374704b389fbc38b5891712/zstandard-0.24.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:92ea7855d5bcfb386c34557516c73753435fb2d4a014e2c9343b5f5ba148b5d8", size = 5576381, upload-time = "2025-08-17T18:22:35.391Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/77/1526080e22e78871e786ccf3c84bf5cec9ed25110a9585507d3c551da3d6/zstandard-0.24.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3adb4b5414febf074800d264ddf69ecade8c658837a83a19e8ab820e924c9933", size = 4953403, upload-time = "2025-08-17T18:22:37.266Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/d0/a3a833930bff01eab697eb8abeafb0ab068438771fa066558d96d7dafbf9/zstandard-0.24.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6374feaf347e6b83ec13cc5dcfa70076f06d8f7ecd46cc71d58fac798ff08b76", size = 5267396, upload-time = "2025-08-17T18:22:39.757Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/5e/90a0db9a61cd4769c06374297ecfcbbf66654f74cec89392519deba64d76/zstandard-0.24.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:13fc548e214df08d896ee5f29e1f91ee35db14f733fef8eabea8dca6e451d1e2", size = 5433269, upload-time = "2025-08-17T18:22:42.131Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/58/fc6a71060dd67c26a9c5566e0d7c99248cbe5abfda6b3b65b8f1a28d59f7/zstandard-0.24.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0a416814608610abf5488889c74e43ffa0343ca6cf43957c6b6ec526212422da", size = 5814203, upload-time = "2025-08-17T18:22:44.017Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/6a/89573d4393e3ecbfa425d9a4e391027f58d7810dec5cdb13a26e4cdeef5c/zstandard-0.24.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0d66da2649bb0af4471699aeb7a83d6f59ae30236fb9f6b5d20fb618ef6c6777", size = 5359622, upload-time = "2025-08-17T18:22:45.802Z" },
-    { url = "https://files.pythonhosted.org/packages/60/ff/2cbab815d6f02a53a9d8d8703bc727d8408a2e508143ca9af6c3cca2054b/zstandard-0.24.0-cp312-cp312-win32.whl", hash = "sha256:ff19efaa33e7f136fe95f9bbcc90ab7fb60648453b03f95d1de3ab6997de0f32", size = 435968, upload-time = "2025-08-17T18:22:49.493Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/a3/8f96b8ddb7ad12344218fbd0fd2805702dafd126ae9f8a1fb91eef7b33da/zstandard-0.24.0-cp312-cp312-win_amd64.whl", hash = "sha256:bc05f8a875eb651d1cc62e12a4a0e6afa5cd0cc231381adb830d2e9c196ea895", size = 505195, upload-time = "2025-08-17T18:22:47.193Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/4a/bfca20679da63bfc236634ef2e4b1b4254203098b0170e3511fee781351f/zstandard-0.24.0-cp312-cp312-win_arm64.whl", hash = "sha256:b04c94718f7a8ed7cdd01b162b6caa1954b3c9d486f00ecbbd300f149d2b2606", size = 461605, upload-time = "2025-08-17T18:22:48.317Z" },
-]