binaryoptionstoolsv2 0.2.8__tar.gz → 0.2.9__tar.gz

{binaryoptionstoolsv2-0.2.8 → binaryoptionstoolsv2-0.2.9}/BinaryOptionsToolsV2/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "BinaryOptionsToolsV2"
-version = "0.2.8"
+version = "0.2.9"
 edition = "2021"
 authors = ["ChipaDevTeam"]
 description = "Python bindings for binary-options-tools. High-performance library for PocketOption trading automation with async/sync support, real-time data streaming, and WebSocket API access."
@@ -18,17 +18,17 @@ name = "BinaryOptionsToolsV2"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = "0.28.2"
+pyo3 = { version = "0.28.2", features = ["abi3-py39"] }
 pyo3-async-runtimes = { version = "0.28.0", features = ["tokio-runtime"] }
 
 binary_options_tools = { path = "../../crates/binary_options_tools", version = "0.2.0" }
 
-thiserror = "2.0.17"
+thiserror = "2.0.18"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.142"
 uuid = "1.18.0"
 tracing = "0.1.41"
-tokio = "1.49.0"
+tokio = { version = "1.49.0", features = ["rt-multi-thread", "macros", "net", "time", "sync"] }
 futures-util = "0.3.31"
 tracing-subscriber = { version = "0.3.22", features = ["env-filter"] }
 chrono = "0.4.42"

{binaryoptionstoolsv2-0.2.8 → binaryoptionstoolsv2-0.2.9}/BinaryOptionsToolsV2/rust/build.rs

