binaryoptionstoolsv2 0.2.14__tar.gz → 0.2.15__tar.gz

{binaryoptionstoolsv2-0.2.14 → binaryoptionstoolsv2-0.2.15}/BinaryOptionsToolsV2/__init__.py

@@ -59,7 +59,16 @@ __all__ = list(
     set(
         __pocket_all__
         + __close_all__
-        + ["tracing", "validator", "PocketOptionAsync", "PocketOption", "CloseOptionAsync", "CloseOption", "RawHandler", "Validator"]
+        + [
+            "tracing",
+            "validator",
+            "PocketOptionAsync",
+            "PocketOption",
+            "CloseOptionAsync",
+            "CloseOption",
+            "RawHandler",
+            "Validator",
+        ]
         + __rust_all__
     )
-)
+)

{binaryoptionstoolsv2-0.2.14 → binaryoptionstoolsv2-0.2.15}/BinaryOptionsToolsV2/closeoption/__init__.py

@@ -10,4 +10,4 @@ __all__ = [
     "SyncRawSubscription",
     "RawHandler",
     "RawHandlerSync",
-]
+]

{binaryoptionstoolsv2-0.2.14 → binaryoptionstoolsv2-0.2.15}/BinaryOptionsToolsV2/closeoption/asynchronous.py

@@ -86,11 +86,11 @@ def sanitize_and_validate_ssid(ssid: str, logger: "Logger") -> str:
     ssid = ssid.strip()
 
     # Try to parse as JSON first
-    if ssid.startswith('{') and ssid.endswith('}'):
+    if ssid.startswith("{") and ssid.endswith("}"):
         try:
             data = json.loads(ssid)
             if isinstance(data, dict):
-                required = ['token', 'sid']
+                required = ["token", "sid"]
                 if all(k in data for k in required):
                     logger.debug("SSID parsed as JSON with token and sid")
                     return ssid
@@ -98,7 +98,7 @@ def sanitize_and_validate_ssid(ssid: str, logger: "Logger") -> str:
             pass
 
     # Try pipe-delimited format: token|sid|demo|public_code|hidden_code
-    parts = ssid.split('|')
+    parts = ssid.split("|")
     if len(parts) >= 3:
         logger.debug(f"SSID parsed as pipe-delimited with {len(parts)} parts")
         return ssid
@@ -111,31 +111,31 @@ def sanitize_and_validate_ssid(ssid: str, logger: "Logger") -> str:
 def parse_ssid(ssid: str) -> Tuple[str, str, bool, str, str]:
     """Parse SSID into token, sid, demo, public_code, hidden_code."""
     # Try JSON first
-    if ssid.startswith('{') and ssid.endswith('}'):
+    if ssid.startswith("{") and ssid.endswith("}"):
         try:
             data = json.loads(ssid)
             if isinstance(data, dict):
-                token = data.get('token', '')
-                sid = data.get('sid', '')
-                demo = data.get('demo', False)
-                public_code = data.get('public_code', '')
-                hidden_code = data.get('hidden_code', '')
+                token = data.get("token", "")
+                sid = data.get("sid", "")
+                demo = data.get("demo", False)
+                public_code = data.get("public_code", "")
+                hidden_code = data.get("hidden_code", "")
                 return token, sid, demo, public_code, hidden_code
         except json.JSONDecodeError:
             pass
 
     # Try pipe-delimited
-    parts = ssid.split('|')
+    parts = ssid.split("|")
     if len(parts) >= 3:
         token = parts[0]
         sid = parts[1]
-        demo = parts[2].lower() in ('true', '1', 'yes', 'demo') if len(parts) > 2 else False
-        public_code = parts[3] if len(parts) > 3 else ''
-        hidden_code = parts[4] if len(parts) > 4 else ''
+        demo = parts[2].lower() in ("true", "1", "yes", "demo") if len(parts) > 2 else False
+        public_code = parts[3] if len(parts) > 3 else ""
+        hidden_code = parts[4] if len(parts) > 4 else ""
         return token, sid, demo, public_code, hidden_code
 
     # Fallback: treat as token only
