dijkies 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

dijkies/data_pipeline.py

@@ -3,6 +3,8 @@ from abc import ABC, abstractmethod
 import pandas as pd
 from pandas.core.frame import DataFrame as PandasDataFrame
 
+from dijkies.exchange_market_api import ExchangeMarketAPI
+
 
 class DataPipeline(ABC):
     @abstractmethod
@@ -10,6 +12,35 @@ class DataPipeline(ABC):
         pass
 
 
-class NoDataPipeline(ABC):
+class NoDataPipeline(DataPipeline):
+    def run(self) -> PandasDataFrame:
+        return pd.DataFrame([{}], columns=["close"])
+
+
+class CurrentValueDataPipeline(DataPipeline):
+    def __init__(self, base: str, exchange_market_api: ExchangeMarketAPI) -> None:
+        self.exchange_market_api = exchange_market_api
+        self.base = base
+
+    def run(self) -> PandasDataFrame:
+        current_price = self.exchange_market_api.get_price(self.base)
+        return pd.DataFrame([{"close": current_price}])
+
+
+class OHLCVDataPipeline(DataPipeline):
+    def __init__(
+        self,
+        exchange_market_api: ExchangeMarketAPI,
+        base: str,
+        candle_interval_in_minutes: int,
+        lookback_in_minutes: int,
+    ) -> None:
+        self.exchange_market_api = exchange_market_api
+        self.base = base
+        self.candle_interval_in_minutes = candle_interval_in_minutes
+        self.lookback_in_minutes = lookback_in_minutes
+
     def run(self) -> PandasDataFrame:
-        return pd.DataFrame({})
+        return self.exchange_market_api.get_candles(
+            self.base, self.candle_interval_in_minutes, self.lookback_in_minutes
+        )

dijkies/deployment.py

@@ -1,94 +1,140 @@
 import os
-import json
 import pickle
-
+import shutil
 from abc import ABC, abstractmethod
-
-from dijkies.strategy import Strategy
-from dijkies.executors import State
-from dijkies.credentials import Credentials
-from dijkies.executors import BitvavoExchangeAssetClient
+from pathlib import Path
+from typing import Literal
+
+from dijkies.executors import (
+    SUPPORTED_EXCHANGES,
+    BacktestExchangeAssetClient,
+    BitvavoExchangeAssetClient,
+)
 from dijkies.logger import get_logger
+from dijkies.strategy import Strategy
 
+BOT_STATUS = Literal["active", "paused", "stopped"]
+ASSET_HANDLING = Literal["quote_only", "base_only", "ignore"]
 
-class StrategyRepository(ABC):
-    @abstractmethod
-    def store(self, strategy: Strategy, id: str) -> None:
-        pass
 
+class StrategyRepository(ABC):
     @abstractmethod
-    def store_state(self, state: State, id: str) -> None:
+    def store(
+        self,
+        strategy: Strategy,
+        person_id: str,
+        exchange: SUPPORTED_EXCHANGES,
+        bot_id: str,
+        status: BOT_STATUS,
+    ) -> None:
         pass
 
     @abstractmethod
-    def read(self, id: str) -> Strategy:
+    def read(
+        self,
+        person_id: str,
+        exchange: SUPPORTED_EXCHANGES,
+        bot_id: str,
+        status: BOT_STATUS,
+    ) -> Strategy:
         pass
 
     @abstractmethod
-    def read_state(self, id: str) -> State:
+    def change_status(
+        self,
+        person_id: str,
+        exchange: SUPPORTED_EXCHANGES,
+        bot_id: str,
+        from_status: BOT_STATUS,
+        to_status: BOT_STATUS,
+    ) -> None:
         pass
 
 
 class LocalStrategyRepository(StrategyRepository):
-    def __init__(self, root_directory: str) -> None:
+    def __init__(self, root_directory: Path) -> None:
         self.root_directory = root_directory
 
-    def store(self, strategy: Strategy, id: str):
-        path = os.path.join(self.root_directory, id + ".pkl")
+    def store(
+        self,
+        strategy: Strategy,
+        person_id: str,
+        exchange: SUPPORTED_EXCHANGES,
+        bot_id: str,
+        status: BOT_STATUS,
+    ) -> None:
+        (self.root_directory / person_id / exchange / status).mkdir(
+            parents=True, exist_ok=True
+        )
+        path = os.path.join(
+            self.root_directory, person_id, exchange, status, bot_id + ".pkl"
+        )
         with open(path, "wb") as file:
             pickle.dump(strategy, file)
 
