binaryoptionstoolsv2 0.2.8__cp313-cp313-win32.whl

BinaryOptionsToolsV2/BinaryOptionsToolsV2.pyi

@@ -0,0 +1,155 @@
+from typing import Any, Callable, List, Optional
+
+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: ...
+
+class RawValidator:
+    @staticmethod
+    def new() -> "RawValidator": ...
+    @staticmethod
+    def regex(pattern: str) -> "RawValidator": ...
+    @staticmethod
+    def contains(pattern: str) -> "RawValidator": ...
+    @staticmethod
+    def starts_with(pattern: str) -> "RawValidator": ...
+    @staticmethod
+    def ends_with(pattern: str) -> "RawValidator": ...
+    @staticmethod
+    def ne(validator: "RawValidator") -> "RawValidator": ...
+    @staticmethod
+    def all(validators: List["RawValidator"]) -> "RawValidator": ...
+    @staticmethod
+    def any(validators: List["RawValidator"]) -> "RawValidator": ...
+    @staticmethod
+    def custom(func: Callable[[str], bool]) -> "RawValidator": ...
+    def check(self, msg: str) -> bool: ...
+
+class StreamIterator:
+    def __aiter__(self) -> "StreamIterator": ...
+    def __anext__(self) -> str: ...
+    def __iter__(self) -> "StreamIterator": ...
+    def __next__(self) -> str: ...
+
+class RawStreamIterator:
+    def __aiter__(self) -> "RawStreamIterator": ...
+    def __anext__(self) -> str: ...
+    def __iter__(self) -> "RawStreamIterator": ...
+    def __next__(self) -> str: ...
+
+class RawHandler:
+    def id(self) -> str: ...
+    async def send_text(self, text: str) -> None: ...
+    async def send_binary(self, data: bytes) -> None: ...
+    async def send_and_wait(self, message: str) -> str: ...
+    async def wait_next(self) -> str: ...
+    async def subscribe(self) -> RawStreamIterator: ...
+
+class RawHandle:
+    async def create(self, validator: RawValidator, keep_alive_message: Optional[str]) -> RawHandler: ...
+    async def remove(self, id: str) -> bool: ...
+
+class RawPocketOption:
+    def __init__(self, ssid: str) -> None: ...
+    @staticmethod
+    async def create(ssid: str) -> "RawPocketOption": ...
+    @staticmethod
+    def new_with_url(ssid: str, url: str) -> "RawPocketOption": ...
+    @staticmethod
+    async def create_with_url(ssid: str, url: str) -> "RawPocketOption": ...
+    @staticmethod
+    def new_with_config(ssid: str, config: PyConfig) -> "RawPocketOption": ...
+    @staticmethod
+    async def create_with_config(ssid: str, config: PyConfig) -> "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]: ...
+    async def sell(self, asset: str, amount: float, time: int) -> List[str]: ...
+    async def check_win(self, trade_id: str) -> str: ...
+    async def get_deal_end_time(self, trade_id: str) -> Optional[int]: ...
+    async def candles(self, asset: str, period: int) -> str: ...
+    async def get_candles(self, asset: str, period: int, offset: int) -> str: ...
+    async def get_candles_advanced(self, asset: str, period: int, offset: int, time: int) -> str: ...
+    async def balance(self) -> float: ...
+    async def open_pending_order(
+        self,
+        open_type: int,
+        amount: float,
+        asset: str,
+        open_time: int,
+        open_price: float,
+        timeframe: int,
+        min_payout: int,
+        command: int,
+    ) -> str: ...
+    async def closed_deals(self) -> str: ...
+    async def clear_closed_deals(self) -> None: ...
+    async def opened_deals(self) -> str: ...
+    async def payout(self) -> str: ...
+    async def history(self, asset: str, period: int) -> str: ...
+    async def compile_candles(self, asset: str, custom_period: int, lookback_period: int) -> str: ...
+    async def subscribe_symbol(self, symbol: str) -> StreamIterator: ...
+    async def subscribe_symbol_chuncked(self, symbol: str, chunck_size: int) -> StreamIterator: ...
+    async def subscribe_symbol_timed(self, symbol: str, time: Any) -> StreamIterator: ...
+    async def subscribe_symbol_time_aligned(self, symbol: str, time: Any) -> StreamIterator: ...
+    async def send_raw_message(self, message: str) -> None: ...
+    async def create_raw_order(self, message: str, validator: RawValidator) -> str: ...
+    async def create_raw_order_with_timeout(self, message: str, validator: RawValidator, timeout: Any) -> str: ...
+    async def create_raw_order_with_timeout_and_retry(
+        self, message: str, validator: RawValidator, timeout: Any
+    ) -> str: ...
+    async def create_raw_iterator(
+        self, message: str, validator: RawValidator, timeout: Optional[Any]
+    ) -> RawStreamIterator: ...
+    async def get_server_time(self) -> int: ...
+    async def disconnect(self) -> None: ...
+    async def connect(self) -> None: ...
+    async def reconnect(self) -> None: ...
+    async def unsubscribe(self, asset: str) -> None: ...
+    async def create_raw_handler(self, validator: RawValidator, keep_alive: Optional[str]) -> RawHandler: ...
+
+class Logger:
+    def __init__(self) -> None: ...
+    def debug(self, message: str) -> None: ...
+    def info(self, message: str) -> None: ...
+    def warn(self, message: str) -> None: ...
+    def error(self, message: str) -> None: ...
+
+class LogBuilder:
+    def __init__(self) -> None: ...
+    def create_logs_iterator(self, level: str, timeout: Optional[Any]) -> Any: ...
+    def log_file(self, path: str, level: str) -> None: ...
+    def terminal(self, level: str) -> None: ...
+    def build(self) -> None: ...
+
+class StreamLogsLayer: ...
+class StreamLogsIterator: ...
+
+class PyContext:
+    async def buy(self, asset: str, amount: float, time: int) -> List[str]: ...
+    async def balance(self) -> float: ...
+
+class PyVirtualMarket:
+    def __init__(self, initial_balance: float) -> None: ...
+    async def update_price(self, asset: str, price: float) -> None: ...
+
+class PyStrategy:
+    def __init__(self) -> None: ...
+    def on_start(self, ctx: PyContext) -> None: ...
+    def on_candle(self, ctx: PyContext, asset: str, candle_json: str) -> None: ...
+
+class PyBot:
+    def __init__(
+        self, client: RawPocketOption, strategy: PyStrategy, virtual_market: Optional[PyVirtualMarket] = None
+    ) -> None: ...
+    def add_asset(self, asset: str, period: int) -> None: ...
+    async def run(self) -> None: ...
+
+def start_tracing(path: str, level: str, terminal: bool, layers: List[StreamLogsLayer]) -> None: ...