-    return ssid, '', False, '', ''
+    return ssid, "", False, "", ""
 
 
 # This file contains all the async code for the CloseOption Module
@@ -157,6 +157,11 @@ class CloseOptionAsync:
         self._raw_handler = None
         self._connected = False
 
+    @property
+    def is_connected(self) -> bool:
+        """Whether the connection to CloseOption has been established."""
+        return self._connected
+
     async def __aenter__(self):
         await self.connect()
         return self
@@ -179,7 +184,9 @@ class CloseOptionAsync:
             raise ValueError("SSID must contain token and sid")
 
         if not public_code or not hidden_code:
-            raise ValueError("SSID must contain public_code and hidden_code (format: token|sid|demo|public_code|hidden_code)")
+            raise ValueError(
+                "SSID must contain public_code and hidden_code (format: token|sid|demo|public_code|hidden_code)"
+            )
 
         # Build URL with sid
         if self._url:
@@ -187,8 +194,9 @@ class CloseOptionAsync:
         else:
             ws_url = f"wss://www.closeoption.com:8443/socket.io/?EIO=3&transport=websocket&sid={sid}"
 
+        logger.info("CloseOption: connecting to WebSocket")
         self._client = RawCloseOption(token, sid, public_code, hidden_code, demo, ws_url, self._config.pyconfig)
-        await self._client.connect()
+        logger.info("CloseOption: WebSocket connection established")
         self._connected = True
 
     async def _ensure_connected(self):
@@ -231,6 +239,12 @@ class CloseOptionAsync:
         result = await self._client.get_candles(asset, period, count)
         return json.loads(result)
 
+    async def get_ticks(self, asset: str) -> List[dict]:
+        """Get tick series for an asset."""
+        await self._ensure_connected()
+        result = await self._client.get_ticks(asset)
+        return json.loads(result)
+
     async def get_candles_live(self, asset: str, period: int) -> AsyncGenerator[dict, None]:
         """Get live candle updates."""
         await self._ensure_connected()

{binaryoptionstoolsv2-0.2.14 → binaryoptionstoolsv2-0.2.15}/BinaryOptionsToolsV2/closeoption/synchronous.py

@@ -1,15 +1,14 @@
 import asyncio
-import json
 import threading
 import sys
-import warnings
-from datetime import timedelta
-from typing import Dict, List, Optional, Tuple, Union
+import concurrent.futures
+from typing import List, Optional, Union
 from ..config import Config
 from ..validator import Validator as Validator
 from .asynchronous import CloseOptionAsync as CloseOptionAsync
 
 if sys.version_info < (3, 10):
+
     async def anext(iterator):
         """Polyfill for anext for Python < 3.10"""
         return await iterator.__anext__()
@@ -29,9 +28,7 @@ class SyncSubscription:
 
     def __next__(self):
         if self._loop is not None and self._loop.is_running():
-            future = asyncio.run_coroutine_threadsafe(
-                anext(self.subscription), self._loop
-            )
+            future = asyncio.run_coroutine_threadsafe(anext(self.subscription), self._loop)
             try:
                 return future.result()
             except StopAsyncIteration:
@@ -48,9 +45,7 @@ class SyncCandleLiveIterator:
         return self
 
     def __next__(self):
-        future = asyncio.run_coroutine_threadsafe(
-            self._get_next(), self.loop
-        )
+        future = asyncio.run_coroutine_threadsafe(self._get_next(), self.loop)
         try:
             return future.result()
         except StopAsyncIteration:
@@ -60,7 +55,6 @@ class SyncCandleLiveIterator:
         return await anext(self.async_gen)
 
 
-
 class RawHandlerSync:
     """Synchronous handler for advanced raw WebSocket message operations."""
 
@@ -86,7 +80,7 @@ class RawHandlerSync:
         """Wait for a specific event from the server."""
         return self._run(self._handler.wait_for(event, timeout))
 
