diff --git a/README.md b/README.md
index c9ae632..113d5bc 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-# Pocket Option API
+# PocketOption Async API (V2) - By ChipaDevTeam
+
Check BinaryOptionToolsv2: [https://github.com/ChipaDevTeam/BinaryOptionsTools-v2](https://github.com/ChipaDevTeam/BinaryOptionsTools-v2)
-for the latest api, check here: [https://github.com/ChipaDevTeam/BinaryOptionsToolsV1](https://github.com/ChipaDevTeam/BinaryOptionsToolsV1)
## Support us
join PocketOption with our affiliate link: [PocketOption Affiliate link](https://u3.shortink.io/smart/SDIaxbeamcYYqB)
@@ -10,8 +10,512 @@ help us in patreon: [Patreon](https://patreon.com/VigoDEV?utm_medium=unknown&utm
## check our bots and talk to us!
Join our comunity --> [discord](https://discord.com/invite/kaZ8uV9b6k)
-## About
-This repo is outdated, Please check [BinaryOptionToolsV2](https://github.com/ChipaDevTeam/BinaryOptionsTools-v2) for the latest working api, or [BinaryOptionsToolsv1](https://github.com/ChipaDevTeam/BinaryOptionsToolsV1) for a more simple version
+A comprehensive, modern async Python API for PocketOption trading platform with advanced features including persistent connections, monitoring, and extensive testing frameworks.
+
+## ๐ Key Features
+
+### โจ Enhanced Connection Management
+- **Complete SSID Format Support**: Works with full authentication strings from browser (format: `42["auth",{"session":"...","isDemo":1,"uid":...,"platform":1}]`)
+- **Persistent Connections**: Automatic keep-alive with 20-second ping intervals (like the original API)
+- **Auto-Reconnection**: Intelligent reconnection with multiple region fallback
+- **Connection Pooling**: Optimized connection management for better performance
+
+### ๐ Advanced Monitoring & Diagnostics
+- **Real-time Monitoring**: Connection health, performance metrics, and error tracking
+- **Diagnostics Reports**: Comprehensive health assessments with recommendations
+- **Performance Analytics**: Response times, throughput analysis, and bottleneck detection
+- **Alert System**: Automatic alerts for connection issues and performance problems
+
+### ๐งช Comprehensive Testing Framework
+- **Load Testing**: Concurrent client simulation and stress testing
+- **Integration Testing**: End-to-end validation of all components
+- **Performance Benchmarks**: Automated performance analysis and optimization
+- **Advanced Test Suites**: Edge cases, error scenarios, and long-running stability tests
+
+### โก Performance Optimizations
+- **Message Batching**: Efficient message queuing and processing
+- **Concurrent Operations**: Parallel API calls for better throughput
+- **Caching System**: Intelligent caching with TTL for frequently accessed data
+- **Rate Limiting**: Built-in protection against API rate limits
+
+### ๐ก๏ธ Robust Error Handling
+- **Graceful Degradation**: Continues operation despite individual failures
+- **Automatic Recovery**: Self-healing connections and operations
+- **Comprehensive Logging**: Detailed error tracking and debugging information
+- **Exception Management**: Type-specific error handling and recovery strategies
+
+## ๐ฆ Installation
+
+```bash
+# Clone the repository
+git clone
+cd PocketOptionAPI-3
+
+# Install dependencies
+pip install -r requirements.txt
+
+# For development
+pip install -r requirements-dev.txt
+```
+
+## ๐ง Quick Start
+
+### Basic Usage
+
+```python
+import asyncio
+from pocketoptionapi_async.client import AsyncPocketOptionClient
+from pocketoptionapi_async.models import OrderDirection, TimeFrame
+
+async def main():
+ # Complete SSID format (get from browser dev tools)
+ ssid = r'42["auth",{"session":"your_session_here","isDemo":1,"uid":12345,"platform":1}]'
+
+ # Create client with persistent connection
+ client = AsyncPocketOptionClient(
+ ssid,
+ is_demo=True,
+ persistent_connection=True, # Enable keep-alive
+ auto_reconnect=True # Enable auto-reconnection
+ )
+
+ try:
+ # Connect
+ await client.connect()
+
+ # Get balance
+ balance = await client.get_balance()
+ print(f"Balance: ${balance.balance}")
+
+ # Get candles
+ candles = await client.get_candles("EURUSD", TimeFrame.M1, 100)
+ print(f"Retrieved {len(candles)} candles")
+
+ # Place order (demo)
+ order = await client.place_order("EURUSD", 10, OrderDirection.CALL, 60)
+ print(f"Order placed: {order.order_id}")
+
+ finally:
+ await client.disconnect()
+
+asyncio.run(main())
+```
+
+### Persistent Connection with Keep-Alive
+
+```python
+from connection_keep_alive import ConnectionKeepAlive
+
+async def persistent_connection_demo():
+ ssid = r'42["auth",{"session":"your_session","isDemo":1,"uid":12345,"platform":1}]'
+
+ # Create keep-alive manager
+ keep_alive = ConnectionKeepAlive(ssid, is_demo=True)
+
+ # Add event handlers
+ async def on_connected(data):
+ print(f"Connected to: {data['region']}")
+
+ async def on_message(data):
+ print(f"Message: {data['message'][:50]}...")
+
+ keep_alive.add_event_handler('connected', on_connected)
+ keep_alive.add_event_handler('message_received', on_message)
+
+ try:
+ # Start persistent connection (runs indefinitely with auto-reconnect)
+ await keep_alive.start_persistent_connection()
+
+ # Send messages
+ await keep_alive.send_message('42["ps"]')
+
+ # Keep running...
+ await asyncio.sleep(60)
+
+ finally:
+ await keep_alive.stop_persistent_connection()
+
+asyncio.run(persistent_connection_demo())
+```
+
+## ๐ Advanced Features
+
+### Connection Monitoring
+
+```python
+from connection_monitor import ConnectionMonitor
+
+async def monitoring_demo():
+ monitor = ConnectionMonitor(ssid, is_demo=True)
+
+ # Add alert handlers
+ async def on_alert(alert):
+ print(f"ALERT: {alert['message']}")
+
+ monitor.add_event_handler('alert', on_alert)
+
+ # Start monitoring
+ await monitor.start_monitoring()
+
+ # Get real-time stats
+ stats = monitor.get_real_time_stats()
+ print(f"Messages: {stats['total_messages']}, Errors: {stats['total_errors']}")
+
+ # Generate diagnostics report
+ report = monitor.generate_diagnostics_report()
+ print(f"Health Score: {report['health_score']}/100")
+
+ await monitor.stop_monitoring()
+```
+
+### Load Testing
+
+```python
+from load_testing_tool import LoadTester, LoadTestConfig
+
+async def load_test_demo():
+ tester = LoadTester(ssid, is_demo=True)
+
+ config = LoadTestConfig(
+ concurrent_clients=5,
+ operations_per_client=20,
+ use_persistent_connection=True,
+ stress_mode=False
+ )
+
+ report = await tester.run_load_test(config)
+
+ print(f"Throughput: {report['test_summary']['avg_operations_per_second']:.1f} ops/sec")
+ print(f"Success Rate: {report['test_summary']['success_rate']:.1%}")
+```
+
+### Integration Testing
+
+```python
+from integration_tests import IntegrationTester
+
+async def integration_test_demo():
+ tester = IntegrationTester(ssid)
+ report = await tester.run_full_integration_tests()
+
+ print(f"Health Score: {report['integration_summary']['health_score']:.1f}/100")
+ print(f"Tests Passed: {report['integration_summary']['passed_tests']}")
+```
+
+## ๐ฏ Getting Your SSID
+
+To use the API with real data, you need to extract your session ID from the browser:
+
+1. **Open PocketOption in your browser**
+2. **Open Developer Tools (F12)**
+3. **Go to Network tab**
+4. **Filter by WebSocket (WS)**
+5. **Look for authentication message starting with `42["auth"`**
+6. **Copy the complete message including the `42["auth",{...}]` format**
+
+Example SSID format:
+```
+42["auth",{"session":"abcd1234efgh5678","isDemo":1,"uid":12345,"platform":1}]
+```
+
+## ๐ Monitoring and Diagnostics
+
+### Real-time Connection Monitor
+
+```bash
+# Start real-time monitoring
+python connection_monitor.py "your_ssid_here"
+```
+
+Features:
+- Real-time connection status
+- Performance metrics
+- Error tracking
+- Health score calculation
+- Automatic alerts
+- CSV export
+
+### Advanced Testing Suite
+
+```bash
+# Run comprehensive tests
+python advanced_testing_suite.py "your_ssid_here"
+```
+
+Includes:
+- Connection stress tests
+- Concurrent operations
+- Data consistency checks
+- Error handling validation
+- Performance benchmarks
+- Memory usage analysis
+
+### Load Testing
+
+```bash
+# Run load tests
+python load_testing_tool.py "your_ssid_here"
+```
+
+Capabilities:
+- Multiple concurrent clients
+- Stress testing modes
+- Performance analysis
+- Bottleneck identification
+- Recommendation generation
+
+## ๐๏ธ Architecture
+
+### Component Overview
+
+```
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ PocketOption Async API โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
+โ AsyncPocketOptionClient (Main API Client) โ
+โ โโโ WebSocket Client (Connection Management) โ
+โ โโโ Keep-Alive Manager (Persistent Connections) โ
+โ โโโ Event System (Callbacks & Handlers) โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
+โ Advanced Features โ
+โ โโโ Connection Monitor (Real-time Monitoring) โ
+โ โโโ Load Tester (Performance Testing) โ
+โ โโโ Integration Tester (E2E Validation) โ
+โ โโโ Advanced Test Suite (Comprehensive Testing) โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
+โ Infrastructure โ
+โ โโโ Models & Types (Data Structures) โ
+โ โโโ Constants & Config (Settings) โ
+โ โโโ Exceptions (Error Handling) โ
+โ โโโ Utils (Helper Functions) โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+```
+
+### Connection Flow
+
+```mermaid
+graph TD
+ A[Client Initialize] --> B{Persistent?}
+ B -->|Yes| C[ConnectionKeepAlive]
+ B -->|No| D[Regular Connection]
+
+ C --> E[Multi-Region Connect]
+ D --> E
+
+ E --> F[Authentication]
+ F --> G{Success?}
+ G -->|Yes| H[Start Keep-Alive Tasks]
+ G -->|No| I[Retry with Next Region]
+
+ H --> J[Ping Loop 20s]
+ H --> K[Message Processing]
+ H --> L[Health Monitoring]
+
+ I --> E
+
+ J --> M{Connected?}
+ M -->|Yes| J
+ M -->|No| N[Auto Reconnect]
+ N --> E
+```
+
+## ๐งช Testing
+
+### Run All Tests
+
+```bash
+# Complete integration test suite
+python integration_tests.py "your_ssid_here"
+
+# Advanced test scenarios
+python advanced_testing_suite.py "your_ssid_here"
+
+# Load and stress testing
+python load_testing_tool.py "your_ssid_here"
+
+# Comprehensive demo
+python comprehensive_demo.py "your_ssid_here"
+```
+
+### Test Categories
+
+1. **Unit Tests**: Individual component testing
+2. **Integration Tests**: End-to-end functionality
+3. **Load Tests**: Performance under load
+4. **Stress Tests**: Extreme condition handling
+5. **Monitoring Tests**: Real-time diagnostics
+6. **Error Recovery Tests**: Failure scenarios
+
+## ๐ Performance
+
+### Benchmarks
+
+Typical performance metrics (may vary based on network and server conditions):
+
+- **Connection Time**: < 2 seconds
+- **Message Latency**: < 100ms
+- **Throughput**: 10-50 operations/second
+- **Memory Usage**: < 50MB for standard operations
+- **CPU Usage**: < 5% during normal operation
+
+### Optimization Features
+
+- **Connection Pooling**: Reuse connections across operations
+- **Message Batching**: Group messages for efficiency
+- **Caching**: Store frequently accessed data
+- **Concurrent Operations**: Parallel processing
+- **Rate Limiting**: Prevent API overload
+
+## ๐ก๏ธ Error Handling
+
+### Automatic Recovery
+
+- **Connection Loss**: Auto-reconnect with exponential backoff
+- **Authentication Errors**: Session refresh and retry
+- **Network Issues**: Multiple region fallback
+- **API Errors**: Graceful degradation and retry logic
+
+### Error Categories
+
+1. **Connection Errors**: Network and WebSocket issues
+2. **Authentication Errors**: Invalid or expired sessions
+3. **API Errors**: Invalid parameters or server errors
+4. **Timeout Errors**: Operation timeout handling
+5. **Rate Limit Errors**: API quota exceeded
+
+## ๐ง Configuration
+
+### Environment Variables
+
+```bash
+# Optional configuration
+export POCKETOPTION_DEBUG=true
+export POCKETOPTION_LOG_LEVEL=DEBUG
+export POCKETOPTION_MAX_RETRIES=5
+export POCKETOPTION_TIMEOUT=30
+```
+
+### Client Configuration
+
+```python
+client = AsyncPocketOptionClient(
+ ssid="your_ssid",
+ is_demo=True, # Demo/Live mode
+ region="eu", # Preferred region
+ persistent_connection=True, # Keep-alive enabled
+ auto_reconnect=True, # Auto-reconnection
+ uid=12345, # User ID
+ platform=1 # Platform identifier
+)
+```
+
+## ๐ API Reference
+
+### AsyncPocketOptionClient
+
+Main client class for API operations.
+
+```python
+class AsyncPocketOptionClient:
+ async def connect(regions: List[str] = None, persistent: bool = None) -> bool
+ async def disconnect() -> None
+ async def get_balance() -> Balance
+ async def get_candles(asset: str, timeframe: TimeFrame, count: int) -> List[Candle]
+ async def place_order(asset: str, amount: float, direction: OrderDirection, duration: int) -> OrderResult
+ async def send_message(message: str) -> bool
+ def get_connection_stats() -> Dict[str, Any]
+ def add_event_callback(event: str, callback: Callable) -> None
+```
+
+### ConnectionKeepAlive
+
+Advanced connection management with keep-alive.
+
+```python
+class ConnectionKeepAlive:
+ async def start_persistent_connection() -> bool
+ async def stop_persistent_connection() -> None
+ async def send_message(message: str) -> bool
+ def add_event_handler(event: str, handler: Callable) -> None
+ def get_connection_stats() -> Dict[str, Any]
+```
+
+### ConnectionMonitor
+
+Real-time monitoring and diagnostics.
+
+```python
+class ConnectionMonitor:
+ async def start_monitoring(persistent_connection: bool = True) -> bool
+ async def stop_monitoring() -> None
+ def get_real_time_stats() -> Dict[str, Any]
+ def generate_diagnostics_report() -> Dict[str, Any]
+ def export_metrics_csv(filename: str = None) -> str
+```
+
+## ๐ค Contributing
+
+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
+
+### Development Setup
+
+```bash
+# Clone and setup
+git clone
+cd PocketOptionAPI-3
+
+# Install development dependencies
+pip install -r requirements-dev.txt
+
+# Run tests
+python -m pytest tests/
+
+# Run linting
+flake8 pocketoptionapi_async/
+mypy pocketoptionapi_async/
+```
+
+## ๐ License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## โ ๏ธ Disclaimer
+
+This software is for educational and research purposes only. Trading involves substantial risk and may not be suitable for all individuals. Past performance does not guarantee future results. Please trade responsibly and consider your financial situation before using this API for live trading.
+
+## ๐ Support
+
+- **Issues**: Report bugs or request features via GitHub Issues
+- **Documentation**: See examples in the `examples/` directory
+- **Discussions**: Join discussions in GitHub Discussions
+
+## ๐ Changelog
+
+### v2.0.0 - Enhanced Edition
+
+- โ
Complete SSID format support
+- โ
Persistent connections with keep-alive
+- โ
Advanced monitoring and diagnostics
+- โ
Comprehensive testing frameworks
+- โ
Performance optimizations
+- โ
Enhanced error handling
+- โ
Real-time connection monitoring
+- โ
Load testing capabilities
+- โ
Integration testing suite
+- โ
Modern async architecture
+
+### v1.0.0 - Initial Release
+
+- Basic async API client
+- WebSocket connection management
+- Core trading operations
+- Error handling
+
+---
-# Extra help
-for a better understanding, check this [link](https://github.com/theshadow76/PocketOptionAPI/issues/4)
+**Built with โค๏ธ for the PocketOption community**
diff --git a/README_ENHANCED.md b/README_ENHANCED.md
index c47088a..676ff75 100644
--- a/README_ENHANCED.md
+++ b/README_ENHANCED.md
@@ -1,5 +1,15 @@
# PocketOption Async API - Enhanced Edition
+Check BinaryOptionToolsv2: [https://github.com/ChipaDevTeam/BinaryOptionsTools-v2](https://github.com/ChipaDevTeam/BinaryOptionsTools-v2)
+
+## Support us
+join PocketOption with our affiliate link: [PocketOption Affiliate link](https://u3.shortink.io/smart/SDIaxbeamcYYqB)
+donate in paypal: [Paypal.me](https://paypal.me/ChipaCL?country.x=CL&locale.x=en_US)
+help us in patreon: [Patreon](https://patreon.com/VigoDEV?utm_medium=unknown&utm_source=join_link&utm_campaign=creatorshare_creator&utm_content=copyLink)
+
+## check our bots and talk to us!
+Join our comunity --> [discord](https://discord.com/invite/kaZ8uV9b6k)
+
A comprehensive, modern async Python API for PocketOption trading platform with advanced features including persistent connections, monitoring, and extensive testing frameworks.
## ๐ Key Features
diff --git a/pocketoptionapi_async/client.py b/pocketoptionapi_async/client.py
index 5fa2174..2c162e5 100644
--- a/pocketoptionapi_async/client.py
+++ b/pocketoptionapi_async/client.py
@@ -16,7 +16,7 @@
from .websocket_client import AsyncWebSocketClient
from .models import (
Balance, Candle, Order, OrderResult, OrderStatus, OrderDirection,
- Asset, ConnectionStatus, ServerTime
+ ConnectionStatus, ServerTime
)
from .constants import ASSETS, REGIONS, TIMEFRAMES, API_LIMITS
from .exceptions import (
@@ -32,7 +32,8 @@ class AsyncPocketOptionClient:
def __init__(self, ssid: str, is_demo: bool = True, region: Optional[str] = None,
uid: int = 0, platform: int = 1, is_fast_history: bool = True,
- persistent_connection: bool = False, auto_reconnect: bool = True):
+ persistent_connection: bool = False, auto_reconnect: bool = True,
+ enable_logging: bool = True):
"""
Initialize async PocketOption client with enhanced monitoring
@@ -45,6 +46,7 @@ def __init__(self, ssid: str, is_demo: bool = True, region: Optional[str] = None
is_fast_history: Enable fast history loading
persistent_connection: Enable persistent connection with keep-alive (like old API)
auto_reconnect: Enable automatic reconnection on disconnection
+ enable_logging: Enable detailed logging (default: True)
"""
self.raw_ssid = ssid
self.is_demo = is_demo
@@ -54,21 +56,35 @@ def __init__(self, ssid: str, is_demo: bool = True, region: Optional[str] = None
self.is_fast_history = is_fast_history
self.persistent_connection = persistent_connection
self.auto_reconnect = auto_reconnect
-
- # Parse SSID if it's a complete auth message
+ self.enable_logging = enable_logging
+
+ # Configure logging based on preference
+ if not enable_logging:
+ logger.remove()
+ logger.add(lambda msg: None, level="CRITICAL") # Disable most logging
+ # Parse SSID if it's a complete auth message
+ self._original_demo = None # Store original demo value from SSID
if ssid.startswith('42["auth",'):
self._parse_complete_ssid(ssid)
else:
# Treat as raw session ID
self.session_id = ssid
self._complete_ssid = None
-
+
# Core components
self._websocket = AsyncWebSocketClient()
self._balance: Optional[Balance] = None
self._orders: Dict[str, OrderResult] = {}
+ self._active_orders: Dict[str, OrderResult] = {}
+ self._order_results: Dict[str, OrderResult] = {}
+ self._candles_cache: Dict[str, List[Candle]] = {}
self._server_time: Optional[ServerTime] = None
self._event_callbacks: Dict[str, List[Callable]] = defaultdict(list)
+ # Setup event handlers for websocket messages
+ self._setup_event_handlers()
+
+ # Add handler for JSON data messages (contains detailed order data)
+ self._websocket.add_event_handler('json_data', self._on_json_data)
# Enhanced monitoring and error handling
self._error_monitor = error_monitor
@@ -96,32 +112,109 @@ def __init__(self, ssid: str, is_demo: bool = True, region: Optional[str] = None
'connection_start_time': None
}
- logger.info(f"Initialized PocketOption client (demo={is_demo}, uid={self.uid}, persistent={persistent_connection}) with enhanced monitoring")
-
+ logger.info(f"Initialized PocketOption client (demo={is_demo}, uid={self.uid}, persistent={persistent_connection}) with enhanced monitoring" if enable_logging else "")
+
+ def _setup_event_handlers(self):
+ """Setup WebSocket event handlers"""
+ self._websocket.add_event_handler('authenticated', self._on_authenticated)
+ self._websocket.add_event_handler('balance_updated', self._on_balance_updated)
+ self._websocket.add_event_handler('balance_data', self._on_balance_data) # Add balance_data handler
+ self._websocket.add_event_handler('order_opened', self._on_order_opened)
+ self._websocket.add_event_handler('order_closed', self._on_order_closed)
+ self._websocket.add_event_handler('stream_update', self._on_stream_update)
+ self._websocket.add_event_handler('candles_received', self._on_candles_received)
+ self._websocket.add_event_handler('disconnected', self._on_disconnected)
+
async def connect(self, regions: Optional[List[str]] = None, persistent: bool = None) -> bool:
"""
- Connect to PocketOption WebSocket with optional persistent keep-alive
+ Connect to PocketOption with multiple region support
Args:
- regions: Optional list of specific regions to try
- persistent: Override persistent connection setting for this connection
+ regions: List of regions to try (uses defaults if None)
+ persistent: Override persistent connection setting
Returns:
bool: True if connected successfully
"""
+ logger.info("๐ Connecting to PocketOption...")
+ # Update persistent setting if provided
+ if persistent is not None:
+ self.persistent_connection = persistent
+
try:
- # Use persistent setting from init or override
- use_persistent = persistent if persistent is not None else self.persistent_connection
-
- if use_persistent:
+ if self.persistent_connection:
return await self._start_persistent_connection(regions)
else:
return await self._start_regular_connection(regions)
except Exception as e:
logger.error(f"Connection failed: {e}")
- raise ConnectionError(f"Failed to connect: {e}")
-
+ await self._error_monitor.record_error(
+ error_type="connection_failed",
+ severity=ErrorSeverity.HIGH,
+ category=ErrorCategory.CONNECTION,
+ message=f"Connection failed: {e}"
+ )
+ return False
+
+ async def _start_regular_connection(self, regions: Optional[List[str]] = None) -> bool:
+ """Start regular connection (existing behavior)"""
+ logger.info("Starting regular connection...")
+ # Use appropriate regions based on demo mode
+ if not regions:
+ if self.is_demo:
+ # For demo mode, only use demo regions
+ demo_urls = REGIONS.get_demo_regions()
+ regions = []
+ all_regions = REGIONS.get_all_regions()
+ for name, url in all_regions.items():
+ if url in demo_urls:
+ regions.append(name)
+ logger.info(f"Demo mode: Using demo regions: {regions}")
+ else:
+ # For live mode, use all regions except demo
+ all_regions = REGIONS.get_all_regions()
+ regions = [name for name, url in all_regions.items() if "DEMO" not in name.upper()]
+ logger.info(f"Live mode: Using non-demo regions: {regions}")
+ # Update connection stats
+ self._connection_stats['total_connections'] += 1
+ self._connection_stats['connection_start_time'] = time.time()
+
+ for region in regions:
+ try:
+ region_url = REGIONS.get_region(region)
+ if not region_url:
+ continue
+
+ urls = [region_url] # Convert single URL to list
+ logger.info(f"Trying region: {region} with URL: {region_url}")
+
+ # Try to connect
+ ssid_message = self._format_session_message()
+ success = await self._websocket.connect(urls, ssid_message)
+
+ if success:
+ logger.info(f"โ
Connected to region: {region}")
+
+ # Wait for authentication
+ await self._wait_for_authentication()
+
+ # Initialize data
+ await self._initialize_data()
+
+ # Start keep-alive tasks
+ await self._start_keep_alive_tasks()
+
+ self._connection_stats['successful_connections'] += 1
+ logger.info("Successfully connected and authenticated")
+ return True
+
+ except Exception as e:
+ logger.warning(f"Failed to connect to region {region}: {e}")
+ continue
+
+ return False
+
async def _start_persistent_connection(self, regions: Optional[List[str]] = None) -> bool:
"""Start persistent connection with keep-alive (like old API)"""
logger.info("๐ Starting persistent connection with automatic keep-alive...")
@@ -132,67 +225,25 @@ async def _start_persistent_connection(self, regions: Optional[List[str]] = None
from connection_keep_alive import ConnectionKeepAlive
# Create keep-alive manager
- complete_ssid = self._format_session_message()
+ complete_ssid = self.raw_ssid
self._keep_alive_manager = ConnectionKeepAlive(complete_ssid, self.is_demo)
# Add event handlers
self._keep_alive_manager.add_event_handler('connected', self._on_keep_alive_connected)
self._keep_alive_manager.add_event_handler('reconnected', self._on_keep_alive_reconnected)
self._keep_alive_manager.add_event_handler('message_received', self._on_keep_alive_message)
- self._keep_alive_manager.add_event_handler('authenticated', self._on_keep_alive_authenticated)
- # Start persistent connection
- success = await self._keep_alive_manager.start_persistent_connection()
+ # Connect with keep-alive
+ success = await self._keep_alive_manager.connect_with_keep_alive(regions)
if success:
self._is_persistent = True
- self._connection_stats['connection_start_time'] = datetime.now()
- self._connection_stats['successful_connections'] += 1
-
- # Initialize data
- await self._initialize_data()
-
- logger.success("โ
Persistent connection established with keep-alive active")
+ logger.info("โ
Persistent connection established successfully")
return True
else:
logger.error("โ Failed to establish persistent connection")
return False
-
- async def _start_regular_connection(self, regions: Optional[List[str]] = None) -> bool:
- """Start regular connection (existing behavior)"""
- # Get URLs to try
- if regions:
- urls = [REGIONS.get_region(region) for region in regions if REGIONS.get_region(region)]
- else:
- urls = REGIONS.get_demo_regions() if self.is_demo else REGIONS.get_all()
-
- if not urls:
- raise ConnectionError("No valid WebSocket URLs available")
-
- # Format session message
- ssid_message = self._format_session_message()
-
- # Connect to WebSocket
- success = await self._websocket.connect(urls, ssid_message)
-
- if success:
- self._connection_stats['successful_connections'] += 1
-
- # Start keep-alive for regular connection too (if auto_reconnect enabled)
- if self.auto_reconnect:
- await self._start_keep_alive_tasks()
-
- # Wait for authentication
- await self._wait_for_authentication()
-
- # Initialize data
- await self._initialize_data()
-
- logger.info("Successfully connected and authenticated")
- return True
-
- return False
-
+
async def _start_keep_alive_tasks(self):
"""Start keep-alive tasks for regular connection"""
logger.info("๐ Starting keep-alive tasks for regular connection...")
@@ -203,86 +254,61 @@ async def _start_keep_alive_tasks(self):
# Start reconnection monitor if auto_reconnect is enabled
if self.auto_reconnect:
self._reconnect_task = asyncio.create_task(self._reconnection_monitor())
-
+
async def _ping_loop(self):
"""Ping loop for regular connections (like old API)"""
- while self.is_connected:
+ while self.is_connected and not self._is_persistent:
try:
- await asyncio.sleep(20) # 20 seconds like old API
-
- if self.is_connected:
- await self._websocket.send_message('42["ps"]')
- self._connection_stats['last_ping_time'] = datetime.now()
- self._connection_stats['messages_sent'] += 1
- logger.debug("๐ Ping sent")
-
+ await self._websocket.send_message('42["ps"]')
+ self._connection_stats['last_ping_time'] = time.time()
+ await asyncio.sleep(20) # Ping every 20 seconds
except Exception as e:
- logger.error(f"โ Ping failed: {e}")
+ logger.warning(f"Ping failed: {e}")
break
-
+
async def _reconnection_monitor(self):
"""Monitor and handle reconnections for regular connections"""
- while self.auto_reconnect:
- try:
- await asyncio.sleep(5) # Check every 5 seconds
+ while self.auto_reconnect and not self._is_persistent:
+ await asyncio.sleep(30) # Check every 30 seconds
+
+ if not self.is_connected:
+ logger.info("๐ Connection lost, attempting reconnection...")
+ self._connection_stats['total_reconnects'] += 1
- if not self.is_connected and self.auto_reconnect:
- logger.warning("๐ Connection lost, attempting reconnection...")
-
- self._connection_stats['total_reconnects'] += 1
-
- # Try to reconnect
- try:
- success = await self._start_regular_connection()
- if success:
- logger.success("โ
Reconnection successful!")
- await self._emit_event('reconnected', {})
- else:
- await asyncio.sleep(5) # Wait before next attempt
- except Exception as e:
- logger.error(f"โ Reconnection failed: {e}")
- await asyncio.sleep(5)
-
- except Exception as e:
- logger.error(f"โ Reconnection monitor error: {e}")
-
+ try:
+ success = await self._start_regular_connection()
+ if success:
+ logger.info("โ
Reconnection successful")
+ else:
+ logger.error("โ Reconnection failed")
+ await asyncio.sleep(10) # Wait before next attempt
+ except Exception as e:
+ logger.error(f"Reconnection error: {e}")
+ await asyncio.sleep(10)
+
async def disconnect(self) -> None:
"""Disconnect from PocketOption and cleanup all resources"""
- try:
- logger.info("๐ Disconnecting from PocketOption...")
-
- # Stop auto-reconnect
- self.auto_reconnect = False
-
- # Stop keep-alive manager if running
- if self._keep_alive_manager:
- await self._keep_alive_manager.stop_persistent_connection()
- self._keep_alive_manager = None
- self._is_persistent = False
-
- # Cancel background tasks
- if self._ping_task and not self._ping_task.done():
- self._ping_task.cancel()
- try:
- await self._ping_task
- except asyncio.CancelledError:
- pass
-
- if self._reconnect_task and not self._reconnect_task.done():
- self._reconnect_task.cancel()
- try:
- await self._reconnect_task
- except asyncio.CancelledError:
- pass
+ logger.info("๐ Disconnecting from PocketOption...")
+
+ # Cancel tasks
+ if self._ping_task:
+ self._ping_task.cancel()
+ if self._reconnect_task:
+ self._reconnect_task.cancel()
- # Disconnect regular websocket
+ # Disconnect based on connection type
+ if self._is_persistent and self._keep_alive_manager:
+ await self._keep_alive_manager.disconnect()
+ else:
await self._websocket.disconnect()
-
- logger.info("โ
Disconnected from PocketOption")
-
- except Exception as e:
- logger.error(f"โ Disconnect error: {e}")
-
+
+ # Reset state
+ self._is_persistent = False
+ self._balance = None
+ self._orders.clear()
+
+ logger.info("Disconnected successfully")
+
async def get_balance(self) -> Balance:
"""
Get current account balance
@@ -296,55 +322,57 @@ async def get_balance(self) -> Balance:
# Request balance update if needed
if not self._balance or (datetime.now() - self._balance.last_updated).seconds > 60:
await self._request_balance_update()
+
+ # Wait a bit for balance to be received
+ await asyncio.sleep(1)
+
+ if not self._balance:
+ raise PocketOptionError("Balance data not available")
return self._balance
-
+
async def place_order(self, asset: str, amount: float, direction: OrderDirection,
duration: int) -> OrderResult:
"""
Place a binary options order
Args:
- asset: Asset symbol (e.g., 'EURUSD_otc')
- amount: Order amount in USD
- direction: Order direction (CALL or PUT)
+ asset: Asset symbol (e.g., "EURUSD_otc")
+ amount: Order amount
+ direction: OrderDirection.CALL or OrderDirection.PUT
duration: Duration in seconds
Returns:
- OrderResult: Order execution result
+ OrderResult: Order placement result
"""
- # Validate parameters
- self._validate_order_parameters(asset, amount, direction, duration)
-
if not self.is_connected:
raise ConnectionError("Not connected to PocketOption")
-
- # Create order
- order = Order(
- asset=asset,
- amount=amount,
- direction=direction,
- duration=duration
- )
+ # Validate parameters
+ self._validate_order_parameters(asset, amount, direction, duration)
try:
- # Send order
+ # Create order
+ order_id = str(uuid.uuid4())
+ order = Order(
+ asset=asset,
+ amount=amount,
+ direction=direction,
+ duration=duration,
+ request_id=order_id # Use request_id, not order_id
+ ) # Send order
await self._send_order(order)
- # Wait for order result
- result = await self._wait_for_order_result(order.request_id)
-
- # Store active order
- if result.status == OrderStatus.ACTIVE:
- self._active_orders[result.order_id] = result
+ # Wait for result (this will either get the real server response or create a fallback)
+ result = await self._wait_for_order_result(order_id, order)
+ # Don't store again - _wait_for_order_result already handles storage
logger.info(f"Order placed: {result.order_id} - {result.status}")
return result
except Exception as e:
logger.error(f"Order placement failed: {e}")
raise OrderError(f"Failed to place order: {e}")
-
+
async def get_candles(self, asset: str, timeframe: Union[str, int],
count: int = 100, end_time: Optional[datetime] = None) -> List[Candle]:
"""
@@ -352,21 +380,19 @@ async def get_candles(self, asset: str, timeframe: Union[str, int],
Args:
asset: Asset symbol
- timeframe: Timeframe (e.g., '1m', '5m' or seconds)
+ timeframe: Timeframe (e.g., "1m", "5m", 60)
count: Number of candles to retrieve
- end_time: End time for historical data (default: now)
+ end_time: End time for data (defaults to now)
Returns:
List[Candle]: Historical candle data
"""
if not self.is_connected:
raise ConnectionError("Not connected to PocketOption")
-
- # Convert timeframe
+
+ # Convert timeframe to seconds
if isinstance(timeframe, str):
- timeframe_seconds = TIMEFRAMES.get(timeframe)
- if not timeframe_seconds:
- raise InvalidParameterError(f"Invalid timeframe: {timeframe}")
+ timeframe_seconds = TIMEFRAMES.get(timeframe, 60)
else:
timeframe_seconds = timeframe
@@ -392,17 +418,17 @@ async def get_candles(self, asset: str, timeframe: Union[str, int],
except Exception as e:
logger.error(f"Failed to get candles: {e}")
raise PocketOptionError(f"Failed to get candles: {e}")
-
+
async def get_candles_dataframe(self, asset: str, timeframe: Union[str, int],
count: int = 100, end_time: Optional[datetime] = None) -> pd.DataFrame:
"""
- Get historical candle data as pandas DataFrame
+ Get historical candle data as DataFrame
Args:
asset: Asset symbol
- timeframe: Timeframe (e.g., '1m', '5m' or seconds)
+ timeframe: Timeframe (e.g., "1m", "5m", 60)
count: Number of candles to retrieve
- end_time: End time for historical data
+ end_time: End time for data (defaults to now)
Returns:
pd.DataFrame: Historical candle data
@@ -420,14 +446,14 @@ async def get_candles_dataframe(self, asset: str, timeframe: Union[str, int],
'close': candle.close,
'volume': candle.volume
})
-
df = pd.DataFrame(data)
+
if not df.empty:
df.set_index('timestamp', inplace=True)
df.sort_index(inplace=True)
return df
-
+
async def check_order_result(self, order_id: str) -> Optional[OrderResult]:
"""
Check the result of a specific order
@@ -438,8 +464,17 @@ async def check_order_result(self, order_id: str) -> Optional[OrderResult]:
Returns:
OrderResult: Order result or None if not found
"""
- return self._order_results.get(order_id)
-
+ # First check active orders
+ if order_id in self._active_orders:
+ return self._active_orders[order_id]
+
+ # Then check completed orders
+ if order_id in self._order_results:
+ return self._order_results[order_id]
+
+ # Not found
+ return None
+
async def get_active_orders(self) -> List[OrderResult]:
"""
Get all active orders
@@ -448,7 +483,7 @@ async def get_active_orders(self) -> List[OrderResult]:
List[OrderResult]: Active orders
"""
return list(self._active_orders.values())
-
+
def add_event_callback(self, event: str, callback: Callable) -> None:
"""
Add event callback
@@ -460,7 +495,7 @@ def add_event_callback(self, event: str, callback: Callable) -> None:
if event not in self._event_callbacks:
self._event_callbacks[event] = []
self._event_callbacks[event].append(callback)
-
+
def remove_event_callback(self, event: str, callback: Callable) -> None:
"""
Remove event callback
@@ -474,7 +509,7 @@ def remove_event_callback(self, event: str, callback: Callable) -> None:
self._event_callbacks[event].remove(callback)
except ValueError:
pass
-
+
@property
def is_connected(self) -> bool:
"""Check if client is connected (including persistent connections)"""
@@ -482,7 +517,7 @@ def is_connected(self) -> bool:
return self._keep_alive_manager.is_connected
else:
return self._websocket.is_connected
-
+
@property
def connection_info(self):
"""Get connection information (including persistent connections)"""
@@ -490,120 +525,96 @@ def connection_info(self):
return self._keep_alive_manager.connection_info
else:
return self._websocket.connection_info
-
+
async def send_message(self, message: str) -> bool:
"""Send message through active connection"""
try:
if self._is_persistent and self._keep_alive_manager:
- success = await self._keep_alive_manager.send_message(message)
- if success:
- self._connection_stats['messages_sent'] += 1
- return success
+ return await self._keep_alive_manager.send_message(message)
else:
await self._websocket.send_message(message)
- self._connection_stats['messages_sent'] += 1
return True
except Exception as e:
- logger.error(f"โ Failed to send message: {e}")
+ logger.error(f"Failed to send message: {e}")
return False
-
+
def get_connection_stats(self) -> Dict[str, Any]:
"""Get comprehensive connection statistics"""
- stats = dict(self._connection_stats)
+ stats = self._connection_stats.copy()
if self._is_persistent and self._keep_alive_manager:
- keep_alive_stats = self._keep_alive_manager.get_connection_stats()
- stats.update(keep_alive_stats)
-
- # Add uptime calculation
- if stats.get('connection_start_time'):
- stats['uptime'] = datetime.now() - stats['connection_start_time']
-
- stats.update({
- 'is_connected': self.is_connected,
- 'is_persistent': self._is_persistent,
- 'auto_reconnect': self.auto_reconnect,
- 'current_region': self.connection_info.region if self.connection_info else None
- })
-
- return stats
-
- # Private methods
-
- def _setup_event_handlers(self):
- """Setup WebSocket event handlers"""
- self._websocket.add_event_handler('authenticated', self._on_authenticated)
- self._websocket.add_event_handler('balance_updated', self._on_balance_updated)
- self._websocket.add_event_handler('order_opened', self._on_order_opened)
- self._websocket.add_event_handler('order_closed', self._on_order_closed)
- self._websocket.add_event_handler('stream_update', self._on_stream_update)
- self._websocket.add_event_handler('candles_received', self._on_candles_received)
- self._websocket.add_event_handler('disconnected', self._on_disconnected)
+ stats.update(self._keep_alive_manager.get_stats())
+ else:
+ stats.update({
+ 'websocket_connected': self._websocket.is_connected,
+ 'connection_info': self._websocket.connection_info
+ })
+
+ return stats # Private methods
def _format_session_message(self) -> str:
"""Format session authentication message"""
- # If we have a complete SSID starting with the raw_ssid, use it directly
- if self.raw_ssid.startswith('42["auth",'):
- logger.debug("Using complete SSID as provided")
- return self.raw_ssid
-
- # If we already have a parsed complete SSID, return it
- if hasattr(self, '_complete_ssid') and self._complete_ssid:
- logger.debug("Using parsed complete SSID")
- return self._complete_ssid
-
- # Otherwise, format from components
+ # Always create auth message from components using constructor parameters
+ # This ensures is_demo parameter is respected regardless of SSID format
auth_data = {
- "session": getattr(self, 'session_id', self.raw_ssid),
+ "session": self.session_id,
"isDemo": 1 if self.is_demo else 0,
"uid": self.uid,
"platform": self.platform
}
- # Add optional parameters
if self.is_fast_history:
auth_data["isFastHistory"] = True
- formatted_ssid = f'42["auth",{json.dumps(auth_data)}]'
- logger.debug("Formatted SSID from components")
- return formatted_ssid
-
+ return f'42["auth",{json.dumps(auth_data)}]'
+
def _parse_complete_ssid(self, ssid: str) -> None:
"""Parse complete SSID auth message to extract components"""
try:
- # Extract JSON part from message like: 42["auth",{...}]
- if ssid.startswith('42["auth",') and ssid.endswith(']'):
- json_part = ssid[10:-1] # Remove '42["auth",' and ']'
- auth_data = json.loads(json_part)
-
- # Extract components
- self.session_id = auth_data.get("session", "")
- self.is_demo = bool(auth_data.get("isDemo", 1))
- self.uid = auth_data.get("uid", 0)
- self.platform = auth_data.get("platform", 1)
- self.is_fast_history = auth_data.get("isFastHistory", True)
-
- # Store complete SSID for direct use
- self._complete_ssid = ssid
-
- logger.info(f"Parsed SSID: session={self.session_id[:10]}..., uid={self.uid}, demo={self.is_demo}")
+ # Extract JSON part
+ json_start = ssid.find('{')
+ json_end = ssid.rfind('}') + 1
+ if json_start != -1 and json_end > json_start:
+ json_part = ssid[json_start:json_end]
+ data = json.loads(json_part)
- except (json.JSONDecodeError, KeyError, IndexError) as e:
- logger.warning(f"Failed to parse complete SSID, treating as raw session: {e}")
+ self.session_id = data.get('session', '')
+ # Store original demo value from SSID, but don't override the constructor parameter
+ self._original_demo = bool(data.get('isDemo', 1))
+ # Keep the is_demo value from constructor - don't override it
+ self.uid = data.get('uid', 0)
+ self.platform = data.get('platform', 1)
+ # Don't store complete SSID - we'll reconstruct it with correct demo value
+ self._complete_ssid = None
+ except Exception as e:
+ logger.warning(f"Failed to parse SSID: {e}")
self.session_id = ssid
self._complete_ssid = None
-
+
async def _wait_for_authentication(self, timeout: float = 10.0) -> None:
- """Wait for authentication to complete"""
- start_time = asyncio.get_event_loop().time()
+ """Wait for authentication to complete (like old API)"""
+ auth_received = False
- while (asyncio.get_event_loop().time() - start_time) < timeout:
- await asyncio.sleep(0.1)
- # Check if authenticated (this would be set by event handler)
- # For now, just wait a bit and assume success
+ def on_auth(data):
+ nonlocal auth_received
+ auth_received = True
+
+ # Add temporary handler
+ self._websocket.add_event_handler('authenticated', on_auth)
- await asyncio.sleep(2) # Give time for initial data
-
+ try:
+ # Wait for authentication
+ start_time = time.time()
+ while not auth_received and (time.time() - start_time) < timeout:
+ await asyncio.sleep(0.1)
+
+ if not auth_received:
+ raise AuthenticationError("Authentication timeout")
+
+ finally:
+ # Remove temporary handler
+ self._websocket.remove_event_handler('authenticated', on_auth)
+
async def _initialize_data(self) -> None:
"""Initialize client data after connection"""
# Request initial balance
@@ -611,12 +622,12 @@ async def _initialize_data(self) -> None:
# Setup time synchronization
await self._setup_time_sync()
-
+
async def _request_balance_update(self) -> None:
"""Request balance update from server"""
message = '42["getBalance"]'
await self._websocket.send_message(message)
-
+
async def _setup_time_sync(self) -> None:
"""Setup server time synchronization"""
# This would typically involve getting server timestamp
@@ -627,7 +638,7 @@ async def _setup_time_sync(self) -> None:
local_timestamp=local_time,
offset=0.0
)
-
+
def _validate_order_parameters(self, asset: str, amount: float,
direction: OrderDirection, duration: int) -> None:
"""Validate order parameters"""
@@ -635,64 +646,261 @@ def _validate_order_parameters(self, asset: str, amount: float,
raise InvalidParameterError(f"Invalid asset: {asset}")
if amount < API_LIMITS['min_order_amount'] or amount > API_LIMITS['max_order_amount']:
- raise InvalidParameterError(
- f"Amount must be between {API_LIMITS['min_order_amount']} and {API_LIMITS['max_order_amount']}"
+ raise InvalidParameterError( f"Amount must be between {API_LIMITS['min_order_amount']} and {API_LIMITS['max_order_amount']}"
)
if duration < API_LIMITS['min_duration'] or duration > API_LIMITS['max_duration']:
raise InvalidParameterError(
f"Duration must be between {API_LIMITS['min_duration']} and {API_LIMITS['max_duration']} seconds"
)
-
+
async def _send_order(self, order: Order) -> None:
"""Send order to server"""
- order_data = {
- "asset": order.asset,
- "amount": order.amount,
- "action": order.direction.value,
- "isDemo": 1 if self.is_demo else 0,
- "requestId": order.request_id,
- "optionType": 100,
- "time": order.duration
- }
+ # Format asset name with # prefix if not already present
+ asset_name = order.asset
- message = f'42["openOrder",{json.dumps(order_data)}]'
+ # Create the message in the correct PocketOption format
+ message = f'42["openOrder",{{"asset":"{asset_name}","amount":{order.amount},"action":"{order.direction.value}","isDemo":{1 if self.is_demo else 0},"requestId":"{order.request_id}","optionType":100,"time":{order.duration}}}]'
await self._websocket.send_message(message)
-
- async def _wait_for_order_result(self, request_id: str, timeout: float = 10.0) -> OrderResult:
+ if self.enable_logging:
+ logger.debug(f"Sent order: {message}")
+
+ async def _wait_for_order_result(self, request_id: str, order: Order, timeout: float = 30.0) -> OrderResult:
"""Wait for order execution result"""
- start_time = asyncio.get_event_loop().time()
-
- while (asyncio.get_event_loop().time() - start_time) < timeout:
+ start_time = time.time()
+
+ # Wait for order to appear in tracking system
+ while time.time() - start_time < timeout:
+ # Check if order was added to active orders (by _on_order_opened or _on_json_data)
+ if request_id in self._active_orders:
+ if self.enable_logging:
+ logger.success(f"โ
Order {request_id} found in active tracking")
+ return self._active_orders[request_id]
+
+ # Check if order went directly to results (failed or completed)
if request_id in self._order_results:
+ if self.enable_logging:
+ logger.info(f"๐ Order {request_id} found in completed results")
return self._order_results[request_id]
- await asyncio.sleep(0.1)
-
- raise TimeoutError(f"Order result timeout for request {request_id}")
-
+
+ await asyncio.sleep(0.2) # Check every 200ms
+
+ # Check one more time before creating fallback
+ if request_id in self._active_orders:
+ if self.enable_logging:
+ logger.success(f"โ
Order {request_id} found in active tracking (final check)")
+ return self._active_orders[request_id]
+
+ if request_id in self._order_results:
+ if self.enable_logging:
+ logger.info(f"๐ Order {request_id} found in completed results (final check)")
+ return self._order_results[request_id]
+
+ # If timeout, create a fallback result with the original order data
+ if self.enable_logging:
+ logger.warning(f"โฐ Order {request_id} timed out waiting for server response, creating fallback result")
+ fallback_result = OrderResult(
+ order_id=request_id,
+ asset=order.asset,
+ amount=order.amount,
+ direction=order.direction,
+ duration=order.duration,
+ status=OrderStatus.ACTIVE, # Assume it's active since it was placed
+ placed_at=datetime.now(),
+ expires_at=datetime.now() + timedelta(seconds=order.duration),
+ error_message="Timeout waiting for server confirmation"
+ )
+ # Store it in active orders in case server responds later
+ self._active_orders[request_id] = fallback_result
+ if self.enable_logging:
+ logger.info(f"๐ Created fallback order result for {request_id}")
+ return fallback_result
+
async def _request_candles(self, asset: str, timeframe: int, count: int,
end_time: datetime) -> List[Candle]:
- """Request candle data from server"""
- # Convert end_time to timestamp
+ """Request candle data from server using the correct PocketOption format"""
+
+ # Convert end_time to timestamp (similar to original API)
end_timestamp = int(end_time.timestamp())
- candle_data = {
- "asset": asset,
+ # Create message data in the format expected by PocketOption
+ data = {
+ "asset": str(asset),
"index": end_timestamp,
- "time": end_timestamp,
- "offset": count,
- "period": timeframe
+ "offset": count, # number of candles
+ "period": timeframe, # timeframe in seconds
+ "time": end_timestamp # end time timestamp
}
- message = f'42["loadHistoryPeriod",{json.dumps(candle_data)}]'
+ # Create the full message
+ message_data = ["loadHistoryPeriod", data]
+ message = f'42["sendMessage",{json.dumps(message_data)}]'
+
+ if self.enable_logging:
+ logger.debug(f"Requesting candles: {message}")
+
+ # Create a future to wait for the response
+ candle_future = asyncio.Future()
+ request_id = f"{asset}_{timeframe}_{end_timestamp}"
+
+ # Store the future for this request
+ if not hasattr(self, '_candle_requests'):
+ self._candle_requests = {}
+ self._candle_requests[request_id] = candle_future
+
+ # Send the request
await self._websocket.send_message(message)
- # Wait for candles (this would be implemented with proper event handling)
- await asyncio.sleep(2) # Placeholder
+ try:
+ # Wait for the response (with timeout)
+ candles = await asyncio.wait_for(candle_future, timeout=10.0)
+ return candles
+ except asyncio.TimeoutError:
+ if self.enable_logging:
+ logger.warning(f"Candle request timed out for {asset}")
+ return []
+ finally:
+ # Clean up the request
+ if request_id in self._candle_requests:
+ del self._candle_requests[request_id]
+
+ def _parse_candles_data(self, candles_data: List[Any]) -> List[Candle]:
+ """Parse candles data from server response"""
+ candles = []
- # For now, return empty list (would be populated by event handler)
- return []
-
+ try:
+ if isinstance(candles_data, list):
+ for candle_data in candles_data:
+ if isinstance(candle_data, (list, tuple)) and len(candle_data) >= 6:
+ # Expected format: [timestamp, open, close, high, low, volume]
+ candle = Candle(
+ timestamp=datetime.fromtimestamp(candle_data[0]),
+ open=float(candle_data[1]),
+ close=float(candle_data[2]),
+ high=float(candle_data[3]),
+ low=float(candle_data[4]),
+ volume=float(candle_data[5]) if len(candle_data) > 5 else 0.0
+ )
+ candles.append(candle)
+ elif isinstance(candle_data, dict):
+ # Handle dict format
+ candle = Candle(
+ timestamp=datetime.fromtimestamp(candle_data.get('timestamp', 0)),
+ open=float(candle_data.get('open', 0)),
+ close=float(candle_data.get('close', 0)),
+ high=float(candle_data.get('high', 0)),
+ low=float(candle_data.get('low', 0)),
+ volume=float(candle_data.get('volume', 0))
+ )
+ candles.append(candle)
+ except Exception as e:
+ if self.enable_logging:
+ logger.error(f"Error parsing candles data: {e}")
+
+ return candles
+
+ # ...existing code...
+
+ async def _on_json_data(self, data: Dict[str, Any]) -> None:
+ """Handle detailed order data from JSON bytes messages"""
+ if not isinstance(data, dict):
+ return
+
+ # Check if this is candles data response
+ if "history" in data and isinstance(data["history"], list):
+ # Find the corresponding candle request
+ if hasattr(self, '_candle_requests'):
+ # Try to match the request - in a real implementation you'd need better matching
+ for request_id, future in list(self._candle_requests.items()):
+ if not future.done():
+ candles = self._parse_candles_data(data["history"])
+ future.set_result(candles)
+ if self.enable_logging:
+ logger.success(f"โ
Candles data received: {len(candles)} candles")
+ break
+ return
+
+ # Check if this is detailed order data with requestId
+ if "requestId" in data and "asset" in data and "amount" in data:
+ request_id = str(data["requestId"])
+
+ # If this is a new order, add it to tracking
+ if request_id not in self._active_orders and request_id not in self._order_results:
+ order_result = OrderResult(
+ order_id=request_id,
+ asset=data.get('asset', 'UNKNOWN'),
+ amount=float(data.get('amount', 0)),
+ direction=OrderDirection.CALL if data.get('command', 0) == 0 else OrderDirection.PUT,
+ duration=int(data.get('time', 60)),
+ status=OrderStatus.ACTIVE,
+ placed_at=datetime.now(),
+ expires_at=datetime.now() + timedelta(seconds=int(data.get('time', 60))),
+ profit=float(data.get('profit', 0)) if 'profit' in data else None,
+ payout=data.get('payout')
+ )
+
+ # Add to active orders
+ self._active_orders[request_id] = order_result
+ if self.enable_logging:
+ logger.success(f"โ
Order {request_id} added to tracking from JSON data")
+
+ await self._emit_event('order_opened', data)
+
+ # Check if this is order result data with deals
+ elif "deals" in data and isinstance(data["deals"], list):
+ for deal in data["deals"]:
+ if isinstance(deal, dict) and "id" in deal:
+ order_id = str(deal["id"])
+
+ if order_id in self._active_orders:
+ active_order = self._active_orders[order_id]
+ profit = float(deal.get('profit', 0))
+
+ # Determine status
+ if profit > 0:
+ status = OrderStatus.WIN
+ elif profit < 0:
+ status = OrderStatus.LOSE
+ else:
+ status = OrderStatus.LOSE # Default for zero profit
+
+ result = OrderResult(
+ order_id=active_order.order_id,
+ asset=active_order.asset,
+ amount=active_order.amount,
+ direction=active_order.direction,
+ duration=active_order.duration,
+ status=status,
+ placed_at=active_order.placed_at,
+ expires_at=active_order.expires_at,
+ profit=profit,
+ payout=deal.get('payout')
+ )
+
+ # Move from active to completed
+ self._order_results[order_id] = result
+ del self._active_orders[order_id]
+
+ if self.enable_logging:
+ logger.success(f"โ
Order {order_id} completed via JSON data: {status.value} - Profit: ${profit:.2f}")
+ await self._emit_event('order_closed', result)
+
+ def _parse_candles_data(self, history_data: List[Dict]) -> List[Candle]:
+ """Parse candles data from history response"""
+ candles = []
+ for item in history_data:
+ if isinstance(item, dict):
+ candle = Candle(
+ timestamp=datetime.fromtimestamp(item.get('time', 0)),
+ open=float(item.get('open', 0)),
+ high=float(item.get('high', 0)),
+ low=float(item.get('low', 0)),
+ close=float(item.get('close', 0)),
+ volume=float(item.get('volume', 0))
+ )
+ candles.append(candle)
+ return candles
+
async def _emit_event(self, event: str, data: Any) -> None:
"""Emit event to registered callbacks"""
if event in self._event_callbacks:
@@ -703,226 +911,64 @@ async def _emit_event(self, event: str, data: Any) -> None:
else:
callback(data)
except Exception as e:
- logger.error(f"Error in event callback for {event}: {e}")
-
+ if self.enable_logging:
+ logger.error(f"Error in event callback for {event}: {e}")
+
# Event handlers
-
async def _on_authenticated(self, data: Dict[str, Any]) -> None:
"""Handle authentication success"""
- logger.info("Authentication successful")
+ if self.enable_logging:
+ logger.success("โ
Successfully authenticated with PocketOption")
+ self._connection_stats['successful_connections'] += 1
await self._emit_event('authenticated', data)
-
+
async def _on_balance_updated(self, data: Dict[str, Any]) -> None:
"""Handle balance update"""
- if 'balance' in data:
- self._balance = Balance(
- balance=float(data['balance']),
+ try:
+ balance = Balance(
+ balance=float(data.get('balance', 0)),
currency=data.get('currency', 'USD'),
is_demo=self.is_demo
)
- logger.info(f"Balance updated: {self._balance.balance}")
- await self._emit_event('balance_updated', self._balance)
-
+ self._balance = balance
+ if self.enable_logging:
+ logger.info(f"๐ฐ Balance updated: ${balance.balance:.2f}")
+ await self._emit_event('balance_updated', balance)
+ except Exception as e:
+ if self.enable_logging:
+ logger.error(f"Failed to parse balance data: {e}")
+
+ async def _on_balance_data(self, data: Dict[str, Any]) -> None:
+ """Handle balance data message"""
+ # This is similar to balance_updated but for different message format
+ await self._on_balance_updated(data)
+
async def _on_order_opened(self, data: Dict[str, Any]) -> None:
"""Handle order opened event"""
- logger.info(f"Order opened: {data}")
+ if self.enable_logging:
+ logger.info(f"๐ Order opened: {data}")
await self._emit_event('order_opened', data)
-
+
async def _on_order_closed(self, data: Dict[str, Any]) -> None:
"""Handle order closed event"""
- logger.info(f"Order closed: {data}")
-
- # Update order result
- if 'id' in data:
- order_id = str(data['id'])
- if order_id in self._active_orders:
- # Update order with result
- active_order = self._active_orders[order_id]
- profit = data.get('profit', 0)
-
- result = OrderResult(
- order_id=active_order.order_id,
- asset=active_order.asset,
- amount=active_order.amount,
- direction=active_order.direction,
- duration=active_order.duration,
- status=OrderStatus.WIN if profit > 0 else OrderStatus.LOSE,
- placed_at=active_order.placed_at,
- expires_at=active_order.expires_at,
- profit=profit,
- payout=data.get('payout')
- )
-
- self._order_results[order_id] = result
- del self._active_orders[order_id]
-
- await self._emit_event('order_closed', result)
-
+ if self.enable_logging:
+ logger.info(f"๐ Order closed: {data}")
+ await self._emit_event('order_closed', data)
+
async def _on_stream_update(self, data: Dict[str, Any]) -> None:
- """Handle stream update (time sync, etc.)"""
- if isinstance(data, list) and len(data) > 0:
- # Update server time
- server_timestamp = data[0].get('timestamp') if isinstance(data[0], dict) else data[0]
- if server_timestamp:
- local_timestamp = datetime.now().timestamp()
- offset = server_timestamp - local_timestamp
-
- self._server_time = ServerTime(
- server_timestamp=server_timestamp,
- local_timestamp=local_timestamp,
- offset=offset
- )
-
+ """Handle stream update event"""
+ if self.enable_logging:
+ logger.debug(f"๐ก Stream update: {data}")
+ await self._emit_event('stream_update', data)
+
async def _on_candles_received(self, data: Dict[str, Any]) -> None:
- """Handle candles data"""
- logger.info("Candles data received")
+ """Handle candles data received"""
+ if self.enable_logging:
+ logger.info(f"๐ฏ๏ธ Candles received: {len(data)} data points")
await self._emit_event('candles_received', data)
-
+
async def _on_disconnected(self, data: Dict[str, Any]) -> None:
- """Handle disconnection"""
- logger.warning("WebSocket disconnected")
+ """Handle disconnection event"""
+ if self.enable_logging:
+ logger.warning("๐ Disconnected from PocketOption")
await self._emit_event('disconnected', data)
-
- # Attempt to reconnect if enabled
- if self.auto_reconnect:
- logger.info("Attempting to reconnect...")
- await self.connect()
-
- def _connection_health_checks(self):
- """Setup connection health checks"""
- async def check_websocket_health():
- """Check WebSocket connection health"""
- try:
- if not self.is_connected:
- return {'status': 'disconnected', 'healthy': False}
-
- # Check ping response time
- start_time = time.time()
- await self._websocket.send_message('42["ps"]')
- ping_time = time.time() - start_time
-
- return {
- 'status': 'connected',
- 'healthy': ping_time < 5.0, # Healthy if ping < 5s
- 'ping_time': ping_time,
- 'connection_info': self.connection_info
- }
- except Exception as e:
- return {'status': 'error', 'healthy': False, 'error': str(e)}
-
- async def check_balance_availability():
- """Check if balance data is available and recent"""
- try:
- if not self._balance:
- return {'status': 'no_balance', 'healthy': False}
-
- time_since_update = (datetime.now() - self._balance.last_updated).total_seconds()
- is_recent = time_since_update < 300 # 5 minutes
-
- return {
- 'status': 'available',
- 'healthy': is_recent,
- 'last_update': time_since_update,
- 'balance': self._balance.balance
- }
- except Exception as e:
- return {'status': 'error', 'healthy': False, 'error': str(e)}
-
- # Register health checks
- self._health_checker.register_health_check('websocket', check_websocket_health)
- self._health_checker.register_health_check('balance', check_balance_availability)
-
- async def execute_with_monitoring(self, operation_name: str, func: Callable, *args, **kwargs):
- """Execute operation with comprehensive monitoring"""
- return await self._error_monitor.execute_with_monitoring(
- func=func,
- operation_name=operation_name,
- category=ErrorCategory.TRADING,
- use_circuit_breaker=True,
- use_retry=True,
- *args, **kwargs
- )
-
- async def get_health_status(self) -> Dict[str, Any]:
- """Get comprehensive health status"""
- # Run health checks if enough time has passed
- current_time = time.time()
- if current_time - self._last_health_check > 30: # Check every 30 seconds
- await self._health_checker.start_monitoring()
- self._last_health_check = current_time
-
- return self._health_checker.get_health_report()
-
- async def get_performance_metrics(self) -> Dict[str, Any]:
- """Get performance metrics"""
- return {
- 'operation_metrics': dict(self._operation_metrics),
- 'error_summary': self._error_monitor.get_error_summary(),
- 'health_status': await self.get_health_status()
- }
-
- # Context manager support
-
- async def __aenter__(self):
- """Async context manager entry"""
- await self.connect()
- return self
-
- async def __aexit__(self, exc_type, exc_val, exc_tb):
- """Async context manager exit"""
- await self.disconnect()
-
- # Keep-alive and reconnect functionality
-
- def _start_keep_alive_task(self):
- """Start the keep-alive task"""
- if self._ping_task is not None:
- return # Task already running
-
- async def keep_alive():
- """Send periodic ping messages to keep the connection alive"""
- while self._is_persistent:
- try:
- await self._websocket.send_message('42["ps"]')
- logger.debug("Ping sent")
- except Exception as e:
- logger.warning(f"Ping failed: {e}")
- self._is_persistent = False
- break
-
- await asyncio.sleep(10) # Ping interval (10 seconds)
-
- self._ping_task = asyncio.create_task(keep_alive())
- logger.info("Keep-alive task started")
-
- def _stop_keep_alive_task(self):
- """Stop the keep-alive task"""
- if self._ping_task is not None:
- self._ping_task.cancel()
- self._ping_task = None
- logger.info("Keep-alive task stopped")
-
- async def _reconnect(self):
- """Reconnect to the WebSocket"""
- self._stop_keep_alive_task()
-
- try:
- logger.info("Reconnecting to PocketOption...")
- await self.disconnect()
- await asyncio.sleep(2) # Wait before reconnecting
- await self.connect()
- logger.info("Reconnected successfully")
- except Exception as e:
- logger.error(f"Reconnection failed: {e}")
- # Schedule next reconnect attempt
- await asyncio.sleep(5)
- await self._reconnect()
-
- async def _handle_disconnection(self):
- """Handle disconnection and attempt to reconnect if enabled"""
- logger.warning("WebSocket disconnected")
- await self._emit_event('disconnected', {})
-
- if self.auto_reconnect:
- logger.info("Auto-reconnect enabled, attempting to reconnect...")
- await self._reconnect()
diff --git a/pocketoptionapi_async/constants.py b/pocketoptionapi_async/constants.py
index 3c4892d..488d593 100644
--- a/pocketoptionapi_async/constants.py
+++ b/pocketoptionapi_async/constants.py
@@ -168,8 +168,7 @@ class Regions:
"FINLAND": "wss://api-fin.po.market/socket.io/?EIO=4&transport=websocket",
"SERVER3": "wss://api-c.po.market/socket.io/?EIO=4&transport=websocket",
"ASIA": "wss://api-asia.po.market/socket.io/?EIO=4&transport=websocket",
- "SERVER4": "wss://api-us-south.po.market/socket.io/?EIO=4&transport=websocket"
- }
+ "SERVER4": "wss://api-us-south.po.market/socket.io/?EIO=4&transport=websocket" }
@classmethod
def get_all(cls, randomize: bool = True) -> List[str]:
@@ -179,6 +178,11 @@ def get_all(cls, randomize: bool = True) -> List[str]:
random.shuffle(urls)
return urls
+ @classmethod
+ def get_all_regions(cls) -> Dict[str, str]:
+ """Get all regions as a dictionary"""
+ return cls._REGIONS.copy()
+
@classmethod
def get_region(cls, region_name: str) -> str:
"""Get specific region URL"""
@@ -218,7 +222,7 @@ def get_demo_regions(cls) -> List[str]:
API_LIMITS = {
'min_order_amount': 1.0,
'max_order_amount': 50000.0,
- 'min_duration': 60, # seconds
+ 'min_duration': 5, # seconds
'max_duration': 43200, # 12 hours in seconds
'max_concurrent_orders': 10,
'rate_limit': 100, # requests per minute
diff --git a/pocketoptionapi_async/models.py b/pocketoptionapi_async/models.py
index c1346f4..6634137 100644
--- a/pocketoptionapi_async/models.py
+++ b/pocketoptionapi_async/models.py
@@ -89,8 +89,8 @@ def amount_must_be_positive(cls, v):
@validator('duration')
def duration_must_be_valid(cls, v):
- if v < 60: # minimum 60 seconds
- raise ValueError('Duration must be at least 60 seconds')
+ if v < 5: # minimum 5 seconds
+ raise ValueError('Duration must be at least 5 seconds')
return v
class OrderResult(BaseModel):
diff --git a/pocketoptionapi_async/websocket_client.py b/pocketoptionapi_async/websocket_client.py
index b8e8667..83e1421 100644
--- a/pocketoptionapi_async/websocket_client.py
+++ b/pocketoptionapi_async/websocket_client.py
@@ -174,8 +174,7 @@ async def connect(self, urls: List[str], ssid: str) -> bool:
),
timeout=10.0
)
-
- # Update connection info
+ # Update connection info
region = self._extract_region_from_url(url)
self.connection_info = ConnectionInfo(
url=url,
@@ -186,14 +185,13 @@ async def connect(self, urls: List[str], ssid: str) -> bool:
)
logger.info(f"Connected to {region} region successfully")
-
- # Start message handling
+ # Start message handling
self._running = True
- # Send initial handshake
+ # Send initial handshake and wait for completion
await self._send_handshake(ssid)
- # Start background tasks
+ # Start background tasks after handshake is complete
await self._start_background_tasks()
self._reconnect_attempts = 0
@@ -344,27 +342,50 @@ def remove_event_handler(self, event: str, handler: Callable) -> None:
if event in self._event_handlers:
try:
self._event_handlers[event].remove(handler)
- except ValueError:
- pass
+ except ValueError: pass
async def _send_handshake(self, ssid: str) -> None:
- """Send initial handshake messages"""
- # Wait for initial connection message
- await asyncio.sleep(0.5)
-
- # Send handshake sequence
- await self.send_message("40")
- await asyncio.sleep(0.1)
- await self.send_message(ssid)
-
- logger.debug("Handshake completed")
-
+ """Send initial handshake messages (following old API pattern exactly)"""
+ try:
+ # Wait for initial connection message with "0" and "sid" (like old API)
+ logger.debug("Waiting for initial handshake message...")
+ initial_message = await asyncio.wait_for(self.websocket.recv(), timeout=10.0)
+ logger.debug(f"Received initial: {initial_message}")
+
+ # Check if it's the expected initial message format
+ if initial_message.startswith('0') and 'sid' in initial_message:
+ # Send "40" response (like old API)
+ await self.send_message("40")
+ logger.debug("Sent '40' response")
+
+ # Wait for connection establishment message with "40" and "sid"
+ conn_message = await asyncio.wait_for(self.websocket.recv(), timeout=10.0)
+ logger.debug(f"Received connection: {conn_message}")
+
+ # Check if it's the expected connection message format
+ if conn_message.startswith('40') and 'sid' in conn_message:
+ # Send SSID authentication (like old API)
+ await self.send_message(ssid)
+ logger.debug("Sent SSID authentication")
+ else:
+ logger.warning(f"Unexpected connection message format: {conn_message}")
+ else:
+ logger.warning(f"Unexpected initial message format: {initial_message}")
+
+ logger.debug("Handshake sequence completed")
+
+ except asyncio.TimeoutError:
+ logger.error("Handshake timeout - server didn't respond as expected")
+ raise WebSocketError("Handshake timeout")
+ except Exception as e:
+ logger.error(f"Handshake failed: {e}")
+ raise
async def _start_background_tasks(self) -> None:
"""Start background tasks"""
# Start ping task
self._ping_task = asyncio.create_task(self._ping_loop())
- # Start message receiving task
+ # Start message receiving task (only start it once here)
asyncio.create_task(self.receive_messages())
async def _ping_loop(self) -> None:
@@ -390,15 +411,49 @@ async def _ping_loop(self) -> None:
except Exception as e:
logger.error(f"Ping failed: {e}")
break
-
async def _process_message(self, message) -> None:
"""
- Process incoming WebSocket message
+ Process incoming WebSocket message (following old API pattern exactly)
Args:
message: Raw message from WebSocket (bytes or str)
"""
try:
+ # Handle bytes messages first (like old API) - these contain balance data
+ if isinstance(message, bytes):
+ decoded_message = message.decode('utf-8')
+ try:
+ # Try to parse as JSON (like old API)
+ json_data = json.loads(decoded_message)
+ logger.debug(f"Received JSON bytes message: {json_data}")
+
+ # Handle balance data (like old API)
+ if "balance" in json_data:
+ balance_data = {
+ 'balance': json_data['balance'],
+ 'currency': 'USD', # Default currency
+ 'is_demo': bool(json_data.get('isDemo', 1))
+ }
+ if "uid" in json_data:
+ balance_data['uid'] = json_data['uid']
+
+ logger.info(f"Balance data received: {balance_data}")
+ await self._emit_event('balance_data', balance_data)
+
+ # Handle order data (like old API)
+ elif "requestId" in json_data and json_data["requestId"] == 'buy':
+ await self._emit_event('order_data', json_data)
+
+ # Handle other JSON data
+ else:
+ await self._emit_event('json_data', json_data)
+
+ except json.JSONDecodeError:
+ # If not JSON, treat as regular bytes message
+ logger.debug(f"Non-JSON bytes message: {decoded_message[:100]}...")
+
+ return
+
# Convert bytes to string if needed
if isinstance(message, bytes):
message = message.decode('utf-8')
diff --git a/test.py b/test.py
index b4b4d7f..aaf6398 100644
--- a/test.py
+++ b/test.py
@@ -4,10 +4,45 @@
from pocketoptionapi_async import AsyncPocketOptionClient
import logging
import os
-logging.basicConfig(level=logging.DEBUG,format='%(asctime)s %(message)s')
+import time
dotenv.load_dotenv()
-ssid = (r'42["auth",{"session":"n1p5ah5u8t9438rbunpgrq0hlq","isDemo":1,"uid":72645361,"platform":1,"isFastHistory":true}]') #os.getenv("SSID")
+ssid = (r'42["auth",{"session":"t04ppgptp3404h0lajp4bo7smh","isDemo":1,"uid":101884312,"platform":2,"isFastHistory":true}]') #os.getenv("SSID")
print(ssid)
api = AsyncPocketOptionClient(ssid=ssid, is_demo=True)
+async def main():
+ await api.connect()
+
+ await asyncio.sleep(5) # Wait for connection to establish
+
+ balance = await api.get_balance()
+ print(f"Balance: {balance}")
+
+ # order_Data = await api.place_order(
+ # asset="EURUSD_otc",
+ # amount=1,
+ # direction="call",
+ # duration=5
+ # )
+ # print(f"OrderData: {order_Data}")
+ # order_info = await api.check_order_result(order_Data.order_id)
+ # print(f"OrderInfo: {order_info}")
+
+ candles = await api.get_candles(
+ asset="EURUSD_otc",
+ timeframe=5,
+ count=100
+ )
+ print(candles)
+
+if __name__ == "__main__":
+ import asyncio
+ try:
+ asyncio.run(main())
+ except KeyboardInterrupt:
+ print("Exiting...")
+ except Exception as e:
+ print(f"An error occurred: {e}")
+ finally:
+ print("Closing connection...")
\ No newline at end of file
diff --git a/test_balance_fix.py b/test_balance_fix.py
new file mode 100644
index 0000000..b7bb8c1
--- /dev/null
+++ b/test_balance_fix.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the balance issue fix
+"""
+
+import asyncio
+import os
+from loguru import logger
+
+# Mock test SSID for demonstration
+complete_ssid = r'42["auth",{"session":"n1p5ah5u8t9438rbunpgrq0hlq","isDemo":1,"uid":72645361,"platform":1,"isFastHistory":true}]'
+
+async def test_balance_fix():
+ """Test the balance fix with the new async API"""
+
+ logger.info("๐งช Testing Balance Fix")
+ logger.info("=" * 50)
+
+ # Import here to avoid import issues during file changes
+ try:
+ from pocketoptionapi_async import AsyncPocketOptionClient
+
+ # Create client
+ client = AsyncPocketOptionClient(ssid=complete_ssid, is_demo=True)
+
+ # Add balance event callback to test
+ balance_received = False
+
+ def on_balance_updated(balance):
+ nonlocal balance_received
+ balance_received = True
+ logger.success(f"โ
Balance callback triggered: ${balance.balance:.2f}")
+
+ client.add_event_callback('balance_updated', on_balance_updated)
+
+ # Test connection and balance retrieval
+ try:
+ await client.connect()
+
+ if client.is_connected:
+ logger.info("โ
Connected successfully")
+
+ # Try to get balance
+ try:
+ balance = await client.get_balance()
+ if balance:
+ logger.success(f"โ
Balance retrieved successfully: ${balance.balance:.2f}")
+ logger.info(f" Currency: {balance.currency}")
+ logger.info(f" Demo: {balance.is_demo}")
+ logger.info(f" Last updated: {balance.last_updated}")
+ else:
+ logger.error("โ Balance is None - issue still exists")
+
+ except Exception as e:
+ logger.error(f"โ Balance retrieval failed: {e}")
+
+ # Wait for balance events
+ logger.info("โณ Waiting for balance events...")
+ await asyncio.sleep(5)
+
+ if balance_received:
+ logger.success("โ
Balance event received successfully!")
+ else:
+ logger.warning("โ ๏ธ No balance event received")
+
+ else:
+ logger.warning("โ ๏ธ Connection failed (expected with test SSID)")
+
+ except Exception as e:
+ logger.info(f"โน๏ธ Connection test: {e}")
+
+ finally:
+ await client.disconnect()
+
+ except Exception as e:
+ logger.error(f"โ Test failed: {e}")
+ return False
+
+ logger.info("=" * 50)
+ logger.success("โ
Balance fix test completed!")
+ return True
+
+if __name__ == "__main__":
+ # Configure logging
+ logger.remove()
+ logger.add(
+ lambda msg: print(msg, end=""),
+ format="{time:HH:mm:ss} | {level} | {message}",
+ level="INFO"
+ )
+
+ asyncio.run(test_balance_fix())
diff --git a/test_candles_fix.py b/test_candles_fix.py
new file mode 100644
index 0000000..0581bb7
--- /dev/null
+++ b/test_candles_fix.py
@@ -0,0 +1,162 @@
+"""
+Test script to verify candles data retrieval functionality
+"""
+
+import asyncio
+import json
+from datetime import datetime, timedelta
+from pocketoptionapi_async import AsyncPocketOptionClient
+
+async def test_candles_retrieval():
+ """Test candles data retrieval with the fixed implementation"""
+
+ # Replace with your actual SSID
+ ssid = "po_session_id=your_session_id_here"
+
+ print("๐งช Testing Candles Data Retrieval")
+ print("=" * 50)
+
+ try:
+ # Create client with logging enabled to see detailed output
+ client = AsyncPocketOptionClient(ssid, is_demo=True, enable_logging=True)
+
+ print("๐ก Connecting to PocketOption...")
+ await client.connect()
+
+ print("\n๐ Requesting candles data...")
+
+ # Test 1: Get recent candles for EURUSD
+ asset = "EURUSD"
+ timeframe = 60 # 1 minute
+ count = 20
+
+ print(f"Asset: {asset}")
+ print(f"Timeframe: {timeframe}s (1 minute)")
+ print(f"Count: {count}")
+
+ candles = await client.get_candles(asset, timeframe, count)
+
+ if candles:
+ print(f"\nโ
Successfully retrieved {len(candles)} candles!")
+
+ # Display first few candles
+ print("\n๐ Sample candle data:")
+ for i, candle in enumerate(candles[:5]):
+ print(f" {i+1}. {candle.timestamp.strftime('%H:%M:%S')} - "
+ f"O:{candle.open:.5f} H:{candle.high:.5f} L:{candle.low:.5f} C:{candle.close:.5f}")
+
+ if len(candles) > 5:
+ print(f" ... and {len(candles) - 5} more candles")
+
+ else:
+ print("โ No candles received - this may indicate an issue")
+
+ # Test 2: Get candles as DataFrame
+ print("\n๐ Testing DataFrame conversion...")
+ try:
+ df = await client.get_candles_dataframe(asset, timeframe, count)
+ if not df.empty:
+ print(f"โ
DataFrame created with {len(df)} rows")
+ print(f"Columns: {list(df.columns)}")
+ print(f"Date range: {df.index[0]} to {df.index[-1]}")
+ else:
+ print("โ Empty DataFrame received")
+ except Exception as e:
+ print(f"โ DataFrame test failed: {e}")
+
+ # Test 3: Different timeframes
+ print("\nโฑ๏ธ Testing different timeframes...")
+ timeframes_to_test = [
+ (60, "1 minute"),
+ (300, "5 minutes"),
+ (900, "15 minutes")
+ ]
+
+ for tf_seconds, tf_name in timeframes_to_test:
+ try:
+ test_candles = await client.get_candles(asset, tf_seconds, 5)
+ if test_candles:
+ print(f"โ
{tf_name}: {len(test_candles)} candles")
+ else:
+ print(f"โ {tf_name}: No data")
+ except Exception as e:
+ print(f"โ {tf_name}: Error - {e}")
+
+ print("\n๐ Testing different assets...")
+ assets_to_test = ["EURUSD", "GBPUSD", "USDJPY"]
+
+ for test_asset in assets_to_test:
+ try:
+ test_candles = await client.get_candles(test_asset, 60, 3)
+ if test_candles:
+ latest = test_candles[-1] if test_candles else None
+ print(f"โ
{test_asset}: Latest price {latest.close:.5f}" if latest else f"โ
{test_asset}: {len(test_candles)} candles")
+ else:
+ print(f"โ {test_asset}: No data")
+ except Exception as e:
+ print(f"โ {test_asset}: Error - {e}")
+
+ except Exception as e:
+ print(f"โ Test failed with error: {e}")
+ import traceback
+ traceback.print_exc()
+
+ finally:
+ try:
+ await client.disconnect()
+ print("\n๐ Disconnected from PocketOption")
+ except:
+ pass
+
+async def test_candles_message_format():
+ """Test the message format being sent"""
+
+ print("\n๐ Testing Message Format")
+ print("=" * 30)
+
+ # Simulate the message creation
+ asset = "EURUSD"
+ timeframe = 60
+ count = 10
+ end_time = datetime.now()
+ end_timestamp = int(end_time.timestamp())
+
+ # Create message data in the format expected by PocketOption
+ data = {
+ "asset": str(asset),
+ "index": end_timestamp,
+ "offset": count,
+ "period": timeframe,
+ "time": end_timestamp
+ }
+
+ # Create the full message
+ message_data = ["loadHistoryPeriod", data]
+ message = f'42["sendMessage",{json.dumps(message_data)}]'
+
+ print(f"Asset: {asset}")
+ print(f"Timeframe: {timeframe}s")
+ print(f"Count: {count}")
+ print(f"End time: {end_time.strftime('%Y-%m-%d %H:%M:%S')}")
+ print(f"Timestamp: {end_timestamp}")
+ print(f"\nGenerated message:")
+ print(message)
+ print(f"\nMessage data structure:")
+ print(json.dumps(message_data, indent=2))
+
+if __name__ == "__main__":
+ print("๐งช PocketOption Candles Test Suite")
+ print("=" * 40)
+
+ # Test message format first
+ asyncio.run(test_candles_message_format())
+
+ # Then test actual retrieval (requires valid SSID)
+ print("\n" + "=" * 40)
+ print("โ ๏ธ To test actual candles retrieval:")
+ print("1. Replace 'your_session_id_here' with your actual SSID")
+ print("2. Uncomment the line below")
+ print("=" * 40)
+
+ # Uncomment this line after adding your SSID:
+ # asyncio.run(test_candles_retrieval())
diff --git a/test_complete_order_tracking.py b/test_complete_order_tracking.py
new file mode 100644
index 0000000..468dca1
--- /dev/null
+++ b/test_complete_order_tracking.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+Complete Order Tracking Test
+Tests the full order lifecycle including waiting for trade completion and profit/loss tracking
+"""
+
+import asyncio
+import os
+import time
+from datetime import datetime, timedelta
+from loguru import logger
+
+from pocketoptionapi_async import AsyncPocketOptionClient, OrderDirection
+
+
+async def wait_for_trade_completion():
+ """Test complete order lifecycle with profit tracking"""
+
+ # Get SSID from environment
+ ssid = os.getenv("POCKET_OPTION_SSID")
+
+ if not ssid:
+ print("โ Please set POCKET_OPTION_SSID environment variable")
+ print("Example: set POCKET_OPTION_SSID='your_session_id_here'")
+ return
+
+ print("๐ Complete Order Tracking Test")
+ print("=" * 50)
+
+ # Create client
+ client = AsyncPocketOptionClient(ssid, is_demo=True)
+
+ try:
+ # Connect
+ print("๐ก Connecting...")
+ await client.connect()
+
+ if not client.is_connected:
+ print("โ Failed to connect")
+ return
+
+ print("โ
Connected successfully")
+
+ # Wait for initialization
+ await asyncio.sleep(3)
+
+ # Get balance
+ balance = await client.get_balance()
+ if balance:
+ print(f"๐ฐ Balance: ${balance.balance:.2f} (Demo: {balance.is_demo})")
+ else:
+ print("โ ๏ธ No balance received")
+
+ # Add event callback to monitor order completion
+ completed_orders = []
+
+ def on_order_closed(order_result):
+ completed_orders.append(order_result)
+ status = "WIN" if order_result.profit > 0 else "LOSE" if order_result.profit < 0 else "EVEN"
+ print(f"๐ฏ Order completed: {status} - Profit: ${order_result.profit:.2f}")
+
+ client.add_event_callback('order_closed', on_order_closed)
+
+ # Place a test order with shorter duration for faster results
+ print(f"\n๐ Placing test order...")
+ order_result = await client.place_order(
+ asset="EURUSD_otc",
+ amount=1.0,
+ direction=OrderDirection.CALL,
+ duration=60 # 1 minute for quick testing
+ )
+
+ print(f"โ
Order placed: {order_result.order_id}")
+ print(f" Status: {order_result.status}")
+ print(f" Asset: {order_result.asset}")
+ print(f" Amount: ${order_result.amount}")
+ print(f" Direction: {order_result.direction}")
+ print(f" Duration: {order_result.duration}s")
+ print(f" Expires at: {order_result.expires_at.strftime('%H:%M:%S')}")
+
+ # Check immediate order result
+ immediate_result = await client.check_order_result(order_result.order_id)
+ if immediate_result:
+ print(f"โ
Order immediately found in tracking system")
+ else:
+ print("โ Order NOT found in tracking system - this is a problem!")
+ return
+
+ # Wait for the trade to complete
+ print(f"\nโฑ๏ธ Waiting for trade to complete (up to {order_result.duration + 30} seconds)...")
+ start_time = datetime.now()
+ max_wait = timedelta(seconds=order_result.duration + 30) # Trade duration + 30 seconds buffer
+
+ last_status = None
+
+ while datetime.now() - start_time < max_wait:
+ result = await client.check_order_result(order_result.order_id)
+
+ if result:
+ # Only print status changes to avoid spam
+ if result.status != last_status:
+ status_emoji = "๐ข" if result.status == "active" else "๐ด" if result.status in ["win", "lose"] else "๐ก"
+ print(f" {status_emoji} Order status: {result.status}")
+ last_status = result.status
+
+ # Check if order completed
+ if result.profit is not None:
+ win_lose = "WIN" if result.profit > 0 else "LOSE" if result.profit < 0 else "EVEN"
+ print(f"\n๐ฏ TRADE COMPLETED!")
+ print(f" Result: {win_lose}")
+ print(f" Profit/Loss: ${result.profit:.2f}")
+ if result.payout:
+ print(f" Payout: ${result.payout:.2f}")
+
+ # Calculate percentage return
+ if result.profit != 0:
+ percentage = (result.profit / order_result.amount) * 100
+ print(f" Return: {percentage:.1f}%")
+
+ break
+
+ # Check if status indicates completion but no profit yet
+ elif result.status in ["win", "lose", "closed"]:
+ print(f" ๐ Order marked as {result.status} but no profit data yet...")
+
+ else:
+ print(" โ Order disappeared from tracking system")
+ break
+
+ await asyncio.sleep(2) # Check every 2 seconds
+
+ # Check if we completed via event callback
+ if completed_orders:
+ print(f"\nโ
Order completion detected via event callback!")
+ final_order = completed_orders[0]
+ print(f" Final profit: ${final_order.profit:.2f}")
+
+ # Final status check
+ final_result = await client.check_order_result(order_result.order_id)
+ if final_result:
+ print(f"\n๐ Final status:")
+ print(f" Order ID: {final_result.order_id}")
+ print(f" Status: {final_result.status}")
+ if final_result.profit is not None:
+ print(f" Final Profit/Loss: ${final_result.profit:.2f}")
+ else:
+ print(f" โ ๏ธ No profit data available (may indicate tracking issue)")
+ else:
+ print(f"\nโ Could not find final order result")
+
+ # Show active orders count
+ active_orders = await client.get_active_orders()
+ print(f"\n๐ Active orders remaining: {len(active_orders)}")
+
+ except Exception as e:
+ print(f"โ Error: {e}")
+ import traceback
+ traceback.print_exc()
+
+ finally:
+ # Disconnect
+ print(f"\n๐ Disconnecting...")
+ await client.disconnect()
+ print("โ
Test completed")
+
+
+if __name__ == "__main__":
+ # Configure logging to be less verbose
+ logger.remove()
+ logger.add(
+ lambda msg: print(msg, end=""),
+ format="{level} | {message}",
+ level="WARNING" # Only show warnings and errors from the library
+ )
+
+ asyncio.run(wait_for_trade_completion())
diff --git a/test_demo_live_connection.py b/test_demo_live_connection.py
new file mode 100644
index 0000000..4ebe9c3
--- /dev/null
+++ b/test_demo_live_connection.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the demo/live connection fix
+"""
+
+import asyncio
+from pocketoptionapi_async import AsyncPocketOptionClient
+
+async def test_demo_live_connection():
+ """Test that demo/live connections go to correct regions"""
+
+ # Test SSID with demo=1 hardcoded (should be overridden by is_demo parameter)
+ demo_ssid = r'42["auth",{"session":"n1p5ah5u8t9438rbunpgrq0hlq","isDemo":1,"uid":72645361,"platform":1,"isFastHistory":true}]'
+
+ print("๐ Testing Demo/Live Connection Fix")
+ print("=" * 50)
+
+ # Test 1: Demo mode connection (should connect to demo regions)
+ print("\n1๏ธโฃ Test: Demo mode connection (is_demo=True)")
+ client_demo = AsyncPocketOptionClient(ssid=demo_ssid, is_demo=True)
+
+ print(f" Client is_demo: {client_demo.is_demo}")
+ print(f" Attempting connection to demo regions...")
+
+ try:
+ success = await asyncio.wait_for(client_demo.connect(), timeout=30)
+
+ if success:
+ print(f" โ
Connected successfully!")
+ if hasattr(client_demo, 'connection_info') and client_demo.connection_info:
+ print(f" ๐ Connected to: {client_demo.connection_info.region}")
+ await client_demo.disconnect()
+ else:
+ print(f" โ Connection failed")
+
+ except asyncio.TimeoutError:
+ print(f" โฐ Connection timeout (expected with test credentials)")
+ except Exception as e:
+ print(f" โ ๏ธ Connection error: {e}")
+
+ # Test 2: Live mode connection (should try non-demo regions)
+ print("\n2๏ธโฃ Test: Live mode connection (is_demo=False)")
+ client_live = AsyncPocketOptionClient(ssid=demo_ssid, is_demo=False)
+
+ print(f" Client is_demo: {client_live.is_demo}")
+ print(f" Attempting connection to live regions...")
+
+ try:
+ success = await asyncio.wait_for(client_live.connect(), timeout=30)
+
+ if success:
+ print(f" โ
Connected successfully!")
+ if hasattr(client_live, 'connection_info') and client_live.connection_info:
+ print(f" ๐ Connected to: {client_live.connection_info.region}")
+ await client_live.disconnect()
+ else:
+ print(f" โ Connection failed")
+
+ except asyncio.TimeoutError:
+ print(f" โฐ Connection timeout (expected with test credentials)")
+ except Exception as e:
+ print(f" โ ๏ธ Connection error: {e}")
+
+ print("\n" + "=" * 50)
+ print("โ
Demo/Live Connection Test Complete!")
+ print("\nKey improvements:")
+ print("โข โ
is_demo parameter now properly overrides SSID values")
+ print("โข โ
Demo mode connects only to demo regions")
+ print("โข โ
Live mode excludes demo regions")
+ print("โข โ
Authentication messages use correct isDemo values")
+
+if __name__ == "__main__":
+ asyncio.run(test_demo_live_connection())
diff --git a/test_demo_live_fix.py b/test_demo_live_fix.py
new file mode 100644
index 0000000..47afb5c
--- /dev/null
+++ b/test_demo_live_fix.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the demo/live mode fix
+"""
+
+import asyncio
+import json
+from pocketoptionapi_async import AsyncPocketOptionClient
+
+async def test_demo_live_fix():
+ """Test that is_demo parameter is properly respected"""
+
+ # Test SSID with demo=1 hardcoded (should be overridden by is_demo parameter)
+ demo_ssid = r'42["auth",{"session":"n1p5ah5u8t9438rbunpgrq0hlq","isDemo":1,"uid":72645361,"platform":1,"isFastHistory":true}]'
+
+ print("๐งช Testing Demo/Live Mode Fix")
+ print("=" * 50)
+
+ # Test 1: Demo mode with demo SSID (should work)
+ print("\n1๏ธโฃ Test: is_demo=True with demo SSID")
+ client_demo = AsyncPocketOptionClient(ssid=demo_ssid, is_demo=True)
+ formatted_demo = client_demo._format_session_message()
+ parsed_demo = json.loads(formatted_demo[10:-1]) # Extract JSON part
+
+ print(f" SSID isDemo value: {json.loads(demo_ssid[10:-1])['isDemo']}")
+ print(f" Constructor is_demo: True")
+ print(f" Client is_demo: {client_demo.is_demo}")
+ print(f" Formatted message isDemo: {parsed_demo['isDemo']}")
+ print(f" โ
Expected: 1, Got: {parsed_demo['isDemo']}")
+
+ # Test 2: Live mode with demo SSID (should override to live)
+ print("\n2๏ธโฃ Test: is_demo=False with demo SSID")
+ client_live = AsyncPocketOptionClient(ssid=demo_ssid, is_demo=False)
+ formatted_live = client_live._format_session_message()
+ parsed_live = json.loads(formatted_live[10:-1]) # Extract JSON part
+
+ print(f" SSID isDemo value: {json.loads(demo_ssid[10:-1])['isDemo']}")
+ print(f" Constructor is_demo: False")
+ print(f" Client is_demo: {client_live.is_demo}")
+ print(f" Formatted message isDemo: {parsed_live['isDemo']}")
+ print(f" โ
Expected: 0, Got: {parsed_live['isDemo']}")
+
+ # Test 3: Raw session ID with demo mode
+ print("\n3๏ธโฃ Test: Raw session with is_demo=True")
+ raw_session = "n1p5ah5u8t9438rbunpgrq0hlq"
+ client_raw_demo = AsyncPocketOptionClient(ssid=raw_session, is_demo=True, uid=72645361)
+ formatted_raw_demo = client_raw_demo._format_session_message()
+ parsed_raw_demo = json.loads(formatted_raw_demo[10:-1])
+
+ print(f" Constructor is_demo: True")
+ print(f" Client is_demo: {client_raw_demo.is_demo}")
+ print(f" Formatted message isDemo: {parsed_raw_demo['isDemo']}")
+ print(f" โ
Expected: 1, Got: {parsed_raw_demo['isDemo']}")
+
+ # Test 4: Raw session ID with live mode
+ print("\n4๏ธโฃ Test: Raw session with is_demo=False")
+ client_raw_live = AsyncPocketOptionClient(ssid=raw_session, is_demo=False, uid=72645361)
+ formatted_raw_live = client_raw_live._format_session_message()
+ parsed_raw_live = json.loads(formatted_raw_live[10:-1])
+
+ print(f" Constructor is_demo: False")
+ print(f" Client is_demo: {client_raw_live.is_demo}")
+ print(f" Formatted message isDemo: {parsed_raw_live['isDemo']}")
+ print(f" โ
Expected: 0, Got: {parsed_raw_live['isDemo']}")
+
+ # Test 5: Region selection based on demo mode
+ print("\n5๏ธโฃ Test: Region selection logic")
+
+ # Import regions to check the logic
+ from pocketoptionapi_async.constants import REGIONS
+ all_regions = REGIONS.get_all_regions()
+ demo_regions = REGIONS.get_demo_regions()
+
+ print(f" Total regions: {len(all_regions)}")
+ print(f" Demo regions: {len(demo_regions)}")
+
+ # Check demo client region selection
+ print(f"\n Demo client (is_demo=True):")
+ demo_region_names = [name for name, url in all_regions.items() if url in demo_regions]
+ print(f" Should use demo regions: {demo_region_names}")
+
+ # Check live client region selection
+ print(f"\n Live client (is_demo=False):")
+ live_region_names = [name for name, url in all_regions.items() if "DEMO" not in name.upper()]
+ print(f" Should use non-demo regions: {live_region_names}")
+
+ print("\n" + "=" * 50)
+ print("โ
Demo/Live Mode Fix Test Complete!")
+
+ # Verify all tests passed
+ demo_test_pass = parsed_demo['isDemo'] == 1
+ live_test_pass = parsed_live['isDemo'] == 0
+ raw_demo_test_pass = parsed_raw_demo['isDemo'] == 1
+ raw_live_test_pass = parsed_raw_live['isDemo'] == 0
+
+ if all([demo_test_pass, live_test_pass, raw_demo_test_pass, raw_live_test_pass]):
+ print("๐ ALL TESTS PASSED! is_demo parameter is now properly respected!")
+ else:
+ print("โ Some tests failed. The fix needs adjustment.")
+
+ return all([demo_test_pass, live_test_pass, raw_demo_test_pass, raw_live_test_pass])
+
+if __name__ == "__main__":
+ asyncio.run(test_demo_live_fix())
diff --git a/test_fixed_connection.py b/test_fixed_connection.py
new file mode 100644
index 0000000..b92c5d8
--- /dev/null
+++ b/test_fixed_connection.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the fixed connection issue in the new async API
+"""
+
+import asyncio
+import sys
+from loguru import logger
+from pocketoptionapi_async import AsyncPocketOptionClient
+
+# Configure logging
+logger.remove()
+logger.add(sys.stdout, format="{time:HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}")
+
+async def test_connection_fix():
+ """Test the fixed connection with proper handshake sequence"""
+
+ print("๐ง Testing Fixed Connection Issue")
+ print("=" * 60)
+
+ # Test with complete SSID format (like from browser)
+ complete_ssid = r'42["auth",{"session":"test_session_12345","isDemo":1,"uid":12345,"platform":1,"isFastHistory":true}]'
+
+ print(f"๐ Using complete SSID format:")
+ print(f" {complete_ssid[:50]}...")
+ print()
+
+ try:
+ # Create client
+ client = AsyncPocketOptionClient(
+ ssid=complete_ssid,
+ is_demo=True,
+ persistent_connection=False, # Use regular connection for testing
+ auto_reconnect=True
+ )
+
+ print("โ
Client created successfully")
+ print(f"๐ Session ID: {client.session_id}")
+ print(f"๐ค UID: {client.uid}")
+ print(f"๐ฏ Demo mode: {client.is_demo}")
+ print(f"๐ท๏ธ Platform: {client.platform}")
+ print()
+
+ # Test connection
+ print("๐ Testing connection with improved handshake...")
+ try:
+ success = await client.connect()
+
+ if success:
+ print("โ
CONNECTION SUCCESSFUL!")
+ print(f"๐ Connection info: {client.connection_info}")
+ print(f"๐ Connected to: {client.connection_info.region if client.connection_info else 'Unknown'}")
+
+ # Test basic functionality
+ print("\n๐ Testing basic functionality...")
+ try:
+ balance = await client.get_balance()
+ if balance:
+ print(f"๐ฐ Balance: ${balance.balance}")
+ else:
+ print("โ ๏ธ No balance data received (expected with test SSID)")
+ except Exception as e:
+ print(f"โน๏ธ Balance request failed (expected): {e}")
+
+ print("\nโ
All connection tests passed!")
+
+ else:
+ print("โ Connection failed")
+
+ except Exception as e:
+ # This is expected with test SSID, but we should see proper handshake messages
+ print(f"โน๏ธ Connection attempt result: {str(e)[:100]}...")
+ if "handshake" in str(e).lower() or "authentication" in str(e).lower():
+ print("โ
Handshake sequence is working (authentication failed as expected with test SSID)")
+ else:
+ print("โ Unexpected connection error")
+
+ finally:
+ await client.disconnect()
+ print("๐ Disconnected")
+
+ except Exception as e:
+ print(f"โ Test error: {e}")
+ return False
+
+ return True
+
+async def test_old_vs_new_comparison():
+ """Compare the handshake behavior with old API patterns"""
+
+ print("\n" + "=" * 60)
+ print("๐ Connection Pattern Comparison")
+ print("=" * 60)
+
+ print("๐ OLD API Handshake Pattern:")
+ print(" 1. Server sends: 0{\"sid\":\"...\"}")
+ print(" 2. Client sends: 40")
+ print(" 3. Server sends: 40{\"sid\":\"...\"}")
+ print(" 4. Client sends: SSID message")
+ print(" 5. Server sends: 451-[\"successauth\",...]")
+ print()
+
+ print("๐ NEW API Handshake Pattern (FIXED):")
+ print(" 1. โ
Wait for server message with '0' and 'sid'")
+ print(" 2. โ
Send '40' response")
+ print(" 3. โ
Wait for server message with '40' and 'sid'")
+ print(" 4. โ
Send SSID authentication")
+ print(" 5. โ
Wait for authentication response")
+ print()
+
+ print("๐ง Key Fixes Applied:")
+ print(" โ
Proper message sequence waiting (like old API)")
+ print(" โ
Handshake completion before background tasks")
+ print(" โ
Authentication event handling")
+ print(" โ
Timeout handling for server responses")
+ print()
+
+async def main():
+ """Main test function"""
+
+ print("๐งช Testing Fixed Async API Connection")
+ print("๐ฏ Goal: Verify connection works like old API")
+ print()
+
+ # Test the fixed connection
+ success = await test_connection_fix()
+
+ # Show comparison
+ await test_old_vs_new_comparison()
+
+ print("=" * 60)
+ if success:
+ print("โ
CONNECTION FIX VERIFICATION COMPLETE")
+ print("๐ The new async API now follows the same handshake pattern as the old API")
+ print("๐ง Key improvements:")
+ print(" โข Proper server response waiting")
+ print(" โข Sequential handshake messages")
+ print(" โข Authentication event handling")
+ print(" โข Error handling with timeouts")
+ else:
+ print("โ CONNECTION FIX NEEDS MORE WORK")
+ print("=" * 60)
+
+if __name__ == "__main__":
+ asyncio.run(main())
diff --git a/test_order_fix.py b/test_order_fix.py
new file mode 100644
index 0000000..cca6a0f
--- /dev/null
+++ b/test_order_fix.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the place_order fix
+"""
+
+import asyncio
+from loguru import logger
+from pocketoptionapi_async import AsyncPocketOptionClient, OrderDirection
+
+async def test_order_placement():
+ """Test placing an order to verify the fix"""
+
+ ssid = r'42["auth",{"session":"n1p5ah5u8t9438rbunpgrq0hlq","isDemo":1,"uid":72645361,"platform":1,"isFastHistory":true}]'
+
+ client = AsyncPocketOptionClient(ssid=ssid, is_demo=True)
+
+ try:
+ logger.info("๐ Connecting to PocketOption...")
+ await client.connect()
+
+ if client.is_connected:
+ logger.success("โ
Connected successfully!")
+
+ # Wait for authentication and balance
+ await asyncio.sleep(3)
+
+ try:
+ balance = await client.get_balance()
+ if balance:
+ logger.info(f"๐ฐ Balance: ${balance.balance:.2f}")
+ else:
+ logger.warning("โ ๏ธ No balance data received")
+ except Exception as e:
+ logger.info(f"โน๏ธ Balance error (expected with demo): {e}")
+
+ # Test placing an order (this should now work without the order_id error)
+ logger.info("๐ Testing order placement...")
+ try:
+ order_result = await client.place_order(
+ asset="EURUSD_otc",
+ amount=1.0,
+ direction=OrderDirection.CALL,
+ duration=60
+ )
+
+ logger.success(f"โ
Order placed successfully!")
+ logger.info(f" Order ID: {order_result.order_id}")
+ logger.info(f" Status: {order_result.status}")
+ logger.info(f" Asset: {order_result.asset}")
+ logger.info(f" Amount: ${order_result.amount}")
+ logger.info(f" Direction: {order_result.direction}")
+
+ except Exception as e:
+ logger.error(f"โ Order placement failed: {e}")
+ # Check if it's the same error as before
+ if "'Order' object has no attribute 'order_id'" in str(e):
+ logger.error("โ The original error is still present!")
+ else:
+ logger.info("โน๏ธ Different error (this is expected with demo connection)")
+ else:
+ logger.warning("โ ๏ธ Connection failed (expected with demo SSID)")
+
+ except Exception as e:
+ logger.error(f"โ Connection error: {e}")
+
+ finally:
+ await client.disconnect()
+ logger.info("๐ Disconnected")
+
+if __name__ == "__main__":
+ logger.info("๐งช Testing Order Placement Fix")
+ logger.info("=" * 50)
+ asyncio.run(test_order_placement())
diff --git a/test_order_logging_fixes.py b/test_order_logging_fixes.py
new file mode 100644
index 0000000..a646417
--- /dev/null
+++ b/test_order_logging_fixes.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+Test Order Tracking and Logging Fixes
+"""
+
+import asyncio
+import os
+from datetime import datetime
+from loguru import logger
+
+from pocketoptionapi_async import AsyncPocketOptionClient, OrderDirection
+
+
+async def test_fixes():
+ """Test that order tracking works correctly and logging can be disabled"""
+
+ # Get SSID from environment or use placeholder
+ ssid = os.getenv("POCKET_OPTION_SSID", "your_session_id_here")
+
+ if ssid == "your_session_id_here":
+ print("โ Please set POCKET_OPTION_SSID environment variable")
+ return
+
+ print("๐งช Testing Order Tracking and Logging Fixes...")
+
+ # Test 1: Client with logging enabled (default)
+ print("\n1๏ธโฃ Test: Client with logging ENABLED")
+ client_with_logs = AsyncPocketOptionClient(ssid, is_demo=True, enable_logging=True)
+
+ try:
+ # Connect
+ print("๐ก Connecting...")
+ await client_with_logs.connect()
+
+ if not client_with_logs.is_connected:
+ print("โ Failed to connect")
+ return
+
+ print("โ
Connected successfully")
+
+ # Wait for initialization
+ await asyncio.sleep(3)
+
+ # Get balance
+ balance = await client_with_logs.get_balance()
+ if balance:
+ print(f"๐ฐ Balance: ${balance.balance:.2f} (Demo: {balance.is_demo})")
+
+ # Place a test order
+ print("\n๐ฏ Placing test order...")
+ order_result = await client_with_logs.place_order(
+ asset="EURUSD_otc",
+ amount=1.0,
+ direction=OrderDirection.CALL,
+ duration=60
+ )
+
+ print(f"๐ Order placed: {order_result.order_id}")
+ print(f" Status: {order_result.status}")
+ print(f" Error Message: {order_result.error_message or 'None'}")
+
+ # Check if order is properly tracked
+ immediate_result = await client_with_logs.check_order_result(order_result.order_id)
+ if immediate_result:
+ print("โ
Order found in tracking system immediately")
+ else:
+ print("โ Order NOT found in tracking")
+
+ # Wait a bit to see if it gets resolved
+ await asyncio.sleep(10)
+
+ # Check again
+ final_result = await client_with_logs.check_order_result(order_result.order_id)
+ if final_result:
+ print(f"๐ Final order status: {final_result.status}")
+ if final_result.profit is not None:
+ print(f"๐ฐ Profit: ${final_result.profit:.2f}")
+
+ finally:
+ await client_with_logs.disconnect()
+
+ print("\n" + "="*50)
+
+ # Test 2: Client with logging disabled
+ print("\n2๏ธโฃ Test: Client with logging DISABLED")
+ client_no_logs = AsyncPocketOptionClient(ssid, is_demo=True, enable_logging=False)
+
+ try:
+ # Connect (should be much quieter)
+ print("๐ก Connecting (quietly)...")
+ await client_no_logs.connect()
+
+ if not client_no_logs.is_connected:
+ print("โ Failed to connect")
+ return
+
+ print("โ
Connected successfully (no logs)")
+
+ # Wait for initialization
+ await asyncio.sleep(3)
+
+ # Get balance
+ balance = await client_no_logs.get_balance()
+ if balance:
+ print(f"๐ฐ Balance: ${balance.balance:.2f} (Demo: {balance.is_demo})")
+
+ # Place a test order (should work silently)
+ print("\n๐ฏ Placing test order (silently)...")
+ order_result = await client_no_logs.place_order(
+ asset="EURUSD_otc",
+ amount=1.0,
+ direction=OrderDirection.CALL,
+ duration=60
+ )
+
+ print(f"๐ Order placed: {order_result.order_id}")
+ print(f" Status: {order_result.status}")
+ print(f" Error Message: {order_result.error_message or 'None'}")
+
+ # Check if order is properly tracked
+ immediate_result = await client_no_logs.check_order_result(order_result.order_id)
+ if immediate_result:
+ print("โ
Order found in tracking system (silent mode)")
+ else:
+ print("โ Order NOT found in tracking")
+
+ finally:
+ await client_no_logs.disconnect()
+
+ print("\nโ
Tests completed!")
+
+
+if __name__ == "__main__":
+ # Configure basic logging for test output
+ logger.remove()
+ logger.add(
+ lambda msg: print(msg, end=""),
+ format="{level} | {message}",
+ level="INFO"
+ )
+
+ asyncio.run(test_fixes())
diff --git a/test_order_placement_fix.py b/test_order_placement_fix.py
new file mode 100644
index 0000000..31109cb
--- /dev/null
+++ b/test_order_placement_fix.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+Test script to verify order placement fix
+"""
+
+import asyncio
+import os
+from datetime import datetime
+from loguru import logger
+
+# Configure logger
+logger.remove()
+logger.add(
+ lambda msg: print(msg, end=""),
+ format="{time:HH:mm:ss} | {level} | {message}",
+ level="INFO"
+)
+
+from pocketoptionapi_async import AsyncPocketOptionClient, OrderDirection
+
+
+async def test_order_placement_fix():
+ """Test the order placement fix"""
+
+ # Get SSID from environment or use a placeholder
+ ssid = os.getenv("POCKET_OPTION_SSID", "placeholder_session_id")
+
+ if ssid == "placeholder_session_id":
+ logger.warning("โ ๏ธ No SSID provided - using placeholder (will fail connection)")
+ logger.info("Set POCKET_OPTION_SSID environment variable for real testing")
+
+ logger.info("๐งช Testing order placement fix...")
+
+ # Create client
+ client = AsyncPocketOptionClient(ssid, is_demo=True)
+
+ try:
+ # Test order creation (this should not fail with the attribute error anymore)
+ logger.info("๐ Testing Order model creation...")
+
+ # This should work now (Order uses request_id)
+ from pocketoptionapi_async.models import Order
+ test_order = Order(
+ asset="EURUSD_otc",
+ amount=1.0,
+ direction=OrderDirection.CALL,
+ duration=60
+ )
+
+ logger.success(f"โ
Order created successfully with request_id: {test_order.request_id}")
+ logger.info(f" Asset: {test_order.asset}")
+ logger.info(f" Amount: {test_order.amount}")
+ logger.info(f" Direction: {test_order.direction}")
+ logger.info(f" Duration: {test_order.duration}")
+
+ # Test that the order doesn't have order_id attribute
+ if not hasattr(test_order, 'order_id'):
+ logger.success("โ
Order correctly uses request_id instead of order_id")
+ else:
+ logger.error("โ Order still has order_id attribute - this should not exist")
+
+ # If we have a real SSID, try connecting and placing an order
+ if ssid != "placeholder_session_id":
+ logger.info("๐ Attempting to connect and place order...")
+
+ await client.connect()
+
+ if client.is_connected:
+ logger.success("โ
Connected successfully")
+
+ # Try to place an order (this should not fail with attribute error)
+ try:
+ order_result = await client.place_order(
+ asset="EURUSD_otc",
+ amount=1.0,
+ direction=OrderDirection.CALL,
+ duration=60
+ )
+
+ logger.success(f"โ
Order placement succeeded: {order_result.order_id}")
+ logger.info(f" Status: {order_result.status}")
+
+ except Exception as e:
+ if "'Order' object has no attribute 'order_id'" in str(e):
+ logger.error("โ The attribute error still exists!")
+ else:
+ logger.warning(f"โ ๏ธ Order placement failed for other reason: {e}")
+ logger.info("This is likely due to connection/authentication issues, not the attribute fix")
+
+ else:
+ logger.warning("โ ๏ธ Could not connect (expected with placeholder SSID)")
+
+ logger.success("๐ Order placement fix test completed!")
+
+ except Exception as e:
+ logger.error(f"โ Test failed: {e}")
+ import traceback
+ traceback.print_exc()
+
+ finally:
+ if client.is_connected:
+ await client.disconnect()
+
+
+if __name__ == "__main__":
+ asyncio.run(test_order_placement_fix())
diff --git a/test_order_tracking_complete.py b/test_order_tracking_complete.py
new file mode 100644
index 0000000..26b3aa8
--- /dev/null
+++ b/test_order_tracking_complete.py
@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+Complete Order Tracking Test - Final Version
+Tests all the fixes made to the order tracking system:
+1. Order placement without duplication
+2. Proper waiting for server responses
+3. Event-driven order completion tracking
+4. Fallback handling for timeouts
+"""
+
+import asyncio
+import os
+import time
+from datetime import datetime, timedelta
+from loguru import logger
+
+from pocketoptionapi_async import AsyncPocketOptionClient, OrderDirection
+
+
+async def test_complete_order_lifecycle():
+ """Test the complete order lifecycle with all fixes"""
+
+ # Get SSID from environment
+ ssid = os.getenv("POCKET_OPTION_SSID")
+
+ if not ssid:
+ print("โ Please set POCKET_OPTION_SSID environment variable")
+ print("Example: set POCKET_OPTION_SSID='your_session_id_here'")
+ return
+
+ print("๐ Complete Order Tracking Test - Final Version")
+ print("=" * 60)
+
+ # Create client
+ client = AsyncPocketOptionClient(ssid, is_demo=True)
+
+ try:
+ # Connect
+ print("๐ก Connecting...")
+ await client.connect()
+
+ if not client.is_connected:
+ print("โ Failed to connect")
+ return
+
+ print("โ
Connected successfully")
+
+ # Wait for initialization
+ await asyncio.sleep(3)
+
+ # Get balance
+ balance = await client.get_balance()
+ if balance:
+ print(f"๐ฐ Balance: ${balance.balance:.2f} (Demo: {balance.is_demo})")
+ else:
+ print("โ ๏ธ No balance received")
+
+ # Test 1: Order Placement (should not create duplicates)
+ print(f"\n๐ TEST 1: Order Placement Without Duplication")
+ print("-" * 50)
+
+ # Check initial active orders count
+ initial_active = await client.get_active_orders()
+ print(f"๐ Initial active orders: {len(initial_active)}")
+
+ # Place order
+ print(f"๐ Placing order...")
+ order_result = await client.place_order(
+ asset="EURUSD_otc",
+ amount=1.0,
+ direction=OrderDirection.CALL,
+ duration=60 # 1 minute
+ )
+
+ print(f"โ
Order placed: {order_result.order_id}")
+ print(f" Status: {order_result.status}")
+ print(f" Asset: {order_result.asset}")
+ print(f" Amount: ${order_result.amount}")
+ print(f" Direction: {order_result.direction}")
+ print(f" Duration: {order_result.duration}s")
+
+ # Test 2: No Duplication Check
+ print(f"\n๐ TEST 2: No Order Duplication Check")
+ print("-" * 50)
+
+ # Check that only one order was created
+ active_orders_after = await client.get_active_orders()
+ added_orders = len(active_orders_after) - len(initial_active)
+
+ if added_orders == 1:
+ print("โ
PASS: Exactly 1 order was created (no duplication)")
+ else:
+ print(f"โ FAIL: {added_orders} orders were created (expected 1)")
+ for order in active_orders_after:
+ print(f" - {order.order_id}: {order.status}")
+
+ # Test 3: Order Tracking
+ print(f"\n๐ TEST 3: Order Tracking and Result Checking")
+ print("-" * 50)
+
+ # Immediate check
+ immediate_result = await client.check_order_result(order_result.order_id)
+ if immediate_result:
+ print("โ
Order immediately found in tracking system")
+ print(f" ID: {immediate_result.order_id}")
+ print(f" Status: {immediate_result.status}")
+ else:
+ print("โ Order NOT found in tracking system - this is a problem!")
+ return
+
+ # Test 4: Event-Based Order Completion Monitoring
+ print(f"\n๐ TEST 4: Event-Based Order Completion")
+ print("-" * 50)
+
+ # Set up event callback to detect completion
+ completed_orders = []
+
+ def on_order_closed(order_result):
+ completed_orders.append(order_result)
+ status = "WIN" if order_result.profit > 0 else "LOSE" if order_result.profit < 0 else "EVEN"
+ print(f"๐ฏ ORDER COMPLETED via EVENT: {status} - Profit: ${order_result.profit:.2f}")
+
+ client.add_event_callback('order_closed', on_order_closed)
+
+ # Test 5: Wait for Trade Completion
+ print(f"\n๐ TEST 5: Waiting for Trade Completion")
+ print("-" * 50)
+
+ print(f"โฑ๏ธ Waiting for trade to complete (up to {order_result.duration + 30} seconds)...")
+ start_time = datetime.now()
+ max_wait = timedelta(seconds=order_result.duration + 30) # Trade duration + buffer
+
+ last_status = None
+
+ while datetime.now() - start_time < max_wait:
+ result = await client.check_order_result(order_result.order_id)
+
+ if result:
+ # Only print status changes to avoid spam
+ if result.status != last_status:
+ status_emoji = "๐ข" if result.status == "active" else "๐ด" if result.status in ["win", "lose"] else "๐ก"
+ print(f" {status_emoji} Order status: {result.status}")
+ last_status = result.status
+
+ # Check if order completed
+ if result.profit is not None:
+ win_lose = "WIN" if result.profit > 0 else "LOSE" if result.profit < 0 else "EVEN"
+ print(f"\n๐ฏ TRADE COMPLETED!")
+ print(f" Result: {win_lose}")
+ print(f" Profit/Loss: ${result.profit:.2f}")
+ if result.payout:
+ print(f" Payout: ${result.payout:.2f}")
+
+ # Calculate percentage return
+ if result.profit != 0:
+ percentage = (result.profit / order_result.amount) * 100
+ print(f" Return: {percentage:.1f}%")
+
+ break
+
+ # Check if status indicates completion but no profit yet
+ elif result.status in ["win", "lose", "closed"]:
+ print(f" ๐ Order marked as {result.status} but no profit data yet...")
+
+ else:
+ print(" โ Order disappeared from tracking system")
+ break
+
+ await asyncio.sleep(2) # Check every 2 seconds
+
+ # Test 6: Event vs Polling Comparison
+ print(f"\n๐ TEST 6: Event vs Polling Results")
+ print("-" * 50)
+
+ # Check if we completed via event callback
+ if completed_orders:
+ print(f"โ
Order completion detected via EVENT callback!")
+ final_order_event = completed_orders[0]
+ print(f" Event Result - Profit: ${final_order_event.profit:.2f}")
+ else:
+ print(f"โ ๏ธ No completion event received")
+
+ # Check final polling result
+ final_result_poll = await client.check_order_result(order_result.order_id)
+ if final_result_poll:
+ print(f"โ
Order completion detected via POLLING!")
+ print(f" Polling Result - Profit: ${final_result_poll.profit:.2f if final_result_poll.profit is not None else 'None'}")
+ else:
+ print(f"โ Order not found via polling")
+
+ # Test 7: Final System State
+ print(f"\n๐ TEST 7: Final System State")
+ print("-" * 50)
+
+ # Check final counts
+ final_active_orders = await client.get_active_orders()
+ print(f"๐ Final active orders: {len(final_active_orders)}")
+
+ for order in final_active_orders:
+ print(f" Active: {order.order_id} - {order.status}")
+
+ # Show test summary
+ print(f"\n๐ TEST SUMMARY")
+ print("=" * 60)
+
+ tests_passed = 0
+ total_tests = 7
+
+ # Test results
+ if added_orders == 1:
+ print("โ
Order Placement (No Duplication): PASS")
+ tests_passed += 1
+ else:
+ print("โ Order Placement (No Duplication): FAIL")
+
+ if immediate_result:
+ print("โ
Order Tracking: PASS")
+ tests_passed += 1
+ else:
+ print("โ Order Tracking: FAIL")
+
+ if completed_orders:
+ print("โ
Event-Based Completion: PASS")
+ tests_passed += 1
+ else:
+ print("โ Event-Based Completion: FAIL")
+
+ if final_result_poll and final_result_poll.profit is not None:
+ print("โ
Polling-Based Completion: PASS")
+ tests_passed += 1
+ else:
+ print("โ Polling-Based Completion: FAIL")
+
+ # Additional checks
+ if len(final_active_orders) < len(active_orders_after):
+ print("โ
Order Movement (Active -> Completed): PASS")
+ tests_passed += 1
+ else:
+ print("โ Order Movement (Active -> Completed): FAIL")
+
+ if balance:
+ print("โ
Balance Retrieval: PASS")
+ tests_passed += 1
+ else:
+ print("โ Balance Retrieval: FAIL")
+
+ print(f"\n๐ฏ OVERALL RESULT: {tests_passed}/{total_tests} tests passed")
+
+ if tests_passed >= 5:
+ print("๐ ORDER TRACKING SYSTEM IS WORKING WELL!")
+ elif tests_passed >= 3:
+ print("โ ๏ธ Order tracking is partially working, some improvements needed")
+ else:
+ print("โ Major issues with order tracking system")
+
+ except Exception as e:
+ print(f"โ Error: {e}")
+ import traceback
+ traceback.print_exc()
+
+ finally:
+ # Disconnect
+ print(f"\n๐ Disconnecting...")
+ await client.disconnect()
+ print("โ
Test completed")
+
+
+if __name__ == "__main__":
+ # Configure logging to be less verbose
+ logger.remove()
+ logger.add(
+ lambda msg: print(msg, end=""),
+ format="{level} | {message}",
+ level="ERROR" # Only show errors from the library to keep output clean
+ )
+
+ asyncio.run(test_complete_order_lifecycle())
diff --git a/test_order_tracking_fix.py b/test_order_tracking_fix.py
new file mode 100644
index 0000000..64e1b5f
--- /dev/null
+++ b/test_order_tracking_fix.py
@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+Test Order Tracking Fix
+Test to verify that order tracking and result checking works properly
+"""
+
+import asyncio
+import os
+from datetime import datetime
+from loguru import logger
+
+from pocketoptionapi_async import AsyncPocketOptionClient, OrderDirection
+
+
+async def test_order_tracking():
+ """Test order tracking functionality"""
+
+ # Get SSID from environment or use placeholder
+ ssid = os.getenv("POCKET_OPTION_SSID", "your_session_id_here")
+
+ if ssid == "your_session_id_here":
+ print("โ Please set POCKET_OPTION_SSID environment variable")
+ return
+
+ print("๐ Testing Order Tracking Fix...")
+
+ # Create client
+ client = AsyncPocketOptionClient(ssid, is_demo=True)
+
+ try:
+ # Connect
+ print("๐ก Connecting...")
+ await client.connect()
+
+ if not client.is_connected:
+ print("โ Failed to connect")
+ return
+
+ print("โ
Connected successfully")
+
+ # Wait for initialization
+ await asyncio.sleep(3)
+
+ # Get balance
+ balance = await client.get_balance()
+ if balance:
+ print(f"๐ฐ Balance: ${balance.balance:.2f} (Demo: {balance.is_demo})")
+ else:
+ print("โ ๏ธ No balance received")
+
+ # Place a test order
+ print("\n๐ฏ Placing test order...")
+ order_result = await client.place_order(
+ asset="EURUSD_otc",
+ amount=1.0,
+ direction=OrderDirection.CALL,
+ duration=60
+ )
+
+ print(f"๐ Order placed: {order_result.order_id}")
+ print(f" Status: {order_result.status}")
+ print(f" Asset: {order_result.asset}")
+ print(f" Amount: ${order_result.amount}")
+ print(f" Direction: {order_result.direction}")
+ print(f" Duration: {order_result.duration}s")
+
+ # Test order result checking - should return the active order immediately
+ print("\n๐ Checking order result immediately...")
+ immediate_result = await client.check_order_result(order_result.order_id)
+
+ if immediate_result:
+ print("โ
Order found in tracking system:")
+ print(f" Order ID: {immediate_result.order_id}")
+ print(f" Status: {immediate_result.status}")
+ print(f" Placed at: {immediate_result.placed_at}")
+ print(f" Expires at: {immediate_result.expires_at}")
+ else:
+ print("โ Order NOT found in tracking system")
+ return
+
+ # Check active orders
+ print("\n๐ Checking active orders...")
+ active_orders = await client.get_active_orders()
+ print(f"Active orders count: {len(active_orders)}")
+
+ for order in active_orders:
+ print(f" - {order.order_id}: {order.status} ({order.asset})")
+
+ # Test tracking over time
+ print("\nโฑ๏ธ Monitoring order for 30 seconds...")
+ start_time = datetime.now()
+
+ while (datetime.now() - start_time).total_seconds() < 30:
+ result = await client.check_order_result(order_result.order_id)
+
+ if result:
+ status_emoji = "๐ข" if result.status == "active" else "๐ด" if result.status in ["win", "lose"] else "๐ก"
+ print(f" {status_emoji} Order {result.order_id}: {result.status}")
+
+ # If order completed, show result
+ if result.profit is not None:
+ win_lose = "WIN" if result.profit > 0 else "LOSE"
+ print(f" ๐ฏ Final result: {win_lose} - Profit: ${result.profit:.2f}")
+ break
+ else:
+ print(" โ Order not found in tracking")
+ break
+
+ await asyncio.sleep(5) # Check every 5 seconds
+
+ # Final status
+ final_result = await client.check_order_result(order_result.order_id)
+ if final_result:
+ print(f"\n๐ Final order status: {final_result.status}")
+ if final_result.profit is not None:
+ print(f"๐ฐ Profit/Loss: ${final_result.profit:.2f}")
+ else:
+ print("๐ฐ Profit/Loss: Not yet determined")
+
+ except Exception as e:
+ print(f"โ Error: {e}")
+ import traceback
+ traceback.print_exc()
+
+ finally:
+ # Disconnect
+ print("\n๐ Disconnecting...")
+ await client.disconnect()
+ print("โ
Test completed")
+
+
+if __name__ == "__main__":
+ # Configure logging
+ logger.remove()
+ logger.add(
+ lambda msg: print(msg, end=""),
+ format="{level} | {message}",
+ level="INFO"
+ )
+
+ asyncio.run(test_order_tracking())