BinaryOptionsToolsV2/__init__.py

@@ -0,0 +1,54 @@
+import importlib
+import os
+import sys
+
+# Import the Rust module and re-export its attributes
+try:
+    _rust_module = importlib.import_module(".BinaryOptionsToolsV2", __package__)
+except (ImportError, ValueError):
+    try:
+        # Fallback for when it's not in the package
+        _rust_module = importlib.import_module("BinaryOptionsToolsV2")
+        # Ensure we didn't just import the package itself
+        if _rust_module is sys.modules.get(__package__):
+            _rust_module = None
+    except ImportError:
+        _rust_module = None
+
+if _rust_module:
+    # Update globals with Rust module attributes
+    globals().update({k: v for k, v in _rust_module.__dict__.items() if not k.startswith("_")})
+else:
+    # This is often okay during development/type checking, but bad for tests
+    if os.environ.get("PYTEST_CURRENT_TEST"):
+        print(f"[ERROR] Rust extension module 'BinaryOptionsToolsV2' not found! __package__={__package__}")
+        print(f"[DEBUG] sys.path: {sys.path}")
+
+# Import submodules for re-export
+from . import tracing as tracing  # noqa: E402
+from . import validator as validator  # noqa: E402
+from .pocketoption import *  # noqa: F403, E402
+from .pocketoption import __all__ as __pocket_all__  # noqa: E402
+
+# Collect all core attributes for __all__
+_core_names = [
+    "RawPocketOption",
+    "RawValidator",
+    "RawHandler",
+    "RawHandle",
+    "Logger",
+    "LogBuilder",
+    "PyConfig",
+    "PyBot",
+    "PyStrategy",
+    "PyContext",
+    "PyVirtualMarket",
+    "StreamLogsIterator",
+    "StreamLogsLayer",
+    "StreamIterator",
+    "RawStreamIterator",
+    "start_tracing",
+]
+__core_all__ = [name for name in _core_names if name in globals()]
+
+__all__ = list(set(__pocket_all__ + ["tracing", "validator"] + __core_all__))

BinaryOptionsToolsV2/config.py

