binaryoptionstoolsv2 0.2.8__tar.gz → 0.2.11__tar.gz

{binaryoptionstoolsv2-0.2.8/python → binaryoptionstoolsv2-0.2.11}/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.11/BinaryOptionsToolsV2/__init__.py

@@ -0,0 +1,36 @@
+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, PocketOption, __all__ as __pocket_all__  # noqa: F401
+
+# 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"] + __rust_all__))

{binaryoptionstoolsv2-0.2.8/python → binaryoptionstoolsv2-0.2.11}/BinaryOptionsToolsV2/config.py

@@ -1,143 +1,124 @@
-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)
+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)