-    def subscribe(self, event: str) -> 'SyncRawSubscription':
+    def subscribe(self, event: str) -> "SyncRawSubscription":
         """Subscribe to a specific event type."""
         sub = self._run(self._handler.subscribe(event))
         return SyncRawSubscription(sub)
@@ -120,9 +114,7 @@ class SyncRawSubscription:
 
     def __next__(self):
         if self._loop is not None and self._loop.is_running():
-            future = asyncio.run_coroutine_threadsafe(
-                anext(self.subscription), self._loop
-            )
+            future = asyncio.run_coroutine_threadsafe(anext(self.subscription), self._loop)
             try:
                 return future.result()
             except StopAsyncIteration:
@@ -131,7 +123,14 @@ class SyncRawSubscription:
 
 
 class CloseOption:
-    def __init__(self, ssid: str, url: Optional[str] = None, config: Union[Config, dict, str] = None, **_):
+    def __init__(
+        self,
+        ssid: str,
+        url: Optional[str] = None,
+        config: Union[Config, dict, str] = None,
+        connect_on_init: bool = True,
+        **_,
+    ):
         """
         Initialize CloseOption synchronous client.
 
@@ -139,6 +138,9 @@ class CloseOption:
             ssid: Session ID in format "token|sid|demo|public_code|hidden_code" or JSON
             url: WebSocket URL (optional, defaults to CloseOption)
             config: Configuration object (optional)
+            connect_on_init: Whether to establish the connection eagerly in the
+                constructor (default True). Set to False to inspect the client
+                API without connecting (e.g. offline demo mode).
         """
         self._ssid = ssid
         self._url = url
@@ -155,16 +157,59 @@ class CloseOption:
         self._thread = threading.Thread(target=self._run_loop, daemon=True)
         self._thread.start()
         self._closed = False
+        if connect_on_init:
+            # Establish the connection eagerly so the constructor fails fast on bad
+            # credentials and later operations don't race an implicit first connect.
+            try:
+                self._connect()
+            except Exception:
+                # Stop the background loop and join its thread before propagating
+                # so a failed construction leaves no orphaned thread behind.
+                try:
+                    self.shutdown()
+                except Exception:
+                    pass
+                raise
+
     def _run_loop(self):
         asyncio.set_event_loop(self._loop)
         self._loop.run_forever()
 
     def _run(self, coro):
+        """Run a coroutine on the background loop and block for its result.
+
+        No timeout is applied here: operation futures (buy/sell/check_win/...)
+        only resolve once the underlying RawCloseOption action has finished (or
+        raised), so a retry can never re-issue an order that already went
+        through. connection_initialization_timeout_secs is applied only by
+        _connect()/_ensure_connected() while establishing the connection.
+        """
         future = asyncio.run_coroutine_threadsafe(coro, self._loop)
         return future.result()
 
+    def _connect(self):
+        """Establish the connection, bounded by the connection initialization
+        timeout. CloseOptionAsync.connect() is a no-op once connected."""
+        future = asyncio.run_coroutine_threadsafe(self._async_client.connect(), self._loop)
+        try:
+            return future.result(timeout=self._config.connection_initialization_timeout_secs)
+        except concurrent.futures.TimeoutError as exc:
+            future.cancel()
+            raise TimeoutError("CloseOption connection timed out") from exc
+
+    def _ensure_connected(self):
+        """Connect on demand through the bounded _connect() path.
+
+        Used for deferred connections (e.g. connect_on_init=False): without this,
+        the async client would connect lazily inside the operation coroutine,
+        bypassing the Python-side connection initialization timeout.
+        """
+        if self._async_client is not None and not self._async_client.is_connected:
+            self._connect()
+
     def __enter__(self):
-        self._run(self._async_client.connect())
+        # Connection is established in __init__; no per-operation timeout applies.
+        print("CloseOption: connected")
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
@@ -172,73 +217,95 @@ class CloseOption:
 
     def buy(self, asset: str, amount: float, time: int) -> dict:
         """Place a BUY (CALL) order."""
+        self._ensure_connected()
         return self._run(self._async_client.buy(asset, amount, time))
 
     def sell(self, asset: str, amount: float, time: int) -> dict:
         """Place a SELL (PUT) order."""
