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

dijkies/executors.py

@@ -1,38 +1,29 @@
+import logging
+import time
+import uuid
 from abc import ABC, abstractmethod
+from decimal import ROUND_DOWN, Decimal, getcontext
 from typing import Literal, Optional, Union
 
-from pydantic import BaseModel
-
-import uuid
-import time
-
 import pandas as pd
 from pandas.core.series import Series
-
-
-import json
-import logging
-
-from decimal import Decimal, getcontext, ROUND_DOWN
-from tenacity import retry, wait_fixed, stop_after_attempt
-
+from pydantic import BaseModel
 from python_bitvavo_api.bitvavo import Bitvavo
 
 from dijkies.exceptions import (
-    NoOrderFoundError,
-    MultipleOrdersFoundError,
-    PlaceOrderError,
     GetOrderInfoError,
-    CancelOrderError,
-    MethodNotDefinedError
+    InsufficientBalanceError,
+    InsufficientOrderValueError,
+    MultipleOrdersFoundError,
+    NoOrderFoundError,
 )
 
-from dijkies.credentials import Credentials
+SUPPORTED_EXCHANGES = Literal["bitvavo", "backtest"]
 
 
 class Order(BaseModel):
     order_id: str
-    exchange: Literal["bitvavo"]
+    exchange: SUPPORTED_EXCHANGES
     market: str
     time_created: int
     time_canceled: Union[int, None] = None
@@ -173,12 +164,6 @@ class ExchangeAssetClient(ABC):
     def __init__(self, state: State) -> None:
         self.state = state
 
-    def clear_credentials(self) -> None:
-        raise MethodNotDefinedError()
-
-    def set_credentials(self, credentials: Credentials) -> None:
-        raise MethodNotDefinedError()
-
     @abstractmethod
     def place_limit_buy_order(
         self, base: str, limit_price: float, amount_in_quote: float
@@ -221,7 +206,7 @@ class BacktestExchangeAssetClient(ExchangeAssetClient):
         super().__init__(state)
         self.fee_market_order = fee_market_order
         self.fee_limit_order = fee_limit_order
-        self.current_candle = pd.Series({"high": 0, "low": 0})
+        self.current_candle = pd.Series({"high": 80000, "low": 78000, "close": 79000})
 
     def update_current_candle(self, current_candle: Series) -> None:
         self.current_candle = current_candle
@@ -336,6 +321,7 @@ class BacktestExchangeAssetClient(ExchangeAssetClient):
             filled = order.on_hold
             filled_quote = order.on_hold * order.limit_price  # type: ignore
             fee = filled_quote * fee_limit_order
+        order.fee = fee
         return Order(
             order_id=order.order_id,
             exchange=order.exchange,
@@ -393,7 +379,7 @@ class BitvavoExchangeAssetClient(ExchangeAssetClient):
         bitvavo_api_key: str,
         bitvavo_api_secret_key: str,
         operator_id: int,
-        logger: logging.Logger
+        logger: logging.Logger,
     ) -> None:
         super().__init__(state)
         self.operator_id = operator_id
@@ -409,19 +395,9 @@ class BitvavoExchangeAssetClient(ExchangeAssetClient):
         )
         self.logger = logger
 
-    def set_credentials(self, api_key: str, api_secret_key: str) -> None:
-        self.bitvavo.APIKEY = api_key
-        self.bitvavo.APISECRET = api_secret_key
-
-    def clear_credentials(self) -> None:
-        self.bitvavo.APIKEY = ""
-        self.bitvavo.APISECRET = ""
-
     def quantity_decimals(self, base: str) -> int:
         trading_pair = base + "-EUR"
-        return self.bitvavo.markets(
-            {'market': trading_pair}
-        )['quantityDecimals']
+        return self.bitvavo.markets({"market": trading_pair})["quantityDecimals"]
 
     @staticmethod
     def __closest_valid_price(price: float) -> float:
@@ -445,7 +421,14 @@ class BitvavoExchangeAssetClient(ExchangeAssetClient):
 
         return float(corrected)
 
