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

{dijkies-0.0.3.dist-info → dijkies-0.1.1.dist-info}/METADATA

@@ -1,20 +1,19 @@
 Metadata-Version: 2.3
 Name: dijkies
-Version: 0.0.3
+Version: 0.1.1
 Summary: A python framework that can be used to create, test and deploy trading algorithms.
 Author: Arnold Dijk
 Author-email: Arnold Dijk <arnold.dijk@teamrockstars.nl>
 License: MIT
-Requires-Dist: mlflow>=3.7.0
 Requires-Dist: pandas>=2.3.3
-Requires-Dist: pre-commit>=4.5.0
 Requires-Dist: pydantic>=2.12.5
-Requires-Dist: pytest>=9.0.2
 Requires-Dist: python-binance>=1.0.33
 Requires-Dist: python-bitvavo-api>=1.4.3
-Requires-Dist: ta>=0.11.0
-Requires-Dist: tenacity>=9.1.2
 Requires-Python: >=3.11
+Project-URL: Documentation, https://github.com/ArnoldDijk/dijkies/blob/dev/README.md
+Project-URL: Homepage, https://github.com/ArnoldDijk/dijkies
+Project-URL: Issues, https://github.com/ArnoldDijk/dijkies/issues
+Project-URL: Source, https://github.com/ArnoldDijk/dijkies
 Description-Content-Type: text/markdown
 
 # Dijkies
@@ -53,19 +52,19 @@ At a high level, Dijkies operates as follows:
 
 ## Key Design Principles
 
-- **Strategy–Executor separation**  
+- **Strategy–Executor separation**
   Trading logic is completely decoupled from execution logic.
 
-- **Single interface for backtesting and live trading**  
+- **Single interface for backtesting and live trading**
   Switching between backtesting and live trading requires no strategy changes.
 
-- **Explicit state management**  
+- **Explicit state management**
   All balances and positions are tracked in a transparent `State` object.
 
-- **Minimal assumptions**  
+- **Minimal assumptions**
   Dijkies does not enforce indicators, timeframes, or asset types.
 
-- **Composable and extensible**  
+- **Composable and extensible**
   New exchanges, execution models, and risk layers can be added easily.
 
 ## Who Is This For?
@@ -92,19 +91,25 @@ This quick start shows how to define a strategy, fetch market data, and run a ba
 
 ### 1. Define a Strategy
 
-A strategy is a class that inherits from `Strategy` and implements the `execute` method.  
+A strategy is a class that inherits from `Strategy` and implements the `execute` method.
 It receives a rolling dataframe of candles and decides when to place orders.
 
 ```python
-from dijkies.strategy import Strategy
+# create strategy
+
 from dijkies.executors import ExchangeAssetClient
+from dijkies.strategy import Strategy
+
 from ta.momentum import RSIIndicator
-import pandas as pd
+from pandas.core.frame import DataFrame as PandasDataFrame
+
+from dijkies.executors import BacktestExchangeAssetClient, State
+
+from dijkies.data_pipeline import DataPipeline, NoDataPipeline
 
 
 class RSIStrategy(Strategy):
-    # Amount of historical data passed into execute()
-    analysis_dataframe_size_in_minutes = 60 * 24 * 30  # 30 days
+    analysis_dataframe_size_in_minutes = 60*24*30
 
     def __init__(
         self,
@@ -116,25 +121,39 @@ class RSIStrategy(Strategy):
         self.higher_threshold = higher_threshold
         super().__init__(executor)
 
-    def execute(self, candle_df: pd.DataFrame) -> None:
-        candle_df["rsi"] = RSIIndicator(candle_df.close).rsi()
+    def execute(self, candle_df: PandasDataFrame) -> None:
+        candle_df["momentum_rsi"] = RSIIndicator(candle_df.close).rsi()
 
-        previous = candle_df.iloc[-2]
-        current = candle_df.iloc[-1]
+        previous_candle = candle_df.iloc[-2]
+        current_candle = candle_df.iloc[-1]
 
-        # Buy when RSI crosses below lower threshold
-        if previous.rsi > self.lower_threshold and current.rsi < self.lower_threshold:
+        is_buy_signal = (
+            previous_candle.momentum_rsi > self.lower_threshold
+            and current_candle.momentum_rsi < self.lower_threshold
+        )
+
+        if is_buy_signal:
             self.executor.place_market_buy_order(
                 self.executor.state.base,
                 self.executor.state.quote_available,
             )
 
-        # Sell when RSI crosses above higher threshold
-        if previous.rsi < self.higher_threshold and current.rsi > self.higher_threshold:
+        is_sell_signal = (
+            previous_candle.momentum_rsi < self.higher_threshold
+            and current_candle.momentum_rsi > self.higher_threshold
+        )
+
+        if is_sell_signal:
             self.executor.place_market_sell_order(
                 self.executor.state.base,
                 self.executor.state.base_available,
             )
+
+    def get_data_pipeline(self) -> DataPipeline:
+        """
+        Implement this metho
+        """
+        return NoDataPipeline()
 ```
 
 ### 2. fetch data for your backtest
