binaryoptionstoolsv2 0.2.11__tar.gz → 0.2.13__tar.gz

{binaryoptionstoolsv2-0.2.11 → binaryoptionstoolsv2-0.2.13}/BinaryOptionsToolsV2/__init__.py

@@ -4,7 +4,13 @@ import sys
 from .config import Config as Config
 from . import tracing as tracing
 from . import validator as validator
-from .pocketoption import PocketOptionAsync, PocketOption, __all__ as __pocket_all__  # noqa: F401
+from .pocketoption import (
+    PocketOptionAsync as PocketOptionAsync,
+    PocketOption as PocketOption,
+    RawHandler as RawHandler,
+    Validator as Validator,
+    __all__ as __pocket_all__,
+)
 
 # Import the Rust module and re-export its attributes
 _rust_module = None
@@ -25,12 +31,30 @@ elif os.environ.get("PYTEST_CURRENT_TEST"):
 
 # Names expected from the Rust cdylib; only those actually loaded will be available
 _rust_exported_names = [
-    "RawPocketOption", "RawValidator", "RawHandler", "RawHandle",
-    "Logger", "LogBuilder", "PyConfig", "PyBot", "PyStrategy",
-    "PyContext", "PyVirtualMarket", "Action",
-    "StreamLogsIterator", "StreamLogsLayer", "StreamIterator",
-    "RawStreamIterator", "start_tracing",
+    "RawPocketOption",
+    "RawValidator",
+    "RawHandler",
+    "RawHandle",
+    "Logger",
+    "LogBuilder",
+    "PyConfig",
+    "PyBot",
+    "PyStrategy",
+    "PyContext",
+    "PyVirtualMarket",
+    "Action",
+    "StreamLogsIterator",
+    "StreamLogsLayer",
+    "StreamIterator",
+    "RawStreamIterator",
+    "start_tracing",
 ]
 __rust_all__ = [n for n in _rust_exported_names if n in globals()]
 
-__all__ = list(set(__pocket_all__ + ["tracing", "validator", "PocketOptionAsync", "PocketOption"] + __rust_all__))
+__all__ = list(
+    set(
+        __pocket_all__
+        + ["tracing", "validator", "PocketOptionAsync", "PocketOption", "RawHandler", "Validator"]
+        + __rust_all__
+    )
+)

{binaryoptionstoolsv2-0.2.11 → binaryoptionstoolsv2-0.2.13}/BinaryOptionsToolsV2/config.py

@@ -27,7 +27,12 @@ class Config:
     connection_initialization_timeout_secs: int = 60
     timeout_secs: int = 30
     urls: List[str] = field(default_factory=list)
-    max_subscriptions: int = 4
+    proxy: str = None
+    user_agent: str = None
+    origin: str = None
+    sec_websocket_extensions: str = None
+    tls_cipher_suites: List[str] = None
+    tls_alpn: List[str] = None
 
     # Logging configuration
     terminal_logging: bool = False
@@ -67,7 +72,12 @@ class Config:
         self._pyconfig.connection_initialization_timeout_secs = self.connection_initialization_timeout_secs
         self._pyconfig.timeout_secs = self.timeout_secs
         self._pyconfig.urls = self.urls
-        self._pyconfig.max_subscriptions = self.max_subscriptions
+        self._pyconfig.proxy = self.proxy
+        self._pyconfig.user_agent = self.user_agent
+        self._pyconfig.origin = self.origin
+        self._pyconfig.sec_websocket_extensions = self.sec_websocket_extensions
+        self._pyconfig.tls_cipher_suites = self.tls_cipher_suites
+        self._pyconfig.tls_alpn = self.tls_alpn
 
     def _validate(self):
         """Validate config values, raising ValueError on invalid input."""
@@ -81,8 +91,6 @@ class Config:
             raise ValueError("connection_initialization_timeout_secs must be at least 1")
         if self.timeout_secs < 1:
             raise ValueError("timeout_secs must be at least 1")