@@ -7,12 +7,15 @@ use std::path::PathBuf;
 fn main() {
     #[cfg(feature = "stubgen")]
     {
-
         // Define stub info gatherer function
         define_stub_info_gatherer!(stub_info);
 
         let crate_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        let python_package_path = crate_root.parent().unwrap().join("python").join("BinaryOptionsToolsV2");
+        let python_package_path = crate_root
+            .parent()
+            .unwrap()
+            .join("python")
+            .join("BinaryOptionsToolsV2");
 
         // Ensure the target directory exists
         std::fs::create_dir_all(&python_package_path)

{binaryoptionstoolsv2-0.2.8 → binaryoptionstoolsv2-0.2.9}/BinaryOptionsToolsV2/rust/src/framework.rs

@@ -2,46 +2,36 @@ use crate::error::BinaryErrorPy;
 use crate::pocketoption::RawPocketOption;
 use crate::runtime::get_runtime;
 
-use binary_options_tools::utils::f64_to_decimal;
 use binary_options_tools::framework::market::Market;
 use binary_options_tools::framework::virtual_market::VirtualMarket;
 use binary_options_tools::framework::{Bot, Context, Strategy};
 use binary_options_tools::pocketoption::candle::Candle;
-use binary_options_tools::pocketoption::error::{PocketResult, PocketError};
+use binary_options_tools::pocketoption::error::{PocketError, PocketResult};
+use binary_options_tools::utils::f64_to_decimal;
 
 use pyo3::prelude::*;
 
-use rust_decimal::Decimal;
-use tracing::info;
 use async_trait::async_trait;
 use rust_decimal::prelude::ToPrimitive;
-use uuid::Uuid;
+use rust_decimal::Decimal;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
+use tracing::info;
+use uuid::Uuid;
 
 #[pyclass(from_py_object)]
 #[derive(Clone)]
 pub enum Action {
     Call,
-    Put,    
+    Put,
 }
 
 #[pyclass(subclass)]
 pub struct PyStrategy {
-    /// A list of the indicators to use
-    /// Each indicator must implement:
-    /// - A method to update its value given a new candle (e.g. `update(candle_json: str)`)
-    /// - A method to reset its state (e.g. `reset()`)
-    /// - A method to get its period (e.g. `period() -> int`)
-    /// No other methods are required as once the loading period is over e.g. the amount of candles passed is greater than 
-    /// the biggest period of the indicators then the strategy will call the on_candle method and pass the update of the 
-    /// indicators to the user.
     indicators: HashMap<String, Py<PyAny>>,
-    // The current candle number, starting from 0. It is incremented by 1 every time a new candle is received. 
-    // Used to know when the loading period is over and the strategy can start trading. It is also useful for the user to know how many candles have passed since the strategy started.
     #[pyo3(get)]
-    current_candle: u32
+    pub current_candle: u32,
 }
 
 #[pymethods]
@@ -61,89 +51,93 @@ impl PyStrategy {
     pub fn on_candle(&self, _ctx: PyContext, _asset: String, _candle_json: String) -> PyResult<()> {
         Ok(())
     }
-    
+
     pub fn on_balance(&self, _ctx: PyContext, _balance: f64) -> PyResult<()> {
         Ok(())
     }
-    
-    /// A way to place a trade synchronously from inside a PyStrategy. The function will block until the trade is executed and return the trade ID and deal information as a JSON string.
-    /// This function should be relativelly fast and should not block the trading loop at all.
-    pub fn trade<'py>(&self, py: Python<'py>, ctx: PyContext, asset: String, amount: f64, timeframe: u32, direction: Action) -> PyResult<Vec<String>>{
+
+    pub fn trade<'py>(
+        &self,
+        py: Python<'py>,
+        ctx: PyContext,
+        asset: String,
+        amount: f64,
+        timeframe: u32,
+        direction: Action,
+    ) -> PyResult<Vec<String>> {
         let market = ctx.market.clone();
         let decimal_amount = f64_to_decimal(amount)
             .ok_or_else(|| BinaryErrorPy::NotAllowed(format!("Invalid amount: {}", amount)))?;
         let trade_future = async move {
             let (id, deal) = match direction {
-                Action::Call =>
-                    market.buy(&asset, decimal_amount, timeframe).await.map_err(BinaryErrorPy::from),
-                    
-                Action::Put =>
-                    market.sell(&asset, decimal_amount, timeframe).await.map_err(BinaryErrorPy::from)
+                Action::Call => market
+                    .buy(&asset, decimal_amount, timeframe)
+                    .await
+                    .map_err(BinaryErrorPy::from),
+
+                Action::Put => market
+                    .sell(&asset, decimal_amount, timeframe)
+                    .await
+                    .map_err(BinaryErrorPy::from),
             }?;
             let trades = Vec::from([
                 id.to_string(),
-                serde_json::to_string(&deal).map_err(BinaryErrorPy::from)?
+                serde_json::to_string(&deal).map_err(BinaryErrorPy::from)?,
             ]);
             Result::<Vec<String>, BinaryErrorPy>::Ok(trades)
         };
-        
+
         Ok(get_runtime(py)?.block_on(trade_future)?)
     }
-    
-    /// Returns the result of a trade given its UUID. The result is serialized as a JSON string.
-    /// The function is synchronous from Python's perspective, but internally it awaits the market's result asynchronously.
-    /// So it's important to call this method when the trade was completed (as it will return the result really fast otherwhise the whole script would be blocked until the trade is completed).
+
     pub fn result<'py>(&self, py: Python<'py>, ctx: PyContext, id: String) -> PyResult<String> {
         let market = ctx.market.clone();
-        let uuid = Uuid::parse_str(&id).map_err(|e| BinaryErrorPy::NotAllowed(format!("Invalid UUID: {}", e)))?;
+        let uuid = Uuid::parse_str(&id)
+            .map_err(|e| BinaryErrorPy::NotAllowed(format!("Invalid UUID: {}", e)))?;
         let future = async move {
             let res = market.result(uuid).await.map_err(BinaryErrorPy::from)?;
             serde_json::to_string(&res).map_err(BinaryErrorPy::from)
         };
         Ok(get_runtime(py)?.block_on(future)?)
     }
-    
-    /// Adds an indicator to the strategy. The indicator must be a Python object that implements the required methods (update, reset, period).
-    /// All the indicators of the `chipa-ta` library are compatible with this method as they implement the required methods. 
-    /// The name parameter is just a string that will be used to identify the indicator and can be any string.
+
     pub fn add(&mut self, name: String, indicator: Py<PyAny>) -> PyResult<()> {
         self.indicators.insert(name.clone(), indicator);
         info!(target: "PyStrategy", "Added indicator '{}' to strategy", name);
         Ok(())
     }
-    
-    /// Gets an indicator by its name. Returns None if the indicator is not found.
+
     pub fn get(&self, name: String) -> PyResult<Option<&Py<PyAny>>> {
         Ok(self.indicators.get(&name))
     }
-    
-    /// Returns the list of current indicators as a tuple (name, indicator_str) where name is the name of the indicator and indicator_str is the string representation of the indicator (`__str__`).
+
     pub fn list_indicators(&self) -> PyResult<Vec<(String, String)>> {
-        self.indicators.iter().map(|(name, indicator)| {
-            let indicator_str = Python::attach(|py| {
-                indicator.call_method0(py, "__str__")?.extract::<String>(py)
-                
-            })?;
-            Ok((name.clone(), indicator_str))
-        }).collect()
-        
+        self.indicators
+            .iter()
+            .map(|(name, indicator)| {
+                let indicator_str = Python::attach(|py| {
+                    indicator.call_method0(py, "__str__")?.extract::<String>(py)
+                })?;
+                Ok((name.clone(), indicator_str))
+            })
+            .collect()
     }
-    
-    /// Called internally by the framework when a new candle is received. It updates all the indicators with the new candle. The candle is serialized as a JSON string.
-    /// It works untill period() is completed
+
     pub fn update<'py>(&mut self, candle: String) -> PyResult<()> {
         self.current_candle += 1;
         for indicator in self.indicators.values() {
             Python::attach(|py| {
-                indicator.call_method1(py, "update", (candle.clone(), )).map_err(|e| {
-                    BinaryErrorPy::NotAllowed(format!("Failed to update indicator: {}", e))
-                })
+                indicator
+                    .call_method1(py, "update", (candle.clone(),))
+                    .map_err(|e| {
+                        BinaryErrorPy::NotAllowed(format!("Failed to update indicator: {}", e))
+                    })
             })?;
         }
         info!(target: "PyStrategy", "Updated indicators with new candle: {}", self.current_candle);
         Ok(())
     }
