binaryoptionstoolsv2 0.1.0__cp310-none-win_amd64.whl

BinaryOptionsToolsV2/__init__.py

@@ -0,0 +1,8 @@
+from .BinaryOptionsToolsV2 import *  # noqa: F403
+from .BinaryOptionsToolsV2 import __all__
+
+# optional: include the documentation from the Rust module
+from .BinaryOptionsToolsV2 import __doc__  # noqa: F401
+from . import asyncronous
+from . import syncronous
+__all__ = __all__ + ["asyncronous", "syncronous"]

BinaryOptionsToolsV2/asyncronous.py

@@ -0,0 +1,85 @@
+from BinaryOptionsToolsV2 import connect, RawPocketOption
+import json
+
+# This file contains all the async code for the PocketOption Module
+class PocketOptionAsync:
+    def __init__(self, client: RawPocketOption):
+        self.client = client
+    
+    async def buy(self, asset: str, amount: float, time: int, check_win: bool = False):
+        """
+        Takes the asset, and amount to place a buy trade that will expire in time (in seconds).
+        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
+        """
+        (trade_id, trade) = await self.client.buy(asset, amount, time)
+        if check_win:
+            return await self.check_win(trade_id)   
+        else:
+            trade = json.loads(trade)
+            return trade_id, trade 
+       
+    async def sell(self, asset: str, amount: float, time: int, check_win: bool = False):
+        """
+        Takes the asset, and amount to place a sell trade that will expire in time (in seconds).
+        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
+        """
+        (trade_id, trade) = await self.client.sell(asset, amount, time)
+        if check_win:
+            return await self.check_win(trade_id)   
+        else:
+            trade = json.loads(trade)
+            return trade_id, trade 
+ 
+    async def check_win(self, id: str):
+        """Returns a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)"""
+        trade = await self.client.check_win(id)
+        trade = json.loads(trade)
+        win = trade["profit"]
+        if win > 0:
+            trade["result"] = "win"
+        elif win == 0:
+            trade["result"] = "draw"
+        else:
+            trade["result"] = "loss"
+        return trade
+        
+    async def get_candles(self, asset: str, period: int, offset: int):  
+        """
+        Takes the asset you want to get the candles and return a list of raw candles in dictionary format
+        Each candle contains:
+            * time: using the iso format
+            * open: open price
+            * close: close price
+            * high: highest price
+            * low: lowest price
+        """
+        candles = await self.client.get_candles(asset, period, offset)
+        return json.loads(candles)
+    
+    async def balance(self):
+        "Returns the balance of the account"
+        return json.loads(await self.client.balance())["balance"]
+    
+    async def opened_deals(self):
+        "Returns a list of all the opened deals as dictionaries"
+        return json.loads(await self.client.opened_deals())
+    
+    async def closed_deals(self):
+        "Returns a list of all the closed deals as dictionaries"
+        return json.loads(await self.client.closed_deals())
+    
+    async def payout(self, asset: None | str | list[str] = None):
+        "Returns a dict of asset : payout for each asset, if 'asset' is not None then it will return the payout of the asset or a list of the payouts for each asset it was passed"
+        payout = json.loads(await self.client.payout())
+        if isinstance(asset, str):
+            return payout.get(asset)
+        elif isinstance(asset, list):
+            return [payout.get(ast) for ast in asset]
+        return payout
+    
+async def async_connect(ssid: str, demo: bool) -> PocketOptionAsync:
+    "Use this function to connect to the server, this works as the initialization for the `PocketOptionAsync` class"
+    client = await connect(ssid, demo)
+    return PocketOptionAsync(client)

BinaryOptionsToolsV2/syncronous.py