-        if self.max_subscriptions < 1:
-            raise ValueError("max_subscriptions must be at least 1")
 
     @classmethod
     def from_dict(cls, config_dict: Dict[str, Any]) -> "Config":
@@ -105,7 +113,6 @@ class Config:
             "connection_initialization_timeout_secs": self.connection_initialization_timeout_secs,
             "timeout_secs": self.timeout_secs,
             "urls": self.urls,
-            "max_subscriptions": self.max_subscriptions,
             "terminal_logging": self.terminal_logging,
             "log_level": self.log_level,
             "extra_duration": self.extra_duration,

{binaryoptionstoolsv2-0.2.11 → binaryoptionstoolsv2-0.2.13}/BinaryOptionsToolsV2/pocketoption/__init__.py

@@ -7,13 +7,15 @@ as well as specific classes for Pocket Option trading.
 
 __all__ = [
     "asynchronous",
-    "synchronous",
+    "login",
+    "login_async",
     "PocketOptionAsync",
     "PocketOption",
     "RawHandler",
     "RawHandlerSync",
+    "Validator",
 ]
-
-from . import asynchronous, synchronous
-from .asynchronous import PocketOptionAsync, RawHandler
+from .tools.login import login, login_async
+from . import asynchronous, synchronous as synchronous
+from .asynchronous import PocketOptionAsync, RawHandler, Validator
 from .synchronous import PocketOption, RawHandlerSync

{binaryoptionstoolsv2-0.2.11 → binaryoptionstoolsv2-0.2.13}/BinaryOptionsToolsV2/pocketoption/asynchronous.py

@@ -2,8 +2,11 @@ import asyncio
 import json
 import re
 import sys
-from datetime import timedelta
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+import time
+import warnings
+from collections import deque
+from datetime import datetime, timezone, timedelta
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union, AsyncGenerator
 
 from ..config import Config
 from ..validator import Validator
@@ -30,6 +33,18 @@ class AsyncSubscription:
         return json.loads(await anext(self.subscription))
 
 
+class AsyncRawSubscription:
+    def __init__(self, subscription):
+        """Asynchronous Iterator over raw message strings"""
+        self.subscription = subscription
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        return await anext(self.subscription)
+
+
 class RawHandler:
     """
     Handler for advanced raw WebSocket message operations.
@@ -191,7 +206,7 @@ def sanitize_and_validate_ssid(ssid: str, logger: "Logger") -> str:
             warnings_list.append(f"missing required field '{field}'")
 
     session = auth_data.get("session", "")
-    if session and not re.match(r'^[a-zA-Z0-9_\-]{10,}$', str(session)):
+    if session and not re.match(r"^[a-zA-Z0-9_\-]{10,}$", str(session)):
         warnings_list.append(f"session token has unexpected format (length={len(str(session))})")
 
     uid = auth_data.get("uid")
@@ -219,7 +234,8 @@ def sanitize_and_validate_ssid(ssid: str, logger: "Logger") -> str:
         raise ValueError(
             "Invalid SSID: " + "; ".join(critical) + ". "
             "The SSID payload must contain 'session' and 'uid' fields. "
-            "Ensure your SSID follows the format: 42['auth',{{'session':'...','uid':123,...}}]")
+            "Ensure your SSID follows the format: 42['auth',{{'session':'...','uid':123,...}}]"
+        )
 
     return ssid
 
@@ -452,9 +468,23 @@ class PocketOptionAsync:
                 - high: Highest price
                 - low: Lowest price
                 - close: Closing price
-        """
-        candles = await self.client.candles(asset, period)
-        return json.loads(candles)
+
+        Note:
+            WARNING: This function only fetches closed historical candles and is intended
+            for training models, backtesting, or historical analysis. It is NOT designed
+            for real-time/live trading as it does not include the current forming candle
+            and can introduce gaps if called sequentially during live trading.
+            For live gap-free candle feeds, use `get_candles_live()` instead.
+        """
+        warnings.warn(
+            "candles() is deprecated and will be removed in a new release. "
+            "Please use get_candles_live() for live gap-free candles instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        gen = self.get_candles_live(asset, period, hours=2.0)
+        closed, forming = await anext(gen)
+        return closed
 
     async def get_candles(self, asset: str, period: int, offset: int) -> List[Dict]:
         """
