roboquant 2.3.1__tar.gz → 2.3.2__tar.gz

{roboquant-2.3.1 → roboquant-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboquant
-Version: 2.3.1
+Version: 2.3.2
 Summary: A fast algorithmic trading platform with support for AI based strategies
 Keywords: algorithmic,trading,machine learning,AI,investment,finance,crypto,stocks,exchange,forex
 Author: roboquant team

{roboquant-2.3.1 → roboquant-2.3.2}/pyproject.toml

@@ -19,7 +19,7 @@ module-name = "roboquant"
 
 [project]
 name = "roboquant"
-version = "2.3.1"
+version = "2.3.2"
 authors = [{ name = "roboquant team", email = "info@roboquant.org" }]
 description = "A fast algorithmic trading platform with support for AI based strategies"
 readme = "README.md"

{roboquant-2.3.1 → roboquant-2.3.2}/roboquant/feeds/feed.py

@@ -13,7 +13,7 @@ class Feed(ABC):
     It provides methods for playing the events and some smaller utility methods, like plotting prices.
 
     Although the most common type of events are those containing market data, other types of
-    events are also possible. For example, events containing news items or social media sentiment could
+    events are also possible. For example, events containing news items or social media posts could
     also be represented as a feed.
     """
 

{roboquant-2.3.1 → roboquant-2.3.2}/roboquant/feeds/parquet.py

@@ -213,3 +213,4 @@ class ParquetFeed(Feed):
             if items:
                 batch = pa.RecordBatch.from_pylist(items, schema=ParquetFeed.__schema)
                 writer.write_batch(batch)
+

{roboquant-2.3.1 → roboquant-2.3.2}/roboquant/journals/metricsjournal.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from datetime import datetime
 
 from roboquant.journals.journal import Journal
@@ -9,6 +10,55 @@ from roboquant.event import Event
 from roboquant.order import Order
 from typing import Dict, List
 
+from roboquant.timeframe import Timeframe
+
+@dataclass
+class TimeSeries:
+    name: str
+    timeline: list[datetime]
+    values: list[float]
+
+    def __post_init__(self):
+        if len(self.timeline) != len(self.values):
+            raise ValueError("Timeline and values must have the same length")
+
+    def __len__(self):
+        return len(self.timeline)
+
+    def timeframe(self) -> Timeframe:
+        """Return the timeframe of the time series. If the time series is empty,
+        an empty timeframe will be returned."""
+        return Timeframe(self.timeline[0], self.timeline[-1], True) if len(self) > 0 else Timeframe.EMPTY
+
+    def plot(self, plot_x: bool = True, ax = None, **kwargs):
+        """Plot one of the metrics. Optional a `matplotlib.axes.Axes` can be provided
+        This requires matplotlib to be installed."""
+        if not ax:
+            from matplotlib import pyplot as plt
+            _, ax = plt.subplots()
+
+        if plot_x:
+            result = ax.plot(self.timeline, self.values, **kwargs)  # type: ignore
+        else:
+            result = ax.plot(self.values, **kwargs)
+
+        ax.set_title(self.name)
+        return result
+
+    def to_dataframe(self, time_index: bool = False):
+        """Return the timeseries as a Pandas dataframe optionally with the time being the index
+        and the value being the column.
+        """
+        import pandas as pd
+
+        d = {
+            "time": self.timeline,
+            "value": self.values
+        }
+        df = pd.DataFrame.from_dict(d, orient="columns")
+        df.Name = self.name
+        return df.set_index("time") if time_index else df  # type: ignore
+
 
 class MetricsJournal(Journal):
     """
@@ -36,7 +86,7 @@ class MetricsJournal(Journal):
 
         self._history.append((event.time, result))
 
-    def get_metric(self, metric_name: str) -> tuple[list[datetime], list[float]]:
+    def get_metric(self, metric_name: str) -> TimeSeries:
         """Return the calculated values of a metric as tuple of date-times and float values"""
         timeline: list[datetime] = []
         values: list[float] = []
@@ -44,38 +94,7 @@ class MetricsJournal(Journal):
             if metric_name in metrics:
                 timeline.append(time)
                 values.append(metrics[metric_name])
-        return timeline, values
-
-    def to_dataframe(self, metric_name: str, time_index: bool = False):
-        """Return the metric as a Pandas dataframe optionally with the time being the index
-        and the value being the column.
-        """
-        import pandas as pd
-
-        times, values = self.get_metric(metric_name)
-        d = {
-            "time": times,
-            "value": values
-        }
-        df = pd.DataFrame.from_dict(d, orient="columns")
-        return df.set_index("time") if time_index else df  # type: ignore
-
-    def plot(self, metric_name: str, plot_x: bool = True, ax = None, **kwargs):
-        """Plot one of the metrics. Optional a `matplotlib.axes.Axes` can be provided
-        This requires matplotlib to be installed."""
-        if not ax:
-            from matplotlib import pyplot as plt
-            _, ax = plt.subplots()
-
-        x, y = self.get_metric(metric_name)
-
-        if plot_x:
-            result = ax.plot(x, y, **kwargs)  # type: ignore
-        else:
-            result = ax.plot(y, **kwargs)
-
-        ax.set_title(metric_name)
-        return result
+        return TimeSeries(metric_name, timeline, values)
 
     def get_metric_names(self) -> list[str]:
         """Return a list of the recorded metric names"""

{roboquant-2.3.1 → roboquant-2.3.2}/roboquant/journals/scorecard.py

@@ -23,9 +23,11 @@ class _Timeseries:
 class ScoreCard(Journal):
     """Tracks progress of a run so it can be plotted using matplotlib charts afterwards.
     It will track the following aspects:
-    - the price of a single asset
-    - the orders for that asset
-    - any metric that is provided
+    - the price of the assets
+    - the orders for that asset as markers on the price chart
+    - any additional metric that has been provided
+
+    This works best on smaller runs with a limited number of assets and orders.
     """
 
     def __init__(self, *metrics: Metric, include_prices: bool = True, price_type: str = "DEFAULT"):
@@ -56,7 +58,7 @@ class ScoreCard(Journal):
             for name, value in result.items():
                 self._metric_results[name].add(time, value)
 
-    def plot(self, **kwargs):
+    def plot(self, size: tuple[float, float] = (8.27, 11.69), **kwargs):
         """Plot a chart with the following sub-charts:
         - prices of the configured asset. Orders als small green up (BUY) and red down (SELL) triangles.
         - metrics that have been configured, each in their own chart.
@@ -71,7 +73,7 @@ class ScoreCard(Journal):
         if not hasattr(axes, "__getitem__"):
             axes = [axes]
 
-        fig.set_size_inches(8.27, 11.69)  # A4
+        fig.set_size_inches(size)
         fig.tight_layout()
 
         plot_nr = 0

{roboquant-2.3.1 → roboquant-2.3.2}/roboquant/strategies/emacrossover.py

@@ -1,5 +1,3 @@
-from datetime import timedelta
-
 from roboquant.signal import Signal
 from roboquant.asset import Asset
 from roboquant.event import Event
@@ -7,13 +5,15 @@ from roboquant.strategies.strategy import Strategy
 
 
 class EMACrossover(Strategy):
-    """Trading strategy based on a fast and slow exponential moving average.
+    """Trading strategy based on a fast and slow Exponential Moving Average.
 
-    The strategy tracks each asset independently and emits a buy signal when
+    This strategy tracks each asset independently and emits a buy signal when
     the fast EMA crosses above the slow EMA, and a sell signal when it crosses
     below. Signals are only generated after enough prices have been observed to
-    cover the longer EMA period. The constructor controls the fast and slow
-    periods, smoothing factor, and the event price type used as input.
+    cover the longer EMA period.
+
+    The constructor controls the fast and slow periods, smoothing factor,
+    and the event price type used as input.
     """
 
     def __init__(self, fast_period: int = 13, slow_period: int = 26, smoothing: float = 2.0, price_type: str = "DEFAULT"):
@@ -23,7 +23,6 @@ class EMACrossover(Strategy):
         self.slow = 1.0 - (smoothing / (slow_period + 1))
         self.price_type = price_type
         self.min_steps = max(fast_period, slow_period)
-        self.cancel_orders_older_than = timedelta(days=5)
 
     def create_signals(self, event: Event) -> list[Signal]:
         result : list[Signal] = []