-    def store_state(self, state: State, id: str) -> None:
-        path = os.path.join(self.root_directory, "state_" + id, ".json")
-        with open(path, "w") as file:
-            json.dump(state, file)
-
-    def read(self, id: str) -> Strategy:
-        path = os.path.join(self.root_directory, id + ".pkl")
+    def read(
+        self,
+        person_id: str,
+        exchange: SUPPORTED_EXCHANGES,
+        bot_id: str,
+        status: BOT_STATUS,
+    ) -> Strategy:
+        path = os.path.join(
+            self.root_directory, person_id, exchange, status, bot_id + ".pkl"
+        )
         with open(path, "rb") as file:
             strategy = pickle.load(file)
         return strategy
 
-    def read_state(self, id: str) -> State:
-        path = os.path.join(self.root_directory, "state_" + id, ".json")
-        with open(path, "r") as file:
-            state = json.load(file)
-        return state
+    def change_status(
+        self,
+        person_id: str,
+        exchange: SUPPORTED_EXCHANGES,
+        bot_id: str,
+        from_status: BOT_STATUS,
+        to_status: BOT_STATUS,
+    ) -> None:
+        if from_status == to_status:
+            return
+        src = (
+            Path(f"{self.root_directory}/{person_id}/{exchange}/{from_status}")
+            / f"{bot_id}.pkl"
+        )
+        dest_folder = Path(f"{self.root_directory}/{person_id}/{exchange}/{to_status}")
+
+        dest_folder.mkdir(parents=True, exist_ok=True)
+        shutil.move(src, dest_folder / src.name)
 
 
 class CredentialsRepository(ABC):
     @abstractmethod
-    def get_api_key(self, id: str) -> str:
+    def get_api_key(self, person_id: str, exchange: str) -> str:
         pass
 
     @abstractmethod
-    def store_api_key(self, id: str, api_key: str) -> None:
+    def store_api_key(self, person_id: str, exchange: str, api_key: str) -> None:
         pass
 
     @abstractmethod
-    def get_api_secret_key(self, id: str) -> str:
+    def get_api_secret_key(self, person_id: str, exchange: str) -> str:
         pass
 
     @abstractmethod
-    def store_api_secret_key(self, id: str, api_secret_key: str) -> None:
+    def store_api_secret_key(
+        self, person_id: str, exchange: str, api_secret_key: str
+    ) -> None:
         pass
 
-    def get_credentials(self, id: str) -> Credentials:
-        return Credentials(
-            api_key=self.get_api_key(id),
-            api_secret_key=self.get_api_secret_key(id)
-        )
-
 
-class LocalCredentialRepository(CredentialsRepository):
-    def get_api_key(self, id: str) -> str:
-        return os.environ.get(f"{id}_api_key")
+class LocalCredentialsRepository(CredentialsRepository):
+    def get_api_key(self, person_id: str, exchange: str) -> str:
+        return os.environ.get(f"{person_id}_{exchange}_api_key")
 
-    def store_api_key(self, id: str, api_key: str) -> None:
+    def store_api_key(self, person_id: str, exchange: str, api_key: str) -> None:
         pass
 
-    def get_api_secret_key(self, id: str) -> str:
-        return os.environ.get(f"{id}_api_secret_key")
+    def get_api_secret_key(self, person_id: str, exchange: str) -> str:
+        return os.environ.get(f"{person_id}_{exchange}_api_secret_key")
 
     def store_api_secret_key(self, id: str, api_secret_key: str) -> None:
         pass
@@ -103,25 +149,92 @@ class Bot:
         self.strategy_repository = strategy_repository
         self.credential_repository = credential_repository
 