@@ -0,0 +1,62 @@
+from BinaryOptionsToolsV2.asyncronous import PocketOptionAsync, async_connect
+import asyncio
+
+class PocketOption:
+    def __init__(self, ssid: str, demo: bool):
+        "Creates a new instance of the PocketOption class"
+        self.loop = asyncio.new_event_loop()
+        self._client: PocketOptionAsync = self.loop.run_until_complete(
+            async_connect(ssid, demo)
+        )
+    
+    def __del__(self):
+        self.loop.close()
+
+    def buy(self, asset: str, amount: float, time: int, check_win: bool = False):
+        """
+        Takes the asset, and amount to place a buy trade that will expire in time (in seconds).
+        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
+        future = self.loop.run_in_executor(None, self._client.buy, asset, amount, time, check_win)
+        """
+        return self.loop.run_until_complete(self._client.buy(asset, amount, time, check_win))
+       
+    def sell(self, asset: str, amount: float, time: int, check_win: bool = False):
+        """
+        Takes the asset, and amount to place a sell trade that will expire in time (in seconds).
+        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
+        """
+        return self.loop.run_until_complete(self._client.sell(asset, amount, time, check_win))
+    
+    def check_win(self, id: str):
+        """Returns a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)"""
+        return self.loop.run_in_executor(self._client.check_win(id))
+
+    def get_candles(self, asset: str, period: int, offset: int):
+        """
+        Takes the asset you want to get the candles and return a list of raw candles in dictionary format
+        Each candle contains:
+            * time: using the iso format
+            * open: open price
+            * close: close price
+            * high: highest price
+            * low: lowest price
+        """
+        return self.loop.run_until_complete(self._client.get_candles(asset, period, offset))
+
+    def balance(self):
+        "Returns the balance of the account"
+        return self.loop.run_until_complete(self._client.balance())
+    
+    def opened_deals(self):
+        "Returns a list of all the opened deals as dictionaries"
+        return self.loop.run_until_complete(self._client.opened_deals())
+    
+    def closed_deals(self):
+        "Returns a list of all the closed deals as dictionaries"
+        return self.loop.run_until_complete(self._client.closed_deals())      
+    
+    def payout(self, asset: None | str | list[str] = None):
+        "Returns a dict of asset | payout for each asset, if 'asset' is not None then it will return the payout of the asset or a list of the payouts for each asset it was passed"
+        return self.loop.run_until_complete(self._client.payout(asset))

BinaryOptionsToolsV2-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.3
+Name: BinaryOptionsToolsV2
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Summary: A library to connect to PocketOption using python with async and sync support.
+Home-Page: https://github.com/ChipaDevTeam/BinaryOptionsTools-v2
+License: BSD License (BSD)
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+👉 [Join us on Discord](https://discord.gg/T3FGXcmd)
+# BinaryOptionsTools
+
+**BinaryOptionsTools** is a powerful suite of tools designed to enhance your binary options trading experience. Whether you're looking for analysis, strategy optimization, or execution tools, this project provides a variety of solutions to help you make informed trading decisions.
+

BinaryOptionsToolsV2-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+BinaryOptionsToolsV2-0.1.0.dist-info/METADATA,sha256=-oXIaiXgeWRe_5JpjUYU7DFkLtoVt_7Gebd0IyALHq0,859
+BinaryOptionsToolsV2-0.1.0.dist-info/WHEEL,sha256=WdQznVppN7z1Vmr3uommICdFQ8BTH-_snRK0jTnZY7g,95
+BinaryOptionsToolsV2/asyncronous.py,sha256=kC3-i1Hz8lSYhCVKt70r8_0Iq-5jlKZHlRBxIuYkjuY,3955
+BinaryOptionsToolsV2/syncronous.py,sha256=TZgPqcDixdxIQCjQVS2o1EFm-vS8_4hb9mjvRa0k2BA,3236
+BinaryOptionsToolsV2/__init__.py,sha256=QZyZtpaxGwlQBFjmrCCE0TxB2oFCKDEBcyShTh7BiGI,317
+BinaryOptionsToolsV2/BinaryOptionsToolsV2.cp310-win_amd64.pyd,sha256=bg7_iIiPwLKA5oSx9Xssc4lyTh1bym94eqGmYjBGjZw,4929024
+BinaryOptionsToolsV2-0.1.0.dist-info/RECORD,,

BinaryOptionsToolsV2-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.7.0)
+Root-Is-Purelib: false
+Tag: cp310-none-win_amd64