binaryoptionstoolsv2 0.2.9__tar.gz → 0.2.12__tar.gz

{binaryoptionstoolsv2-0.2.9/python → binaryoptionstoolsv2-0.2.12}/BinaryOptionsToolsV2/BinaryOptionsToolsV2.pyi

@@ -1,4 +1,8 @@
-from typing import Any, Callable, List, Optional
+from typing import Any, Callable, List, Optional, Tuple
+
+class Action:
+    Call: "Action"
+    Put: "Action"
 
 class PyConfig:
     def __init__(
@@ -90,13 +94,15 @@ class RawPocketOption:
         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_chuncked(self, symbol: str, chunck_size: int) -> 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: ...
@@ -141,14 +147,25 @@ class PyVirtualMarket:
     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: ...
 

binaryoptionstoolsv2-0.2.12/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-0.2.9/python → binaryoptionstoolsv2-0.2.12}/BinaryOptionsToolsV2/config.py

@@ -1,25 +1,17 @@
 import json
+import sys
 from dataclasses import dataclass, field
 from typing import Any, Dict, List
 
 
 def _get_pyconfig():
-    """Helper to get the PyConfig class from the compiled Rust module."""
-    try:
-        # First try to import from the package
-        from . import 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 PyConfig
-    except (ImportError, AttributeError):
-        # Fallback to direct import
-        try:
-            from ..BinaryOptionsToolsV2 import PyConfig
-
-            return PyConfig
-        except ImportError:
-            import BinaryOptionsToolsV2
-
-            return getattr(BinaryOptionsToolsV2, "PyConfig")
+    return _mod.PyConfig
 
 
 @dataclass
@@ -35,6 +27,7 @@ class Config:
     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
@@ -49,8 +42,6 @@ class Config:
         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:
@@ -58,21 +49,15 @@ class Config:
 
     @property
     def pyconfig(self) -> Any:
-        """
-        Returns the PyConfig instance for use in Rust code.
-        Once this is accessed, the configuration becomes locked.
-        """
+        """Returns the PyConfig instance for use in Rust code, then locks config."""
         if self._pyconfig is None:
             self._pyconfig = _get_pyconfig()()
-            self._update_pyconfig()
+            self._sync_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")
-
+    def _sync_pyconfig(self):
+        """Sync all Python config fields to the Rust PyConfig instance."""
         if self._pyconfig is None:
             self._pyconfig = _get_pyconfig()()
 
@@ -82,40 +67,37 @@ 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
+
+    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.
-
-        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__})
+        """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.
-
-        Args:
-            json_str: JSON string containing configuration values
-
-        Returns:
-            Config instance
-        """
+        """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.
-
-        Returns:
-            Dictionary containing all configuration values
-        """
+        """Converts the configuration to a dictionary."""
         return {
             "max_allowed_loops": self.max_allowed_loops,
             "sleep_interval": self.sleep_interval,
@@ -123,29 +105,20 @@ 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,
         }
 
     def to_json(self) -> str:
-        """
-        Converts the configuration to a JSON string.
-
-        Returns:
-            JSON string containing all configuration values
-        """
+        """Converts the configuration to a JSON string."""
         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
-        """
+        """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-0.2.9/python → binaryoptionstoolsv2-0.2.12}/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