-    
+
     pub fn reset(&mut self) -> PyResult<()> {
         for indicator in self.indicators.values() {
             Python::attach(|py| {
@@ -155,16 +149,23 @@ impl PyStrategy {
         self.current_candle = 0;
         Ok(())
     }
-    
+
     pub fn period(&self) -> PyResult<u32> {
         let mut max_period = 0;
         for indicator in self.indicators.values() {
             let period: u32 = Python::attach(|py| {
-                indicator.call_method0(py, "period").map_err(|e| {
-                    BinaryErrorPy::NotAllowed(format!("Failed to get period from indicator: {}", e))
-                })?.extract(py).map_err(|e| {
-                    BinaryErrorPy::NotAllowed(format!("Failed to extract period as u32: {}", e))
-                })
+                indicator
+                    .call_method0(py, "period")
+                    .map_err(|e| {
+                        BinaryErrorPy::NotAllowed(format!(
+                            "Failed to get period from indicator: {}",
+                            e
+                        ))
+                    })?
+                    .extract(py)
+                    .map_err(|e| {
+                        BinaryErrorPy::NotAllowed(format!("Failed to extract period as u32: {}", e))
+                    })
             })?;
             if period > max_period {
                 max_period = period;
@@ -191,73 +192,52 @@ impl Strategy for StrategyWrapper {
                     client: Some(client),
                     market,
                 };
-                inner.call_method1(py, "on_start", (py_ctx,)).map_err(|e| {
-                    PocketError::General(format!(
-                        "Python on_start error: {}",
-                        e
-                    ))
-                })
+                inner
+                    .call_method1(py, "on_start", (py_ctx,))
+                    .map_err(|e| PocketError::General(format!("Python on_start error: {}", e)))
             })
             .map(|_| ())
         })
         .await
-        .map_err(|e| {
-            PocketError::General(format!(
-                "Spawn blocking error: {}",
-                e
-            ))
-        })??;
+        .map_err(|e| PocketError::General(format!("Spawn blocking error: {}", e)))??;
         Ok(())
     }
 
     async fn on_candle(&self, ctx: &Context, asset: &str, candle: &Candle) -> PocketResult<()> {
-        let candle_json = serde_json::to_string(candle).map_err(|e| {
-            PocketError::General(e.to_string())
-        })?;
+        let candle_json =
+            serde_json::to_string(candle).map_err(|e| PocketError::General(e.to_string()))?;
         let asset = asset.to_string();
         let inner = Python::attach(|py| self.inner.clone_ref(py));
         let client = ctx.client.clone();
         let market = ctx.market.clone();
-        let period = Python::attach(|py| inner.call_method0(py, "period").map_err(|e| {
-            PocketError::General(format!(
-                "Python period error: {}",
-                e
-            ))
-        }).map(|obj| obj.extract::<u32>(py)))?
-        .map_err(|e| {
-            PocketError::General(format!(
-                "Python period extract error: {}",
-                e
-            ))
+        let period = Python::attach(|py| {
+            inner
+                .call_method0(py, "period")
+                .map_err(|e| PocketError::General(format!("Python period error: {}", e)))
+                .map(|obj| obj.extract::<u32>(py))
+        })?
+        .map_err(|e| PocketError::General(format!("Python period extract error: {}", e)))?;
+        let current_candle = Python::attach(|py| {
+            inner
+                .getattr(py, "current_candle")
+                .map_err(|e| PocketError::General(format!("Python current_candle error: {}", e)))
+                .and_then(|obj| {
+                    obj.extract::<u32>(py).map_err(|e| {
+                        PocketError::General(format!("Python current_candle extract error: {}", e))
+                    })
+                })
         })?;
-        let current_candle = Python::attach(|py| inner.getattr(py, "current_candle").map_err(|e| {
-            PocketError::General(format!(
-                "Python current_candle error: {}",
-                e
-            ))
-        }).and_then(|obj| obj.extract::<u32>(py).map_err(|e| {
-            PocketError::General(format!(
-                "Python current_candle extract error: {}",
-                e
-            ))
-        })))?;
-        
+
         if current_candle < period {
-            // Just update the indicators and return, the strategy is not ready to trade yet
-            
             Python::attach(|py| {
-                inner.call_method1(py, "update", (candle_json.clone(),)).map_err(|e| {
-                    PocketError::General(format!(
-                        "Python update error: {}",
-                        e
-                    ))
-                })
+                inner
+                    .call_method1(py, "update", (candle_json.clone(),))
+                    .map_err(|e| PocketError::General(format!("Python update error: {}", e)))
             })?;
-            // Since the method update is called current_candles is incremented by 1, so we add 1 to it to show the user the correct number of candles that have passed since the strategy started.
             info!(target: "StrategyWrapper", "Loading period: candle {} of {}", current_candle +1, period);
             return Ok(());
         }
-        
+
         tokio::task::spawn_blocking(move || -> PocketResult<()> {
             Python::attach(|py| {
                 let py_ctx = PyContext {
@@ -266,28 +246,18 @@ impl Strategy for StrategyWrapper {
                 };
                 inner
                     .call_method1(py, "on_candle", (py_ctx, asset, candle_json))
-                    .map_err(|e| {
-                        PocketError::General(format!(
-                            "Python on_candle error: {}",
-                            e
-                        ))
-                    })
+                    .map_err(|e| PocketError::General(format!("Python on_candle error: {}", e)))
             })
             .map(|_| ())
         })
         .await
-        .map_err(|e| {
-            PocketError::General(format!(
-                "Spawn blocking error: {}",
-                e
-            ))
-        })??;
-        
+        .map_err(|e| PocketError::General(format!("Spawn blocking error: {}", e)))??;
+
         Ok(())
     }
-    
+
     async fn on_balance_update(&self, ctx: &Context, balance: Decimal) -> PocketResult<()> {
-        let balance = balance.to_f64().unwrap_or(-1.0); // -1 default to know there is an error converting the balance to f64, but it should never happen as the balance should be always a valid decimal that can be converted to f64 without losing too much precision (the balance is usually a small number with few decimals).
+        let balance = balance.to_f64().unwrap_or(-1.0); // -1.0 indicates a conversion error, though it shouldnt happen often- awaiting this should be fine and if anything u can just asyncio wait like 5 seconds
         let inner = Python::attach(|py| self.inner.clone_ref(py));
         let client = ctx.client.clone();
         let market = ctx.market.clone();
@@ -299,22 +269,12 @@ impl Strategy for StrategyWrapper {
                 };
                 inner
                     .call_method1(py, "on_balance", (py_ctx, balance))
-                    .map_err(|e| {
-                        PocketError::General(format!(
-                            "Python on_balance error: {}",
-                            e
-                        ))
-                    })
+                    .map_err(|e| PocketError::General(format!("Python on_balance error: {}", e)))
             })
             .map(|_| ())
         })
         .await
-        .map_err(|e| {
-            PocketError::General(format!(
-                "Spawn blocking error: {}",
-                e
-            ))
-        })??;
+        .map_err(|e| PocketError::General(format!("Spawn blocking error: {}", e)))??;
 
         Ok(())
     }
@@ -329,6 +289,12 @@ pub struct PyContext {
 
 #[pymethods]
 impl PyContext {
+    /// Places a buy (Call) order asynchronously.
+    ///
+    /// :param asset: The asset to trade (e.g. "EURUSD_otc").
+    /// :param amount: The amount to trade.
+    /// :param time: The duration of the trade in seconds.
+    /// :return: A list [trade_id, deal_json].
     pub fn buy<'py>(
         &self,
         py: Python<'py>,
@@ -350,6 +316,9 @@ impl PyContext {
         })
     }
 
+    /// Fetches the current balance asynchronously.
+    ///
+    /// :return: The current balance as a float.
     pub fn balance<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         let market = self.market.clone();
         pyo3_async_runtimes::tokio::future_into_py(py, async move {
@@ -378,6 +347,12 @@ impl PyVirtualMarket {
         })
     }
 
+    /// Updates the price of an asset in the virtual market.
+    /// This is an asynchronous method.
+    ///
+    /// :param asset: The asset identifier.
+    /// :param price: The new price.
+    /// :return: None
     pub fn update_price<'py>(
         &self,
         py: Python<'py>,
@@ -415,7 +390,7 @@ impl PyBot {
         }
         Self { inner: Some(bot) }
     }
