BinaryOptionsToolsV2 0.2.12__tar.gz → 0.2.13__tar.gz

{binaryoptionstoolsv2-0.2.12 → 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.12 → 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.
@@ -453,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]:
         """
@@ -475,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]:
         """
@@ -500,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.
@@ -987,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.
 
@@ -1128,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.

{binaryoptionstoolsv2-0.2.12 → binaryoptionstoolsv2-0.2.13}/BinaryOptionsToolsV2/pocketoption/synchronous.py

@@ -1,10 +1,10 @@
 import asyncio
 import json
 import threading
+import sys
+import warnings
 from datetime import timedelta
 from typing import Dict, List, Optional, Tuple, Union
-import sys 
-
 from ..config import Config
 from ..validator import Validator as Validator
 from .asynchronous import PocketOptionAsync as PocketOptionAsync
@@ -25,6 +25,41 @@ class SyncSubscription:
         return json.loads(next(self.subscription))
 
 
+class SyncRawSubscription:
+    def __init__(self, subscription):
+        self.subscription = subscription
+
+    def __iter__(self):
+        return self
+
+    def __aiter__(self):
+        return self.subscription
+
+    def __next__(self):
+        return next(self.subscription)
+
+
+class SyncCandleLiveIterator:
+    """Synchronous iterator for live candle updates."""
+
+    def __init__(self, async_gen, loop):
+        self.async_gen = async_gen
+        self.loop = loop
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        async def get_next():
+            try:
+                return await self.async_gen.__anext__()
+            except StopAsyncIteration:
+                raise StopIteration
+
+        try:
+            return asyncio.run_coroutine_threadsafe(get_next(), self.loop).result()
+        except StopIteration:
+            raise StopIteration
 class RawHandlerSync:
     """Synchronous handler for advanced raw WebSocket message operations."""
 
@@ -126,11 +161,14 @@ class PocketOption:
             _: Additional keyword arguments forwarded to the async client.
         """
         self._lock = threading.RLock()
-        self._loop = asyncio.new_event_loop()
-        def _run_loop():
-            asyncio.set_event_loop(self._loop)
-            self._loop.run_forever()
-        self._loop_thread = threading.Thread(target=_run_loop, daemon=True)
+        loop = asyncio.new_event_loop()
+        self._loop = loop
+
+        def _run_loop(loop_to_run):
+            asyncio.set_event_loop(loop_to_run)
+            loop_to_run.run_forever()
+
+        self._loop_thread = threading.Thread(target=_run_loop, args=(loop,), daemon=True)
         self._loop_thread.start()
         self._client = PocketOptionAsync(ssid, url=url, config=config)
         future = asyncio.run_coroutine_threadsafe(self._client.wait_for_assets(), self._loop)
@@ -138,7 +176,7 @@ class PocketOption:
 
     def __del__(self):
         self._cleanup_loop()
-    
+
     def _cleanup_loop(self):
         loop = getattr(self, "_loop", None)
         if loop is None or loop.is_closed():
@@ -150,7 +188,7 @@ class PocketOption:
                 future.result(timeout=5)
         except Exception:
             pass
-    
+
         loop.call_soon_threadsafe(loop.stop)
         thread = getattr(self, "_loop_thread", None)
         if thread is not None and thread.is_alive():
@@ -158,7 +196,7 @@ class PocketOption:
             # The daemon thread will be killed automatically, so just skip the join.
             if not sys.is_finalizing():
                 thread.join(timeout=2)
-    
+
         try:
             loop.close()
         except Exception:
@@ -270,8 +308,24 @@ class PocketOption:
 
         Returns:
             A list of candle dictionaries.
-        """
-        return self._run(self._client.get_candles(asset, period, offset))
+
+        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(
+            "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)
+        iterator = self.get_candles_live(asset, period, hours=hours)
+        closed, forming = next(iterator)
+        return closed
 
     def get_candles_advanced(self, asset: str, period: int, offset: int, time: int) -> List[Dict]:
         """Get historical candle data with a specific reference time.
@@ -284,6 +338,13 @@ class PocketOption:
 
         Returns:
             A list of candle dictionaries.
+
+        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.
         """
         return self._run(self._client.get_candles_advanced(asset, period, offset, time))
 
@@ -296,8 +357,57 @@ class PocketOption:
 
         Returns:
             A list of candle dictionaries.
+
+        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,
+        )
+        iterator = self.get_candles_live(asset, period, hours=2.0)
+        closed, forming = next(iterator)
+        return closed
+
+    def get_candles_live(
+        self,
+        asset: str,
+        period: int,
+        hours: float = 2.0,
+        max_rows: int = 100,
+    ) -> SyncCandleLiveIterator:
+        """Fetches historical backfill and streams live candles.
+
+        This method subscribes to raw ticks first and buffers them, then fetches
+        historical candles, merges them, replays the buffered ticks, and returns
+        a generator yielding updated candles (both closed historical candles and
+        the current forming candle) in real-time.
+
+        Args:
+            asset: Trading asset (e.g., "EURUSD_otc")
+            period: Candle timeframe in seconds (e.g., 60 for 1-minute candles)
+            hours: Hours of history to backfill. Defaults to 2.0.
+            max_rows: Maximum number of closed candles to retain in history. Defaults to 100.
+
+        Returns:
+            An iterator yielding (closed_candles, forming_candle).
         """
-        return self._run(self._client.candles(asset, period))
+        async def create_gen():
+            return self._client.get_candles_live(
+                asset=asset,
+                period=period,
+                hours=hours,
+                max_rows=max_rows,
+            )
+
+        async_gen = self._run(create_gen())
+        return SyncCandleLiveIterator(async_gen, self.loop)
 
     def balance(self) -> float:
         """Get the current account balance.
@@ -442,6 +552,14 @@ class PocketOption:
         """
         return self._run(self._client.compile_candles(asset, custom_period, lookback_period))
 
+    def send_raw(self, message: str) -> None:
+        """Send a raw Engine.io/Socket.io message directly over the connection."""
+        self._run(self._client.send_raw(message))
+
+    def subscribe_raw(self) -> SyncRawSubscription:
+        """Subscribe to all incoming WebSocket messages verbatim."""
+        return SyncRawSubscription(self._run(self._client.subscribe_raw()))
+
     def subscribe_symbol(self, asset: str) -> SyncSubscription:
         """Subscribe to real-time price updates for a symbol.
 
@@ -537,14 +655,6 @@ class PocketOption:
         """
         return self._client.is_connected()
 
-    def max_subscriptions(self) -> int:
-        """Get the maximum number of concurrent subscriptions.
-
-        Returns:
-            The maximum number of allowed subscriptions.
-        """
-        return self._client.max_subscriptions()
-
     def wait_for_assets(self, timeout: float = 60.0) -> None:
         """Wait for asset data to finish loading.