BinaryOptionsToolsV2 0.2.12__cp39-abi3-win32.whl

BinaryOptionsToolsV2/BinaryOptionsToolsV2.pyi

@@ -0,0 +1,172 @@
+from typing import Any, Callable, List, Optional, Tuple
+
+class Action:
+    Call: "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: ...
+
+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 get_closed_deal(self, id: str) -> Optional[str]: ...
+    async def clear_closed_deals(self) -> None: ...
+    async def opened_deals(self) -> str: ...
+    async def get_opened_deal(self, id: str) -> Optional[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_chunked(self, symbol: str, chunk_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:
+    current_candle: int
+    def __init__(self) -> None: ...
+    def on_start(self, ctx: PyContext) -> None: ...
+    def on_candle(self, ctx: PyContext, asset: str, candle_json: str) -> None: ...
+    def on_balance(self, ctx: PyContext, balance: float) -> None: ...
+    def trade(self, ctx: PyContext, asset: str, amount: float, timeframe: int, direction: Action) -> List[str]: ...
+    def result(self, ctx: PyContext, id: str) -> str: ...
+    def add(self, name: str, indicator: Any) -> None: ...
+    def get(self, name: str) -> Optional[Any]: ...
+    def list_indicators(self) -> List[Tuple[str, str]]: ...
+    def update(self, candle: str) -> None: ...
+    def reset(self) -> None: ...
+    def period(self) -> int: ...
+
+class PyBot:
+    def __init__(
+        self, client: RawPocketOption, strategy: PyStrategy, virtual_market: Optional[PyVirtualMarket] = None
+    ) -> None: ...
+    def with_update_interval(self, millis: int) -> 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,60 @@
+import importlib
+import os
+import sys
+from .config import Config as Config
+from . import tracing as tracing
+from . import validator as validator
+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
+try:
+    _rust_module = importlib.import_module(".BinaryOptionsToolsV2", __package__)
+except (ImportError, ValueError):
+    try:
+        _rust_module = importlib.import_module("BinaryOptionsToolsV2")
+        if _rust_module is sys.modules.get(__package__):
+            _rust_module = None
+    except ImportError:
+        pass
+
+if _rust_module is not None:
+    globals().update({k: v for k, v in _rust_module.__dict__.items() if not k.startswith("_")})
+elif os.environ.get("PYTEST_CURRENT_TEST"):
+    print(f"[ERROR] Rust extension module not found (__package__={__package__})")
+
+# 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",
+]
+__rust_all__ = [n for n in _rust_exported_names if n in globals()]
+
+__all__ = list(
+    set(
+        __pocket_all__
+        + ["tracing", "validator", "PocketOptionAsync", "PocketOption", "RawHandler", "Validator"]
+        + __rust_all__
+    )
+)

BinaryOptionsToolsV2/config.py

@@ -0,0 +1,124 @@
+import json
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+
+def _get_pyconfig():
+    """Get the PyConfig class from the compiled Rust module via package namespace."""
+    pkg = sys.modules.get(__package__ or "")
+    if pkg is not None and hasattr(pkg, "PyConfig"):
+        return pkg.PyConfig
+    import BinaryOptionsToolsV2 as _mod
+
+    return _mod.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)
+    max_subscriptions: int = 4
+
+    # 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:
+        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, then locks config."""
+        if self._pyconfig is None:
+            self._pyconfig = _get_pyconfig()()
+            self._sync_pyconfig()
+        self._locked = True
+        return self._pyconfig
+
+    def _sync_pyconfig(self):
+        """Sync all Python config fields to the Rust PyConfig instance."""
+        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
+        self._pyconfig.max_subscriptions = self.max_subscriptions
+
+    def _validate(self):
+        """Validate config values, raising ValueError on invalid input."""
+        if self.max_allowed_loops < 0:
+            raise ValueError("max_allowed_loops must be non-negative")
+        if self.sleep_interval < 0:
+            raise ValueError("sleep_interval must be non-negative")
+        if self.reconnect_time < 1:
+            raise ValueError("reconnect_time must be at least 1 second")
+        if self.connection_initialization_timeout_secs < 1:
+            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":
+        """Creates a Config instance from a dictionary."""
+        cfg = cls(**{k: v for k, v in config_dict.items() if k in cls.__dataclass_fields__})
+        cfg._validate()
+        return cfg
+
+    @classmethod
+    def from_json(cls, json_str: str) -> "Config":
+        """Creates a Config instance from a JSON string."""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Converts the configuration to a dictionary."""
+        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,
+            "max_subscriptions": self.max_subscriptions,
+            "terminal_logging": self.terminal_logging,
+            "log_level": self.log_level,
+            "extra_duration": self.extra_duration,
+        }
+
+    def to_json(self) -> str:
+        """Converts the configuration to a JSON string."""
+        return json.dumps(self.to_dict())
+
+    def update(self, config_dict: Dict[str, Any]) -> None:
+        """Updates config from a dictionary. Raises RuntimeError if locked."""
+        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,21 @@
+"""
+Module for Pocket Option related functionality.
+
+Contains asynchronous and synchronous clients,
+as well as specific classes for Pocket Option trading.
+"""
+
+__all__ = [
+    "asynchronous",
+    "login",
+    "login_async",
+    "PocketOptionAsync",
+    "PocketOption",
+    "RawHandler",
+    "RawHandlerSync",
+    "Validator",
+]
+from .tools.login import login, login_async
+from . import asynchronous, synchronous as synchronous
+from .asynchronous import PocketOptionAsync, RawHandler, Validator
+from .synchronous import PocketOption, RawHandlerSync