binaryoptionstoolsv2 0.2.14__tar.gz → 0.2.16__tar.gz

{binaryoptionstoolsv2-0.2.14 → binaryoptionstoolsv2-0.2.16}/BinaryOptionsToolsV2/BinaryOptionsToolsV2.pyi

@@ -5,15 +5,19 @@ class Action:
     Put: "Action"
 
 class PyConfig:
-    def __init__(
-        self,
-        max_allowed_loops: int = 10,
-        sleep_interval: int = 100,
-        reconnect_time: int = 5,
-        connection_initialization_timeout: float = 30.0,
-        timeout: float = 10.0,
-        urls: List[str] = [],
-    ) -> None: ...
+    # The Rust constructor takes no arguments; fields are read/written through
+    # properties. Defaults mirror `binary_options_tools::config::Config`.
+    def __init__(self) -> None: ...
+    max_allowed_loops: int
+    sleep_interval: int
+    reconnect_time: int
+    connection_initialization_timeout_secs: int
+    timeout_secs: int
+    urls: List[str]
+    proxy: Optional[str]
+    user_agent: Optional[str]
+    origin: Optional[str]
+    sec_websocket_extensions: Optional[str]
 
 class RawValidator:
     @staticmethod
@@ -72,6 +76,10 @@ class RawPocketOption:
     def new_with_config(ssid: str, config: PyConfig) -> "RawPocketOption": ...
     @staticmethod
     async def create_with_config(ssid: str, config: PyConfig) -> "RawPocketOption": ...
+    @staticmethod
+    def new_try_demo(token: Optional[str] = None) -> "RawPocketOption": ...
+    @staticmethod
+    async def create_try_demo(token: Optional[str] = None) -> "RawPocketOption": ...
     async def wait_for_assets(self, timeout_secs: float) -> None: ...
     def is_demo(self) -> bool: ...
     async def buy(self, asset: str, amount: float, time: int) -> List[str]: ...
@@ -87,7 +95,7 @@ class RawPocketOption:
         open_type: int,
         amount: float,
         asset: str,
-        open_time: int,
+        open_time: str,
         open_price: float,
         timeframe: int,
         min_payout: int,

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

@@ -8,13 +8,21 @@ from .pocketoption import (
     PocketOptionAsync as PocketOptionAsync,
     PocketOption as PocketOption,
     RawHandler as RawHandler,
+    RawHandlerSync as RawHandlerSync,
+    Trade as Trade,
+    TradeResult as TradeResult,
     Validator as Validator,
+    login as login,
+    login_async as login_async,
     __all__ as __pocket_all__,
 )
 from .closeoption import (
     CloseOptionAsync as CloseOptionAsync,
     CloseOption as CloseOption,
-    RawHandler as CloseRawHandler,
+    AsyncRawSubscription as AsyncRawSubscription,
+    AsyncSubscription as AsyncSubscription,
+    SyncRawSubscription as SyncRawSubscription,
+    SyncSubscription as SyncSubscription,
     __all__ as __close_all__,
 )
 
@@ -56,10 +64,25 @@ _rust_exported_names = [
 __rust_all__ = [n for n in _rust_exported_names if n in globals()]
 
 __all__ = list(
-    set(
+    dict.fromkeys(
         __pocket_all__
         + __close_all__
-        + ["tracing", "validator", "PocketOptionAsync", "PocketOption", "CloseOptionAsync", "CloseOption", "RawHandler", "Validator"]
+        + [
+            "tracing",
+            "validator",
+            "PocketOptionAsync",
+            "PocketOption",
+            "CloseOptionAsync",
+            "CloseOption",
+            "RawHandler",
+            "Trade",
+            "TradeResult",
+            "Validator",
+        ]
         + __rust_all__
     )
-)
+)
+# The subpackage `__all__` lists include submodule names (e.g. "asynchronous")
+# that only exist there. Expose just the names this package actually resolves,
+# so `from BinaryOptionsToolsV2 import *` works instead of raising AttributeError.
+__all__ = [name for name in __all__ if name in globals()]

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

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

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

@@ -1,16 +1,12 @@
-import asyncio
 import json
-import re
 import sys
-import warnings
-from datetime import timedelta
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union, AsyncGenerator
+from typing import TYPE_CHECKING, List, Optional, Tuple, Union, AsyncGenerator
 
 from ..config import Config
 from ..validator import Validator
 
 if TYPE_CHECKING:
-    from ..BinaryOptionsToolsV2 import Logger, RawCloseOption
+    from ..BinaryOptionsToolsV2 import Logger
 
 if sys.version_info < (3, 10):
 
@@ -86,11 +82,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 +94,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 +107,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 +153,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 +180,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 +190,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 +235,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.16}/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.16}/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.16}/BinaryOptionsToolsV2/pocketoption/__init__.py

@@ -14,8 +14,11 @@ __all__ = [
     "RawHandler",
     "RawHandlerSync",
     "Validator",
+    "Trade",
+    "TradeResult",
 ]
 from .tools.login import login, login_async
 from . import asynchronous, synchronous as synchronous
 from .asynchronous import PocketOptionAsync, RawHandler, Validator
 from .synchronous import PocketOption, RawHandlerSync
+from .models import Trade, TradeResult