@@ -143,8 +162,9 @@ Market data is provided as a pandas DataFrame containing OHLCV candles.
 ```python
 from dijkies.exchange_market_api import BitvavoMarketAPI
 
-market_api = BitvavoMarketAPI()
-candle_df = market_api.get_candles(base="XRP", lookback_in_minutest=60*24*365)
+bitvavo_market_api = BitvavoMarketAPI()
+
+candle_df = bitvavo_market_api.get_candles()
 ```
 
 ### 3. Set Up State and BacktestingExecutor
@@ -179,13 +199,129 @@ strategy = RSIStrategy(
     higher_threshold=65,
 )
 
-backtester = Backtester()
-
-results = backtester.run(
+results = strategy.backtest(
     candle_df=candle_df,
-    strategy=strategy,
 )
 
 results.total_value_strategy.plot()
 results.total_value_hodl.plot()
-```
+```
+
+## Deployment & Live Trading
+
+Dijkies supports deploying strategies to live trading environments using the **same strategy code** that is used for backtesting. Deployment is built around a small set of composable components that handle persistence, credentials, execution switching, and bot lifecycle management.
+
+At a high level, deployment works by:
+
+1. Persisting a configured strategy
+2. Attaching a live exchange executor
+3. Running the strategy via a `Bot`
+4. Managing lifecycle states such as *active*, *paused*, and *stopped*
+
+---
+
+## Core Deployment Concepts
+
+### Strategy Persistence
+
+Strategies are **serialized and stored** so they can be resumed, paused, or stopped without losing state.
+
+This includes:
+- Strategy parameters
+- Internal indicators or buffers
+- Account state (balances, open orders, etc.)
+
+Persistence is handled through a `StrategyRepository`.
+
+---
+
+### Strategy Status
+
+Each deployed strategy (bot) exists in one of the following states:
+
+- **active** — strategy is running normally
+- **paused** — strategy execution stopped due to an error
+- **stopped** — strategy has been intentionally stopped
+
+Status transitions are managed automatically by the deployment system.
+
+---
+
+### Executor Switching
+
+One of Dijkies’ key design goals is that **strategies do not know whether they are backtesting or live trading**.
+
+At deployment time, the executor is injected dynamically:
+
+- `BacktestExchangeAssetClient` for backtesting
+- `BitvavoExchangeAssetClient` for live trading
+
+No strategy code changes are required.
+
+---
+
+## Strategy Repository
+
+The `StrategyRepository` abstraction defines how strategies are stored and retrieved.
+
+```python
+class StrategyRepository(ABC):
+    def store(...)
+    def read(...)
+    def change_status(...)
+```
+
+### LocalStrategyRepository
+
+The provided implementation stores strategies locally using pickle.
+
+#### Directory Structure
+
+root/
+└── person_id/
+    └── exchange/
+        └── status/
+            └── bot_id.pkl
+
+```python
+from pathlib import Path
+from dijkies.bot import LocalStrategyRepository
+
+repo = LocalStrategyRepository(Path("./strategies"))
+
+# read
+
+strategy = repo.read(
+    person_id="ArnoldDijk",
+    exchange="bitvavo",
+    bot_id="rsi_bot",
+    status="active"
+)
+
+# store
+
+repo.store(
+    strategy=strategy,
+    person_id="ArnoldDijk",
+    exchange="bitvavo",
+    bot_id="berend_botje",
+    status="active"
+)
+
+# change status
+
+repo.change_status(
+    person_id="ArnoldDijk",
+    exchange="bitvavo",
+    bot_id="berend_botje",
+    from_status="active",
+    to_status="stopped",
+)
+```
+
+This makes it easy to:
+
+- Resume bots after restarts
+- Inspect stored strategies
+- Build higher-level orchestration around the filesystem
+

dijkies-0.1.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+dijkies/__init__.py,sha256=FmmEOqu9R1gE1wBWWIrAIFTF1rI5sEjpsCdrw4RC5Z8,167
+dijkies/data_pipeline.py,sha256=-0557jmH4o4jghDiQzYVU3hzRXOKejIDFpcJWhcW-GY,1395
+dijkies/deployment.py,sha256=8T4b91TRCcZCFe92gIqoCbk0vetbuhrORmDHq6M_5x8,7138
+dijkies/exceptions.py,sha256=Sgbzm3GXSTfKnGf9BMEOjg7ksebjSIg53DqGU6KOUmg,2418
+dijkies/exchange_market_api.py,sha256=RqA59y0f3O8GB8Za9DXkyH5XocVG0wiKuxJ7tRNijkg,7602
+dijkies/executors.py,sha256=oPK62s11uCYooOizm8sNB0oJLevHDHnfAsOa5QNWlig,19386
+dijkies/logger.py,sha256=yrxNyzriXO_WITRsIEWkVQeqLRavHVklFainDO18p7Y,432
+dijkies/performance.py,sha256=bqY3d9-F1NtATwO7FK9JsD-MThEAqLsmWt_ty5Fowzc,5414
+dijkies/strategy.py,sha256=5KJJuBA6_cwD6CZ4_c3_LSJXfMR_wphQ0S9sIv0eXRo,4242
+dijkies-0.1.1.dist-info/WHEEL,sha256=RRVLqVugUmFOqBedBFAmA4bsgFcROUBiSUKlERi0Hcg,79
+dijkies-0.1.1.dist-info/METADATA,sha256=xfWlwdi42OU2aTb3s1MuHG1yXwqGvQ8swP7PKoLLGKI,8881
+dijkies-0.1.1.dist-info/RECORD,,

{dijkies-0.0.3.dist-info → dijkies-0.1.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.18
+Generator: uv 0.9.21
 Root-Is-Purelib: true
 Tag: py3-none-any

dijkies/backtest.py

@@ -1,98 +0,0 @@
-from datetime import datetime, timedelta
-from typing import Optional
-
-import pandas as pd
-from pandas.core.frame import DataFrame as PandasDataFrame
-
-from dijkies.evaluate import EvaluationFramework
-from dijkies.executors import BacktestExchangeAssetClient
-from dijkies.performance import PerformanceInformationRow
-from dijkies.exceptions import (
-    DataTimeWindowShorterThanSuggestedAnalysisWindowError,
-    InvalidExchangeAssetClientError,
-    InvalidTypeForTimeColumnError,
-    MissingOHLCVColumnsError,
-    TimeColumnNotDefinedError,
-)
-from dijkies.strategy import Strategy
-
-
-class Backtester:
-    def __init__(
-        self,
-        evaluation: Optional[EvaluationFramework] = None,
-    ):
-        self.evaluation = evaluation
-
-    @staticmethod
-    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
-
-    def simulate(
-        self,
-        data: PandasDataFrame,
-        strategy: Strategy,
-    ) -> 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 = strategy.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(strategy.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 = strategy.state.total_value_in_quote(start_candle.open)
-        result = []
-
-        for _, candle in simulation_df.iterrows():
-            analysis_df = self.get_analysis_df(data, candle.time, lookback_in_min)
-            strategy.executor.update_current_candle(candle)
-
-            strategy.run(analysis_df)
-
-            result.append(
-                PerformanceInformationRow.from_objects(
-                    candle, start_candle, strategy.state, start_value_in_quote
-                )
-            )
-
-        return pd.DataFrame([r.dict() for r in result])
-
-    def run(
-        self,
-        candle_df: PandasDataFrame,
-        strategy: Strategy,
-    ) -> PandasDataFrame:
-
-        results = self.simulate(candle_df, strategy)
-        if isinstance(self.evaluation, EvaluationFramework):
-            self.evaluation.evaluate(results)
-
-        return results

dijkies/credentials.py

@@ -1,6 +0,0 @@
-from pydantic import BaseModel
-
-
-class Credentials(BaseModel):
-    api_key: str
-    api_secret_key: str

dijkies/evaluate.py

@@ -1,235 +0,0 @@
-import logging
-import os
-import tempfile
-from abc import ABC, abstractmethod
-from datetime import datetime, timezone
-from typing import Optional, Union
-
-import matplotlib.pyplot as plt
-import mlflow
-import pandas as pd
-from pandas.core.frame import DataFrame as PandasDataFrame
-
-from dijkies.performance import Metric
-
-
-class EvaluationFramework(ABC):
-    @abstractmethod
-    def evaluate(self, performance_results: PandasDataFrame) -> None:
-        pass
-
-
-class MLFlowEvaluator(ABC):
-    @abstractmethod
-    def evaluate(self, performance_results: PandasDataFrame) -> None:
-        pass
-
-
-class MLFlowEvaluationFramework(EvaluationFramework):
-    def __init__(
-        self,
-        evaluators: list[MLFlowEvaluator],
-        experiment_name: str,
-        logger: logging.Logger,
-        strategy_parameters: Optional[dict[str, Union[int, str, float, bool]]],
-        log_dataset: bool = False,
-    ) -> None:
-        self.evaluators = evaluators
-        self.logger = logger
-        self.experiment_name = experiment_name
-        self.log_dataset = log_dataset
-        self.strategy_parameters = strategy_parameters
-
-    def evaluate(self, performance_results: PandasDataFrame) -> None:
-        mlflow.set_experiment(self.experiment_name)
-        # for results:
-        # poetry run mlflow server --host 127.0.0.1 --port 8080
-
-        run_name = "run__" + datetime.now(tz=timezone.utc).strftime("%Y_%m_%d_%H_%M%Z")
-
-        with mlflow.start_run(run_name=run_name) as run:
-            run_id = run.info.run_id
-            self.logger.info("Run created: " + run_id)
-            if self.log_dataset:
-                dataset = mlflow.data.from_pandas(
-                    performance_results, source="local", name="training_data"
-                )
-                mlflow.log_input(dataset, context="training")
-                mlflow.log_params(self.strategy_parameters)
-                with tempfile.TemporaryDirectory() as tmpdir:
-                    file_path = os.path.join(tmpdir, "data.csv")
-                    performance_results.to_csv(file_path, index=False)
-                    mlflow.log_artifact(file_path)
-
-            [
-                evaluator.evaluate(performance_results) for evaluator in self.evaluators
-            ]  # type: ignore
-
-
-class MLFlowOverallEvaluator(MLFlowEvaluator):
-    def __init__(self, metrics: list[Metric], logger: logging.Logger) -> None:
-        self.metrics = metrics
-        self.logger = logger
-
-    def log_metrics(self, performance_results: PandasDataFrame) -> None:
-        for metric in self.metrics:
-            mlflow.log_metric(
-                "strategy_" + metric.metric_name,
-                round(metric.calculate(performance_results.total_value_strategy), 2),
-            )
-            mlflow.log_metric(
-                "hodl_" + metric.metric_name,
-                round(metric.calculate(performance_results.total_value_hodl), 2),
-            )
-
-    @staticmethod
-    def plot_fee(performance_results: PandasDataFrame) -> None:
-        plt.figure(figsize=(8, 5))
-        plt.plot(
-            performance_results.candle_time,
-            performance_results.total_fee_paid,
-            color="blue",
-            label="fee",
-        )
-        plt.xlabel("Time")
-        plt.xticks(rotation=45)
-        plt.ylabel("fee paid in €")
-        plt.title("total transaction fee paid to Exchange")
-        plt.grid(True)
-        plt.legend()
-
-        # Log figure directly to MLflow
-        mlflow.log_figure(plt.gcf(), "total_fee_paid.png")
-
-        plt.close()  # free memory
-
-    @staticmethod
-    def plot_balance_fractions(performance_results: PandasDataFrame) -> None:
-        perc_in_quote = (
-            performance_results.balance_total_quote
-            / performance_results.total_value_strategy
-        )
-        perc_in_base = (
-            performance_results.balance_total_base
-            / performance_results.total_value_strategy
-            * performance_results.candle_close
-        )
-
-        plt.figure(figsize=(8, 5))
-        plt.plot(
-            performance_results.candle_time,
-            perc_in_quote,
-            color="blue",
-            label="percentage value in quote",
-        )
-        plt.plot(
-            performance_results.candle_time,
-            perc_in_base,
-            color="red",
-            label="percentage value in base",
-        )
-        plt.xlabel("Time")
-        plt.xticks(rotation=45)
-        plt.ylabel("fraction")
-        plt.title("fraction of total value in quote")
-        plt.grid(True)
-        plt.legend()
-
-        # Log figure directly to MLflow
-        mlflow.log_figure(plt.gcf(), "balance_fractions.png")
-
-        plt.close()  # free memory
-
-    @staticmethod
-    def plot_strategy_vs_hodl(performance_results: PandasDataFrame) -> None:
-        plt.figure(figsize=(8, 5))
-        plt.plot(
-            performance_results.candle_time,
-            performance_results.total_value_strategy,
-            color="blue",
-            label="strategy",
-        )
-        plt.plot(
-            performance_results.candle_time,
-            performance_results.total_value_hodl,
-            color="red",
-            label="hodl",
-        )
-        plt.xlabel("Time")
-        plt.xticks(rotation=45)
-        plt.ylabel("Value")
-        plt.title("strategy vs. hodl")
-        plt.grid(True)
-        plt.legend()
-
-        # Log figure directly to MLflow
-        mlflow.log_figure(plt.gcf(), "overal_result.png")
-
-        plt.close()  # free memory
-
-    def plot_results(self, performance_results: PandasDataFrame) -> None:
-        self.plot_strategy_vs_hodl(performance_results)
-        self.plot_fee(performance_results)
-        self.plot_balance_fractions(performance_results)
-
-    def evaluate(self, performance_results: PandasDataFrame) -> None:
-        self.log_metrics(performance_results)
-        self.plot_results(performance_results)
-
-
-class MLFlowSliceEvaluator(MLFlowEvaluator):
-    def __init__(
-        self, window_size_in_min: int, metrics: list[Metric], logger: logging.Logger
-    ) -> None:
-        self.window_size_in_min = window_size_in_min
-        self.metrics = metrics
-        self.logger = logger
-
-    def results_window_slicer(self, results: PandasDataFrame) -> PandasDataFrame:
-        candle_interval_in_minutes = (
-            results.iloc[1].candle_time - results.iloc[0].candle_time
-        ).total_seconds() / 60
-        window_size = self.window_size_in_min / candle_interval_in_minutes
-
-        evaluation = []
-
-        for sub_result in [
-            results.loc[i : i + window_size]
-            for i in range(len(results) - (int(window_size) + 1))
-        ]:
-            row = {}
-            for metric in self.metrics:
-                row["strategy_" + metric.metric_name] = metric.calculate(
-                    sub_result.total_value_strategy
-                )
-                row["hodl_" + metric.metric_name] = metric.calculate(
-                    sub_result.total_value_hodl
-                )
-            evaluation.append(row)
-
-        return pd.DataFrame(evaluation)
-
-    def plot_results(self, slicer_results: PandasDataFrame) -> None:
-        for col in slicer_results.columns:
-            self.logger.info(f"create plot {col}")
-            plt.figure(figsize=(8, 5))
-            plt.hist(slicer_results[col])
-            plt.title(f"Column: {col}")
-            plt.xlabel(col)
-            plt.grid(True)
-
-            # Log figure directly to MLflow
-            mlflow.log_figure(plt.gcf(), f"{col}.png")
-
-            plt.close()  # free memory
-
-    def log_metrics(self, slicer_results: PandasDataFrame) -> None:
-        for col in slicer_results.columns:
-            self.logger.info(f"compute metrics for {col}")
-            mlflow.log_metric(f"{col}_mean", round(slicer_results[col].mean(), 3))
-            mlflow.log_metric(f"{col}_std", round(slicer_results[col].std(), 3))
-
-    def evaluate(self, performance_results: PandasDataFrame) -> None:
-        slicer_results = self.results_window_slicer(performance_results)
-        self.log_metrics(slicer_results)
-        self.plot_results(slicer_results)

dijkies-0.0.3.dist-info/RECORD

@@ -1,15 +0,0 @@
-dijkies/__init__.py,sha256=FmmEOqu9R1gE1wBWWIrAIFTF1rI5sEjpsCdrw4RC5Z8,167
-dijkies/backtest.py,sha256=Z3U8pijdNwGh_h4dlPtORk3znIOBlTKOaGR-IK-swys,3206
-dijkies/credentials.py,sha256=pwhRsTFnaDOinnRwnplnxAIDS778dPd2awFDmjo3dpY,104
-dijkies/data_pipeline.py,sha256=SK5NCpI5okhwiPOAPTzoDVLgqPH6SGPsT4khNXcf7jI,313
-dijkies/deployment.py,sha256=N8xtF2YTU1wA0RAcwVmJEaXKZnNH94XjutIs7aOFyYo,3638
-dijkies/evaluate.py,sha256=52H87f4E7-1eTDN2CLSKkswtydTIeDSMZdCoXo56woA,8064
-dijkies/exceptions.py,sha256=BLqK0-rmpqx3wtZ8abu19u8ClnsAjkcpz4B22p-YYt0,1907
-dijkies/exchange_market_api.py,sha256=ZH2gD_Z7PkX3KLT1GtG20Xr-bacj4B3IGsJNP7Hz5AE,7606
-dijkies/executors.py,sha256=7GJznhlv2WMP6UjqQeE6s9VQsvzD0Y0okXdJd4rmMdk,20896
-dijkies/logger.py,sha256=yrxNyzriXO_WITRsIEWkVQeqLRavHVklFainDO18p7Y,432
-dijkies/performance.py,sha256=1EoGx0_riiAyOP8G7UQcYwmjt8b8hw4c3UzAgsbpOuE,5416
-dijkies/strategy.py,sha256=4UZpuZcDvtol6RbarUw-K846bZritSDqDirz9w8ycPw,1804
-dijkies-0.0.3.dist-info/WHEEL,sha256=ZyFSCYkV2BrxH6-HRVRg3R9Fo7MALzer9KiPYqNxSbo,79
-dijkies-0.0.3.dist-info/METADATA,sha256=zgh4Zr4w3-yFTLg0le_rKDHMIsMpltd68ZT9AAkTx1w,5717
-dijkies-0.0.3.dist-info/RECORD,,