@@ -462,8 +492,8 @@ class PocketOptionAsync:
 
         Args:
             asset (str): Trading asset (e.g., "EURUSD_otc")
-            timeframe (int): Candle timeframe in seconds (e.g., 60 for 1-minute candles)
             period (int): Historical period in seconds to fetch
+            offset (int): Candle timeframe in seconds (e.g., 60 for 1-minute candles)
 
         Returns:
             List[Dict]: List of candles, each containing:
@@ -474,11 +504,24 @@ class PocketOptionAsync:
                 - close: Closing price
 
         Note:
-            Available timeframes: 1, 5, 15, 30, 60, 300 seconds
-            Maximum period depends on the timeframe
-        """
-        candles = await self.client.get_candles(asset, period, offset)
-        return json.loads(candles)
+            - Available timeframes: 1, 5, 15, 30, 60, 300 seconds
+            - Maximum period depends on the timeframe
+            - WARNING: This function only fetches closed historical candles and is intended
+              for training models, backtesting, or historical analysis. It is NOT designed
+              for real-time/live trading as it does not include the current forming candle
+              and can introduce gaps if called sequentially during live trading.
+              For live gap-free candle feeds, use `get_candles_live()` instead.
+        """
+        warnings.warn(
+            "get_candles() is deprecated and will be removed in a new release. "
+            "Please use get_candles_live() for live gap-free candles instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        hours = max(0.1, offset / 3600.0)
+        gen = self.get_candles_live(asset, period, hours=hours)
+        closed, forming = await anext(gen)
+        return closed
 
     async def get_candles_advanced(self, asset: str, period: int, offset: int, time: int) -> List[Dict]:
         """
@@ -486,8 +529,8 @@ class PocketOptionAsync:
 
         Args:
             asset (str): Trading asset (e.g., "EURUSD_otc")
-            timeframe (int): Candle timeframe in seconds (e.g., 60 for 1-minute candles)
             period (int): Historical period in seconds to fetch
+            offset (int): Candle timeframe in seconds (e.g., 60 for 1-minute candles)
             time (int): Time to fetch candles from
 
         Returns:
@@ -499,12 +542,209 @@ class PocketOptionAsync:
                 - close: Closing price
 
         Note:
-            Available timeframes: 1, 5, 15, 30, 60, 300 seconds
-            Maximum period depends on the timeframe
+            - Available timeframes: 1, 5, 15, 30, 60, 300 seconds
+            - Maximum period depends on the timeframe
+            - WARNING: This function only fetches closed historical candles and is intended
+              for training models, backtesting, or historical analysis. It is NOT designed
+              for real-time/live trading as it does not include the current forming candle
+              and can introduce gaps if called sequentially during live trading.
+              For live gap-free candle feeds, use `get_candles_live()` instead.
         """
         candles = await self.client.get_candles_advanced(asset, period, offset, time)
         return json.loads(candles)
 
+    async def get_candles_live(
+        self,
+        asset: str,
+        period: int,
+        hours: float = 2.0,
+        max_rows: int = 100,
+    ) -> AsyncGenerator[Tuple[List[Dict], Optional[Dict]], None]:
+        """Fetches historical backfill and streams gap-free live candles.
+
+        This method subscribes to raw ticks first and buffers them, then fetches
+        historical candles (using get_candles_advanced, history, and compile_candles),
+        merges them, replays the buffered ticks, and yields updated candles (both
+        closed historical candles and the current forming candle) in real-time.
+
+        Args:
+            asset (str): Trading asset (e.g., "EURUSD_otc")
+            period (int): Candle timeframe in seconds (e.g., 60 for 1-minute candles)
+            hours (float): Hours of history to backfill. Defaults to 2.0.
+            max_rows (int): Maximum number of closed candles to retain in history. Defaults to 100.
+
+        Yields:
+            Tuple[List[Dict], Optional[Dict]]: A tuple containing:
+                - List[Dict]: List of closed candles (up to max_rows), each containing
+                  'time', 'open', 'high', 'low', 'close'.
+                - Optional[Dict]: The currently forming candle, containing 'time', 'open',
+                  'high', 'low', 'close', or None if not yet started.
+        """
+        platform_time_offset = 7200
+
+        def bucket_start(timestamp: int, p: int) -> int:
+            return (timestamp // p) * p
+
+        def extract_time(candle: Dict) -> int:
+            val = int(float(candle.get("timestamp", candle.get("time", 0))))
+            if val > 10_000_000_000:
+                val //= 1000
+            return val - platform_time_offset
+
+        def merge_candles(*groups: List[Dict]) -> List[Dict]:
+            res: Dict[int, Dict] = {}
+            for group in groups:
+                for candle in group:
+                    res[extract_time(candle)] = candle
+            return [res[ts] for ts in sorted(res)]
+
+        # Initialize feed
+        feed_candles: deque = deque(maxlen=max_rows)
+        forming: Optional[Dict] = None
+
+        def seed_history(history: List[Dict]) -> None:
+            cutoff = bucket_start(int(time.time()), period)
+            ordered = sorted(
+                (c for c in history if extract_time(c) < cutoff),
+                key=extract_time,
+            )
+            for c in ordered[-max_rows:]:
+                feed_candles.append(
+                    {
+                        "time": extract_time(c),
+                        "open": float(c["open"]),
+                        "high": float(c["high"]),
+                        "low": float(c["low"]),
+                        "close": float(c["close"]),
+                    }
+                )
+
+        def ingest_tick(timestamp: int, price: float) -> None:
+            nonlocal forming
+            if forming is None:
+                start = bucket_start(timestamp, period)
+                forming = {
+                    "time": start,
+                    "open": price,
+                    "high": price,
+                    "low": price,
+                    "close": price,
+                }
+                return
+
+            start = bucket_start(timestamp, period)
+            if start == forming["time"]:
+                forming["high"] = max(forming["high"], price)
+                forming["low"] = min(forming["low"], price)
+                forming["close"] = price
+            elif start > forming["time"]:
+                feed_candles.append(dict(forming))
+                forming = {
+                    "time": start,
+                    "open": price,
+                    "high": price,
+                    "low": price,
+                    "close": price,
+                }
+
+        # 1. Subscribe to ticks FIRST
+        tick_buffer: List[Tuple[int, float]] = []
+        buffering = True
+        stream = await self.subscribe_symbol(asset)
+
+        queue = asyncio.Queue()
+
+        async def tick_reader():
+            nonlocal buffering
+            try:
+                async for tick in stream:
+                    ts = extract_time(tick)
+                    price = float(tick.get("close", tick.get("price", 0.0)))
+                    if buffering:
+                        tick_buffer.append((ts, price))
+                    else:
+                        ingest_tick(ts, price)
+                        await queue.put((list(feed_candles), dict(forming) if forming else None))
+            except asyncio.CancelledError:
+                pass
+            finally:
+                await queue.put(None)
+
+        reader_task = asyncio.create_task(tick_reader())
+
+        try:
+            # 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(
+                        asset,
+                        period,
+                        offset_seconds,
+                        platform_time,
+                    ),
+                    timeout=3.0
+                )
+            except Exception:
+                advanced_candles = []
+
+            try:
+                recent_candles = await asyncio.wait_for(
+                    self.history(asset, period),
+                    timeout=3.0
+                )
+            except Exception:
+                recent_candles = []
+
+            try:
+                compiled_candles = await asyncio.wait_for(
+                    self.compile_candles(
+                        asset,
+                        period,
+                        offset_seconds,
+                    ),
+                    timeout=3.0
+                )
+            except Exception:
+                compiled_candles = []
+
+            history = merge_candles(
+                compiled_candles,
+                recent_candles,
+                advanced_candles,
+            )
+            seed_history(history)
+
+            # 3. Replay backlog
+            cutoff = 0
+            if feed_candles:
+                cutoff = feed_candles[-1]["time"] + period
+            for ts, price in sorted(tick_buffer):
+                if ts < cutoff:
+                    continue
+                ingest_tick(ts, price)
+
+            buffering = False
+            # Yield initial seed state
+            yield list(feed_candles), dict(forming) if forming else None
+
+            # 4. Stream loop
+            while True:
+                item = await queue.get()
+                if item is None:
+                    break
+                yield item
+
+        finally:
+            reader_task.cancel()
+            try:
+                await reader_task
+            except asyncio.CancelledError:
+                pass
+            await self.unsubscribe(asset)
+
     async def balance(self) -> float:
         """
         Retrieves current account balance.
@@ -589,7 +829,7 @@ class PocketOptionAsync:
         if deal_json is None:
             return None
         return json.loads(deal_json)
-    
+
     async def open_pending_order(
         self,
         open_type: int,
@@ -608,7 +848,7 @@ class PocketOptionAsync:
             open_type (int): The type of the pending order.
             amount (float): The amount to trade.
             asset (str): The asset symbol (e.g., "EURUSD_otc").
-            open_time (int | str): The server time to open the trade. 
+            open_time (int | str): The server time to open the trade.
                 Can be a Unix timestamp (int) or a formatted string "YYYY-MM-DD HH:MM:SS".
             open_price (float): The price to open the trade at.
             timeframe (int): The duration of the trade in seconds.
@@ -641,13 +881,14 @@ class PocketOptionAsync:
                         # We can't easily convert "YYYY-MM-DD" to timestamp without more info,
                         # but for the sake of not crashing, we'll try to parse it or use 0.
                         from datetime import datetime
+
                         try:
                             # PocketOption strings are usually UTC
-                            dt = datetime.strptime(open_time, '%Y-%m-%d %H:%M:%S')
+                            dt = datetime.strptime(open_time, "%Y-%m-%d %H:%M:%S")
                             actual_open_time = int(dt.timestamp())
                         except Exception:
                             actual_open_time = 0
-                
+
                 # Retry with converted integer
                 order = await self.client.open_pending_order(
                     open_type, amount, asset, actual_open_time, open_price, timeframe, min_payout, command
@@ -789,7 +1030,6 @@ class PocketOptionAsync:
             return None
         return json.loads(deal_json)
 
-
     async def clear_closed_deals(self) -> None:
         """Removes all closed deals from the client's memory.
 