-    @retry(wait=wait_fixed(2), stop=stop_after_attempt(2))
+    def get_balance(self, base: str) -> dict[str, float]:
+        balance = self.bitvavo.balance({"symbol": base})
+        if balance:
+            balance = balance[0]
+        else:
+            balance = {"available": 0, "inOrder": 0}
+        return balance
+
     def place_limit_buy_order(
         self, base: str, limit_price: float, amount_in_quote: float
     ) -> Order:
@@ -468,30 +451,23 @@ class BitvavoExchangeAssetClient(ExchangeAssetClient):
             },
         )
         if "errorCode" in response:
-            true_balance = self.bitvavo.balance({"symbol": "EUR"})[0]
-            error_message = \
-                f"""
-                failed to place limit buy-order\n\n
-
-                trading_pair: {trading_pair}\n
-                limit_price: {limit_price}\n
-                amount_in_quote: {amount_in_quote}\n\n
-                available: {true_balance['available']}\n\n
-                in orders: {true_balance['inOrder']}\n\n
+            error_code = response["errorCode"]
+            if error_code in [107, 108, 109]:
+                time.sleep(3)
+                order = self.place_limit_buy_order(base, limit_price, amount_in_quote)
+                return order
+            elif error_code == 216:
+                balance = self.get_balance(base)
+                raise InsufficientBalanceError(balance, amount_in_base)
+            elif error_code == 217:
+                raise InsufficientOrderValueError()
+            else:
+                raise Exception(str(response))
 
-                error: \n\n
-
-                {response}
-                """
-            self.logger.error(error_message)
-            raise PlaceOrderError(error_message)
-
-        self.logger.info(f"limit order placed: {json.dumps(response)}")
         order = order_from_bitvavo_response(response)
         self.state.add_order(order)
         return order
 
-    @retry(wait=wait_fixed(2), stop=stop_after_attempt(2))
     def place_limit_sell_order(
         self, base: str, limit_price: float, amount_in_base: float
     ) -> Order:
@@ -499,7 +475,7 @@ class BitvavoExchangeAssetClient(ExchangeAssetClient):
 
         quantity_decimals = self.quantity_decimals(base)
 
-        factor = 1 / (10 ** quantity_decimals)
+        factor = 1 / (10**quantity_decimals)
         amount_in_base = round(
             (float(amount_in_base) // factor) * factor,
             quantity_decimals,
@@ -518,33 +494,24 @@ class BitvavoExchangeAssetClient(ExchangeAssetClient):
             },
         )
         if "errorCode" in response:
-            true_balance = self.bitvavo.balance({"symbol": base})[0]
-            error_message = \
-                f"""
-                failed to place limit buy-order\n\n
-
-                trading_pair: {trading_pair}\n
-                limit_price: {limit_price}\n
-                amount_in_base: {amount_in_base}\n\n
-                available: {true_balance['available']}\n\n
-                in orders: {true_balance['inOrder']}\n\n
+            error_code = response["errorCode"]
+            if error_code in [107, 108, 109]:
+                time.sleep(3)
+                order = self.place_limit_sell_order(base, limit_price, amount_in_base)
+                return order
+            elif error_code == 216:
+                balance = self.get_balance(base)
+                raise InsufficientBalanceError(balance, amount_in_base)
+            elif error_code == 217:
+                raise InsufficientOrderValueError()
+            else:
+                raise Exception(str(response))
 
-                error: \n\n
-
-                {response}
-                """
-            self.logger.error(error_message)
-            raise PlaceOrderError(error_message)
-
-        self.logger.info(f"limit order placed: {json.dumps(response)}")
         order = order_from_bitvavo_response(response)
         self.state.add_order(order)
         return order
 
-    # @retry(wait=wait_fixed(2), stop=stop_after_attempt(2))
-    def place_market_buy_order(
-        self, base: str, amount_in_quote: float
-    ) -> Order:
+    def place_market_buy_order(self, base: str, amount_in_quote: float) -> Order:
         trading_pair = base + "-EUR"
 
         amount_in_quote = str(round(float(amount_in_quote), 2))
@@ -556,34 +523,30 @@ class BitvavoExchangeAssetClient(ExchangeAssetClient):
             body={"amountQuote": amount_in_quote, "operatorId": self.operator_id},
         )
         if "errorCode" in response:
+            error_code = response["errorCode"]
+            if error_code in [107, 108, 109]:
+                time.sleep(3)
+                order = self.place_market_buy_order(base, amount_in_quote)
+                return order
+            elif error_code == 216:
+                balance = self.get_balance("EUR")
+                raise InsufficientBalanceError(balance, amount_in_quote)
+            elif error_code == 217:
+                raise InsufficientOrderValueError()
+            else:
+                raise Exception(str(response))
 
-            error_message = \
-                f"""
-                failed to place market buy-order\n\n
-                trading_pair: {trading_pair}\n
-                amount_in_quote: {amount_in_quote}\n\n
-                error:\n\n
-                {response}
-                """
-
-            self.logger.error(error_message)
-            raise PlaceOrderError(error_message)
-
-        self.logger.info(f"market buy order placed: {json.dumps(response)}")
         order = order_from_bitvavo_response(response)
         time.sleep(3)
         order = self.get_order_info(order)
         self.state.process_filled_order(order)
         return order
 
-    @retry(wait=wait_fixed(2), stop=stop_after_attempt(2))
-    def place_market_sell_order(
-        self, base: str, amount_in_base: float
-    ) -> Order:
+    def place_market_sell_order(self, base: str, amount_in_base: float) -> Order:
         trading_pair = base + "-EUR"
         quantity_decimals = self.quantity_decimals(base)
 