@@ -0,0 +1,143 @@
+import json
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+
+def _get_pyconfig():
+    try:
+        from .BinaryOptionsToolsV2 import PyConfig
+
+        return PyConfig
+    except ImportError:
+        import BinaryOptionsToolsV2
+
+        return getattr(BinaryOptionsToolsV2, "PyConfig")
+
+
+@dataclass
+class Config:
+    """
+    Python wrapper around PyConfig that provides additional functionality
+    for configuration management.
+    """
+
+    max_allowed_loops: int = 100
+    sleep_interval: int = 100
+    reconnect_time: int = 5
+    connection_initialization_timeout_secs: int = 60
+    timeout_secs: int = 30
+    urls: List[str] = field(default_factory=list)
+
+    # Logging configuration
+    terminal_logging: bool = False
+    log_level: str = "INFO"
+
+    # Extra duration, used by functions like `check_win`
+    extra_duration: int = 5
+
+    def __post_init__(self):
+        self.urls = self.urls or []
+        self._pyconfig = None
+        self._locked = False
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Override setattr to check for locked state"""
+        # Allow setting private attributes and during initialization
+        if name.startswith("_") or not hasattr(self, "_locked") or not self._locked:
+            super().__setattr__(name, value)
+        else:
+            raise RuntimeError("Configuration is locked and cannot be modified after being used")
+
+    @property
+    def pyconfig(self) -> Any:
+        """
+        Returns the PyConfig instance for use in Rust code.
+        Once this is accessed, the configuration becomes locked.
+        """
+        if self._pyconfig is None:
+            self._pyconfig = _get_pyconfig()()
+            self._update_pyconfig()
+        self._locked = True
+        return self._pyconfig
+
+    def _update_pyconfig(self):
+        """Updates the internal PyConfig with current values"""
+        if self._locked:
+            raise RuntimeError("Configuration is locked and cannot be modified after being used")
+
+        if self._pyconfig is None:
+            self._pyconfig = _get_pyconfig()()
+
+        self._pyconfig.max_allowed_loops = self.max_allowed_loops
+        self._pyconfig.sleep_interval = self.sleep_interval
+        self._pyconfig.reconnect_time = self.reconnect_time
+        self._pyconfig.connection_initialization_timeout_secs = self.connection_initialization_timeout_secs
+        self._pyconfig.timeout_secs = self.timeout_secs
+        self._pyconfig.urls = self.urls
+
+    @classmethod
+    def from_dict(cls, config_dict: Dict[str, Any]) -> "Config":
+        """
+        Creates a Config instance from a dictionary.
+
+        Args:
+            config_dict: Dictionary containing configuration values
+
+        Returns:
+            Config instance
+        """
+        return cls(**{k: v for k, v in config_dict.items() if k in Config.__dataclass_fields__})
+
+    @classmethod
+    def from_json(cls, json_str: str) -> "Config":
+        """
+        Creates a Config instance from a JSON string.
+
+        Args:
+            json_str: JSON string containing configuration values
+
+        Returns:
+            Config instance
+        """
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts the configuration to a dictionary.
+
+        Returns:
+            Dictionary containing all configuration values
+        """
+        return {
+            "max_allowed_loops": self.max_allowed_loops,
+            "sleep_interval": self.sleep_interval,
+            "reconnect_time": self.reconnect_time,
+            "connection_initialization_timeout_secs": self.connection_initialization_timeout_secs,
+            "timeout_secs": self.timeout_secs,
+            "urls": self.urls,
+            "terminal_logging": self.terminal_logging,
+            "log_level": self.log_level,
+        }
+
+    def to_json(self) -> str:
+        """
+        Converts the configuration to a JSON string.
+
+        Returns:
+            JSON string containing all configuration values
+        """
+        return json.dumps(self.to_dict())
+
+    def update(self, config_dict: Dict[str, Any]) -> None:
+        """
+        Updates the configuration with values from a dictionary.
+
+        Args:
+            config_dict: Dictionary containing new configuration values
+        """
+        if self._locked:
+            raise RuntimeError("Configuration is locked and cannot be modified after being used")
+
+        for key, value in config_dict.items():
+            if hasattr(self, key):
+                setattr(self, key, value)

BinaryOptionsToolsV2/pocketoption/__init__.py

@@ -0,0 +1,19 @@
+"""
+Module for Pocket Option related functionality.
+
+Contains asynchronous and synchronous clients,
+as well as specific classes for Pocket Option trading.
+"""
+
+__all__ = [
+    "asynchronous",
+    "synchronous",
+    "PocketOptionAsync",
+    "PocketOption",
+    "RawHandler",
+    "RawHandlerSync",
+]
+
+from . import asynchronous, synchronous
+from .asynchronous import PocketOptionAsync, RawHandler
+from .synchronous import PocketOption, RawHandlerSync