+        self._ensure_connected()
         return self._run(self._async_client.sell(asset, amount, time))
 
     def check_win(self, order_id: str) -> dict:
         """Check the result of a trade."""
+        self._ensure_connected()
         return self._run(self._async_client.check_win(order_id))
 
     def balance(self) -> float:
         """Get current balance."""
+        self._ensure_connected()
         return self._run(self._async_client.balance())
 
     def candles(self, asset: str, period: int) -> List[dict]:
         """Get historical candles."""
+        self._ensure_connected()
         return self._run(self._async_client.candles(asset, period))
 
     def get_candles(self, asset: str, period: int, count: int = 100) -> List[dict]:
         """Get historical candles with count."""
+        self._ensure_connected()
         return self._run(self._async_client.get_candles(asset, period, count))
 
+    def get_ticks(self, asset: str) -> List[dict]:
+        """Get tick series for an asset."""
+        self._ensure_connected()
+        return self._run(self._async_client.get_ticks(asset))
+
     def get_candles_live(self, asset: str, period: int) -> SyncCandleLiveIterator:
         """Get live candle updates."""
+        self._ensure_connected()
         async_gen = self._run(self._async_client.get_candles_live(asset, period))
         return SyncCandleLiveIterator(async_gen, self._loop)
 
     def subscribe_symbol(self, symbol: str) -> SyncSubscription:
         """Subscribe to price updates for a symbol."""
+        self._ensure_connected()
         sub = self._run(self._async_client.subscribe_symbol(symbol))
         return SyncSubscription(sub, self._loop)
 
     def subscribe_raw(self) -> SyncRawSubscription:
         """Subscribe to all raw messages."""
+        self._ensure_connected()
         sub = self._run(self._async_client.subscribe_raw())
         return SyncRawSubscription(sub, self._loop)
 
     def send_raw(self, message: str) -> None:
         """Send a raw message."""
+        self._ensure_connected()
         self._run(self._async_client.send_raw(message))
 
     def active_assets(self) -> List[dict]:
         """Get list of active assets."""
+        self._ensure_connected()
         return self._run(self._async_client.active_assets())
 
     def payout(self, asset: str) -> float:
         """Get payout for an asset."""
+        self._ensure_connected()
         return self._run(self._async_client.payout(asset))
 
     def history(self, limit: int = 100) -> List[dict]:
         """Get trade history."""
+        self._ensure_connected()
         return self._run(self._async_client.history(limit))
 
     def opened_deals(self) -> List[dict]:
         """Get opened deals."""
+        self._ensure_connected()
         return self._run(self._async_client.opened_deals())
 
     def closed_deals(self) -> List[dict]:
         """Get closed deals."""
+        self._ensure_connected()
         return self._run(self._async_client.closed_deals())
 
     def get_server_time(self) -> int:
         """Get server time."""
+        self._ensure_connected()
         return self._run(self._async_client.get_server_time())
 
     def raw_handler(self) -> RawHandlerSync:
         """Get raw handler for advanced operations."""
+        self._ensure_connected()
         handler = self._run(self._async_client.raw_handler())
         return RawHandlerSync(handler)
 
@@ -248,10 +315,16 @@ class CloseOption:
             return
         self._closed = True
         if self._async_client:
-            self._run(self._async_client.shutdown())
+            try:
+                self._run(self._async_client.shutdown())
+            except Exception:
+                pass
             self._async_client = None
         if self._loop and self._loop.is_running():
             self._loop.call_soon_threadsafe(self._loop.stop)
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5.0)
+
     def reconnect(self) -> None:
         """Reconnect to the server."""
-        return self._run(self._async_client.reconnect())
+        return self._run(self._async_client.reconnect())

{binaryoptionstoolsv2-0.2.14 → binaryoptionstoolsv2-0.2.15}/BinaryOptionsToolsV2/config.py

@@ -24,7 +24,7 @@ class Config:
     max_allowed_loops: int = 100
     sleep_interval: int = 100
     reconnect_time: int = 5