-        factor = 1 / (10 ** quantity_decimals)
+        factor = 1 / (10**quantity_decimals)
         amount_in_base = round(
             (float(amount_in_base) // factor) * factor,
             quantity_decimals,
@@ -595,47 +558,33 @@ class BitvavoExchangeAssetClient(ExchangeAssetClient):
             body={"amount": str(amount_in_base), "operatorId": self.operator_id},
         )
         if "errorCode" in response:
-            error_message = \
-                f"""
-                failed to place market sell-order\n\n
-                trading_pair: {trading_pair}\n
-                amount_in_base: {amount_in_base}\n\n
-                error:\n\n
-                {response}
-                """
-            self.logger.error(error_message)
-            raise PlaceOrderError(error_message)
-
-        self.logger.info(f"market sell order placed: {json.dumps(response)}")
+            error_code = response["errorCode"]
+            if error_code in [107, 108, 109]:
+                time.sleep(3)
+                order = self.place_market_sell_order(base, amount_in_base)
+                return order
+            elif error_code == 216:
+                balance = self.get_balance(base)
+                raise InsufficientBalanceError(balance, amount_in_base)
+            elif error_code == 217:
+                raise InsufficientOrderValueError()
+            else:
+                raise Exception(str(response))
+
         order = order_from_bitvavo_response(response)
         time.sleep(3)
         order = self.get_order_info(order)
         self.state.process_filled_order(order)
         return order
 
-    @retry(wait=wait_fixed(2), stop=stop_after_attempt(2))
-    def get_order_info(
-        self, order: Order
-    ) -> Order:
+    def get_order_info(self, order: Order) -> Order:
 
-        response = self.bitvavo.getOrder(
-            market=order.market, orderId=order.order_id
-        )
+        response = self.bitvavo.getOrder(market=order.market, orderId=order.order_id)
         if "errorCode" in response:
-            error_message = \
-                f"""
-                failed to retrieve order information\n\n
-                order: {order.order_id}\n 
-                trading_pair: {order.market}\n\n 
-                error: \n\n
-
-                {response}
-                """
-            self.logger.exception(error_message)
-            raise GetOrderInfoError(response)
+            if response["errorCode"] == 240:
+                raise GetOrderInfoError(response)
         return order_from_bitvavo_response(response)
 
-    @retry(wait=wait_fixed(2), stop=stop_after_attempt(2))
     def cancel_order(self, order: Order) -> Order:
         response = self.bitvavo.cancelOrder(
             market=order.market,
@@ -643,23 +592,6 @@ class BitvavoExchangeAssetClient(ExchangeAssetClient):
             operatorId=self.operator_id,
         )
         if "errorCode" in response:
-            error_message = \
-                f"""
-                failed to cancel order\n\n
-                trading_pair: {order.market}\n
-                order_id: {order.order_id}\n\n
-                error:\n\n
-
-                {response}
-                """
-
-            self.logger.exception(error_message)
-
-            if not (
-                response["errorCode"] == 240 and
-                "No active order found." in response["error"]
-            ):
-                raise CancelOrderError(response)
-
-        self.logger.info(f"order cancelled: {order.order_id}")
+            if response["errorCode"] != 240:
+                raise GetOrderInfoError(response)
         self.state.cancel_order(order)

dijkies/performance.py

@@ -1,12 +1,10 @@
-from abc import ABC, abstractmethod
-
-import numpy as np
-from pandas.core.series import Series as PandasSeries
-
 import uuid
+from abc import ABC, abstractmethod
 from datetime import datetime
 
+import numpy as np
 from pandas.core.series import Series
+from pandas.core.series import Series as PandasSeries
 from pydantic import BaseModel
 
 from dijkies.executors import State

dijkies/strategy.py

@@ -1,10 +1,20 @@
 import inspect
 from abc import ABC, abstractmethod
+from datetime import datetime, timedelta
 
+import pandas as pd
 from pandas.core.frame import DataFrame as PandasDataFrame
 
-from dijkies.executors import ExchangeAssetClient
 from dijkies.data_pipeline import DataPipeline
+from dijkies.exceptions import (
+    DataTimeWindowShorterThanSuggestedAnalysisWindowError,
+    InvalidExchangeAssetClientError,
+    InvalidTypeForTimeColumnError,
+    MissingOHLCVColumnsError,
+    TimeColumnNotDefinedError,
+)
+from dijkies.executors import BacktestExchangeAssetClient, ExchangeAssetClient
+from dijkies.performance import PerformanceInformationRow
 
 
 class Strategy(ABC):
@@ -56,13 +66,64 @@ class Strategy(ABC):
     def analysis_dataframe_size_in_minutes(self) -> int:
         pass
 
-    @property
-    @abstractmethod
-    def exchange(self) -> str:
-        pass
-
     def get_data_pipeline(self) -> DataPipeline:
         """
         implement this method for deployement
         """
         raise NotImplementedError()
+
+    def backtest(self, data: PandasDataFrame) -> PandasDataFrame:
+        """
+        This method runs the backtest. It expects data, this should have the following properties:
+        """
+
+        # validate args
+
+        if "time" not in data.columns:
+            raise TimeColumnNotDefinedError()
+
+        if not pd.api.types.is_datetime64_any_dtype(data.time):
+            raise InvalidTypeForTimeColumnError()
+
+        lookback_in_min = self.analysis_dataframe_size_in_minutes
+        timespan_data_in_min = (data.time.max() - data.time.min()).total_seconds() / 60
+
+        if lookback_in_min > timespan_data_in_min:
+            raise DataTimeWindowShorterThanSuggestedAnalysisWindowError()
+
+        if not {"open", "high", "low", "close", "volume"}.issubset(data.columns):
+            raise MissingOHLCVColumnsError()
+
+        if not isinstance(self.executor, BacktestExchangeAssetClient):
+            raise InvalidExchangeAssetClientError()
+
+        start_time = data.iloc[0].time + timedelta(minutes=lookback_in_min)
+        simulation_df: PandasDataFrame = data.loc[data.time >= start_time]
+        start_candle = simulation_df.iloc[0]
+        start_value_in_quote = self.state.total_value_in_quote(start_candle.open)
+        result: list[PerformanceInformationRow] = []
+
+        def get_analysis_df(
+            data: PandasDataFrame, current_time: datetime, look_back_in_min: int
+        ) -> PandasDataFrame:
+            start_analysis_df = current_time - timedelta(minutes=look_back_in_min)
+
+            analysis_df = data.loc[
+                (data.time >= start_analysis_df) & (data.time <= current_time)
+            ]
+
+            return analysis_df
+
+        for _, candle in simulation_df.iterrows():
+            analysis_df = get_analysis_df(data, candle.time, lookback_in_min)
+            self.executor.update_current_candle(candle)
+
+            self.run(analysis_df)
+
+            result.append(
+                PerformanceInformationRow.from_objects(
+                    candle, start_candle, self.state, start_value_in_quote
+                )
+            )
+
+        return pd.DataFrame([r.model_dump() for r in result])