@@ -986,6 +1226,14 @@ class PocketOptionAsync:
 
         return json.loads(await self.client.compile_candles(asset, custom_period, lookback_period))
 
+    async def send_raw(self, message: str) -> None:
+        """Send a raw Engine.io/Socket.io message directly over the connection."""
+        await self.client.send_raw(message)
+
+    async def subscribe_raw(self) -> AsyncRawSubscription:
+        """Subscribe to all incoming WebSocket messages verbatim."""
+        return AsyncRawSubscription(await self.client.subscribe_raw())
+
     async def subscribe_symbol(self, asset: str) -> AsyncSubscription:
         """Subscribe to real-time raw price updates for an asset.
 
@@ -1127,15 +1375,6 @@ class PocketOptionAsync:
         """Returns whether the SSID passed basic format validation during init."""
         return self._ssid_valid
 
-    def max_subscriptions(self) -> int:
-        """
-        Returns the configured maximum number of concurrent subscriptions.
-
-        Returns:
-            int: Maximum number of concurrent asset subscriptions allowed
-        """
-        return self.client.max_subscriptions()
-
     async def disconnect(self) -> None:
         """
         Disconnects the client while keeping the configuration intact.
@@ -1520,6 +1759,3 @@ class PocketOptionAsync:
             async context manager or when it is garbage collected.
         """
         return await self.client.create_raw_iterator(message, validator.raw_validator, timeout)
-
-
-