-    connection_initialization_timeout_secs: int = 60
+    connection_initialization_timeout_secs: int = 120
     timeout_secs: int = 30
     urls: List[str] = field(default_factory=list)
     proxy: str = None

{binaryoptionstoolsv2-0.2.14 → binaryoptionstoolsv2-0.2.15}/BinaryOptionsToolsV2/pocketoption/asynchronous.py

@@ -597,7 +597,7 @@ class PocketOptionAsync:
         def merge_candles(*groups: List[Dict]) -> List[Dict]:
             res: Dict[int, Dict] = {}
             for group in groups:
-                for candle in group:
+                for candle in group or []:
                     res[extract_time(candle)] = candle
             return [res[ts] for ts in sorted(res)]
 
@@ -679,7 +679,7 @@ class PocketOptionAsync:
             # 2. Fetch history while buffering ticks
             offset_seconds = int(hours * 3600)
             platform_time = int(time.time()) + platform_time_offset
-            
+
             try:
                 advanced_candles = await asyncio.wait_for(
                     self.get_candles_advanced(
@@ -688,16 +688,13 @@ class PocketOptionAsync:
                         offset_seconds,
                         platform_time,
                     ),
-                    timeout=3.0
+                    timeout=3.0,
                 )
             except Exception:
                 advanced_candles = []
 
             try:
-                recent_candles = await asyncio.wait_for(
-                    self.history(asset, period),
-                    timeout=3.0
-                )
+                recent_candles = await asyncio.wait_for(self.history(asset, period), timeout=3.0)
             except Exception:
                 recent_candles = []
 
@@ -708,7 +705,7 @@ class PocketOptionAsync:
                         period,
                         offset_seconds,
                     ),
-                    timeout=3.0
+                    timeout=3.0,
                 )
             except Exception:
                 compiled_candles = []
@@ -1188,6 +1185,7 @@ class PocketOptionAsync:
             and may have different availability or latency characteristics. For advanced
             historical data with specific time ranges, consider using `get_candles_advanced()`.
         """
+        return json.loads(await self.client.history(asset, period))
 
     async def get_ticks(self, asset: str, lookback_seconds: int) -> List[Tuple[int, float]]:
         """Retrieves historical tick data for an asset.
@@ -1223,7 +1221,7 @@ class PocketOptionAsync:
         if not isinstance(lookback_seconds, int) or lookback_seconds <= 0:
             raise ValueError("lookback_seconds must be a positive integer")
 
-        return json.loads(await self.client.get_ticks(asset, lookback_seconds))
+        return [tuple(tick) for tick in json.loads(await self.client.get_ticks(asset, lookback_seconds))]
 
     async def compile_candles(self, asset: str, custom_period: int, lookback_period: int) -> List[Dict]:
         """Compiles custom candlesticks from raw tick history.

{binaryoptionstoolsv2-0.2.14 → binaryoptionstoolsv2-0.2.15}/BinaryOptionsToolsV2/pocketoption/synchronous.py

@@ -25,7 +25,6 @@ class SyncSubscription:
         return json.loads(next(self.subscription))
 
 
-
 class SyncCandleLiveIterator:
     """Synchronous iterator for live candle updates."""
 
@@ -47,6 +46,8 @@ class SyncCandleLiveIterator:
             return asyncio.run_coroutine_threadsafe(get_next(), self.loop).result()
         except StopIteration:
             raise StopIteration
+
+
 class RawHandlerSync:
     """Synchronous handler for advanced raw WebSocket message operations."""
 
@@ -390,6 +391,7 @@ class PocketOption:
         Returns:
             An iterator yielding (closed_candles, forming_candle).
         """
+
         async def create_gen():
             return self._client.get_candles_live(
                 asset=asset,
@@ -529,6 +531,7 @@ class PocketOption:
         Returns:
             A list of historical trade dictionaries.
         """
+        return self._run(self._client.history(asset, period))
 
     def get_ticks(self, asset: str, lookback_seconds: int) -> List[Tuple[int, float]]:
         """Get historical tick data for an asset.