-    def set_executor(self, strategy: Strategy):
-        api_key = self.credential_repository.get_api_key(id)
-        api_secret_key = self.credential_repository.get_api_secret_key(id)
-
-        if strategy.exchange == "bitvavo":
+    def set_executor(
+        self,
+        strategy: Strategy,
+        person_id: str,
+        exchange: SUPPORTED_EXCHANGES,
+    ) -> None:
+        if exchange == "bitvavo":
+            api_key = self.credential_repository.get_api_key(person_id, exchange)
+            api_secret_key = self.credential_repository.get_api_secret_key(
+                person_id, exchange
+            )
             strategy.executor = BitvavoExchangeAssetClient(
-                strategy.state,
-                api_key,
-                api_secret_key,
-                1,
-                get_logger()
+                strategy.state, api_key, api_secret_key, 1, get_logger()
+            )
+        elif exchange == "backtest":
+            strategy.executor = BacktestExchangeAssetClient(
+                strategy.state, 0.0025, 0.0015
             )
+        else:
+            raise Exception("exchange not defined")
+
+    def run(
+        self,
+        person_id: str,
+        exchange: SUPPORTED_EXCHANGES,
+        bot_id: str,
+        status: BOT_STATUS,
+    ) -> None:
 
-    def run(self, id: str) -> None:
-        strategy = self.strategy_repository.read(id)
-        self.set_executor(strategy)
+        strategy = self.strategy_repository.read(person_id, exchange, bot_id, status)
+        self.set_executor(strategy, person_id, exchange)
 
         data_pipeline = strategy.get_data_pipeline()
         data = data_pipeline.run()
-        strategy.run(data)
 
-        self.strategy_repository.store(strategy)
+        try:
+            strategy.run(data)
+            self.strategy_repository.store(
+                strategy, person_id, exchange, bot_id, status
+            )
+        except Exception as e:
+            self.strategy_repository.store(
+                strategy, person_id, exchange, bot_id, status
+            )
+            self.strategy_repository.change_status(
+                person_id, exchange, bot_id, status, "paused"
+            )
+            raise Exception(e)
+
+    def stop(
+        self,
+        person_id: str,
+        exchange: SUPPORTED_EXCHANGES,
+        bot_id: str,
+        status: BOT_STATUS,
+        asset_handling: ASSET_HANDLING,
+    ) -> None:
+        if status == "stopped":
+            return
+
+        strategy = self.strategy_repository.read(person_id, exchange, bot_id, status)
+        self.set_executor(strategy, person_id, exchange)
+
+        try:
+            for open_order in strategy.state.open_orders:
+                _ = strategy.executor.cancel_order(open_order)
+            if asset_handling == "base_only":
+                _ = strategy.executor.place_market_buy_order(
+                    strategy.state.base, strategy.state.quote_available
+                )
+            elif asset_handling == "quote_only":
+                _ = strategy.executor.place_market_sell_order(
+                    strategy.state.base, strategy.state.base_available
+                )
+            self.strategy_repository.store(
+                strategy, person_id, exchange, bot_id, status
+            )
+            self.strategy_repository.change_status(
+                person_id, exchange, bot_id, status, "stopped"
+            )
+
+        except Exception as e:
+            self.strategy_repository.store(
+                strategy, person_id, exchange, bot_id, status
+            )
+            self.strategy_repository.change_status(
+                person_id, exchange, bot_id, status, "paused"
+            )
+            raise Exception(e)

dijkies/exceptions.py

@@ -58,3 +58,26 @@ class CancelOrderError(Exception):
 class MethodNotDefinedError(Exception):
     def __init__(self):
         super().__init__("method not implemented...")
+
+
+class InsufficientBalanceError(Exception):
+    def __init__(
+        self,
+        balance: dict[str, float],
+        requested: float,
+    ):
+        super().__init__(
+            f"""
+            not enough balance:\n
+            available: {balance["available"]}, requested: {requested}\n
+            """
+        )
+
+
+class InsufficientOrderValueError(Exception):
+    def __init__(self):
+        super().__init__(
+            """
+            order value should be at least 5 euro:
+            """
+        )

dijkies/exchange_market_api.py

@@ -1,17 +1,13 @@
-from abc import ABC, abstractmethod
-
-from pandas.core.frame import DataFrame as PandasDataFrame
-
 import logging
-
-import pandas as pd
-import requests
-from binance.client import Client
-
 import threading
 import time
+from abc import ABC, abstractmethod
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
+import pandas as pd
+import requests
+from binance.client import Client
+from pandas.core.frame import DataFrame as PandasDataFrame
 from python_bitvavo_api.bitvavo import Bitvavo
 
 from dijkies.logger import get_logger