-    
+
     pub fn with_update_interval(&mut self, millis: u64) -> PyResult<()> {
         if let Some(bot) = &mut self.inner {
             bot.with_update_interval(Duration::from_millis(millis));
@@ -444,6 +419,10 @@ impl PyBot {
         }
     }
 
+    /// Runs the bot's execution loop.
+    /// This is an asynchronous method that will block the current task until the bot is stopped.
+    ///
+    /// :return: None
     pub fn run<'py>(&mut self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         let mut bot = self.inner.take().ok_or_else(|| {
             PyErr::new::<pyo3::exceptions::PyRuntimeError, _>("Bot already running or consumed")

{binaryoptionstoolsv2-0.2.8 → binaryoptionstoolsv2-0.2.9}/BinaryOptionsToolsV2/rust/src/pocketoption.rs

@@ -504,10 +504,16 @@ impl RawPocketOption {
         lookback_period: u32,
     ) -> PyResult<Bound<'py, PyAny>> {
         if custom_period == 0 {
-            return Err(BinaryErrorPy::InvalidParameter("custom_period must be non-zero".to_string()).into());
+            return Err(BinaryErrorPy::InvalidParameter(
+                "custom_period must be non-zero".to_string(),
+            )
+            .into());
         }
         if lookback_period == 0 {
-            return Err(BinaryErrorPy::InvalidParameter("lookback_period must be non-zero".to_string()).into());
+            return Err(BinaryErrorPy::InvalidParameter(
+                "lookback_period must be non-zero".to_string(),
+            )
+            .into());
         }
         let client = self.client.clone();
         future_into_py(py, async move {