roboquant 2.3.3__tar.gz → 2.4.0__tar.gz

{roboquant-2.3.3 → roboquant-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboquant
-Version: 2.3.3
+Version: 2.4.0
 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
@@ -121,6 +121,3 @@ Roboquant is made available under the Apache 2.0 license. You can read more abou
 Absolutely no warranty is implied with this product. Use at your own risk. I provide no guarantee that it will be profitable, or that it won't lose all your money very quickly or does not contain bugs.
 
 All financial trading offers the possibility of loss. Leveraged trading, may result in you losing all your money, and still owing more. Back tested results are no guarantee of future performance. I can take no responsibility for any losses caused by live trading using roboquant. Use at your own risk. I am not registered or authorised by any financial regulator.
-
-## Kotlin version
-Next to this Python version of `roboquant`, there is also a Kotlin version available. Both share a similar API, just the used computer language is different. Which one to use depends very much on personal preferences, skills and usage.

{roboquant-2.3.3 → roboquant-2.4.0}/README.md

@@ -79,6 +79,3 @@ Roboquant is made available under the Apache 2.0 license. You can read more abou
 Absolutely no warranty is implied with this product. Use at your own risk. I provide no guarantee that it will be profitable, or that it won't lose all your money very quickly or does not contain bugs.
 
 All financial trading offers the possibility of loss. Leveraged trading, may result in you losing all your money, and still owing more. Back tested results are no guarantee of future performance. I can take no responsibility for any losses caused by live trading using roboquant. Use at your own risk. I am not registered or authorised by any financial regulator.
-
-## Kotlin version
-Next to this Python version of `roboquant`, there is also a Kotlin version available. Both share a similar API, just the used computer language is different. Which one to use depends very much on personal preferences, skills and usage.

{roboquant-2.3.3 → roboquant-2.4.0}/pyproject.toml

@@ -19,7 +19,7 @@ module-name = "roboquant"
 
 [project]
 name = "roboquant"
-version = "2.3.3"
+version = "2.4.0"
 authors = [{ name = "roboquant team", email = "info@roboquant.org" }]
 description = "A fast algorithmic trading platform with support for AI based strategies"
 readme = "README.md"
@@ -84,4 +84,3 @@ dev = [
   "ipywidgets>=8.1.6",
   "chronos-forecasting>=2.3.1",
 ]
-talib = ["ta-lib==0.6.5"]

{roboquant-2.3.3 → roboquant-2.4.0}/roboquant/__init__.py

@@ -17,6 +17,7 @@ from .monetary import Amount, Wallet
 from .asset import Asset, Stock, Crypto, Forex, Option
 from .run import run
 from .timeframe import Timeframe, utcnow
+from .timeseries import TimeSeries
 
 __all__ = [
     "brokers",
@@ -43,5 +44,6 @@ __all__ = [
     "Option",
     "run",
     "Timeframe",
+    "TimeSeries",
     "utcnow",
 ]

{roboquant-2.3.3 → roboquant-2.4.0}/roboquant/account.py

@@ -32,7 +32,7 @@ class Trade:
 @dataclass(slots=True)
 class Position:
     """The position of an asset in the account. The position prices are denoted in the currency of the asset that
-    is linked to this posistion. See also `Account.positions`.
+    is linked to this posistion. See also :meth:`roboquant.Account.positions`.
     """
 
     size: Decimal
@@ -212,32 +212,14 @@ class Account:
 
     def pnl(self) -> Wallet:
         """
-        Return the total profit and loss of the account, which is the sum of realized and unrealized PnL.
+        Return the total profit and loss of the account, which is
+        the sum of realized and unrealized PnL.
 
         Returns:
             Wallet: The total profit and loss.
         """
         return self.realized_pnl() + self.unrealized_pnl()
 
-    def required_buying_power(self, order: Order) -> Amount:
-        """
-        Return the amount of buying power required for a certain order. The underlying logic takes into
-        account that a reduction in position size doesn't require buying power.
-
-        Args:
-            order (Order): The order for which to calculate the required buying power.
-
-        Returns:
-            Amount: The required buying power as an Amount.
-        """
-        pos_size = self.get_position_size(order.asset)
-
-        # Only buying power required if the remaining order size increases the position size
-        if abs(pos_size + order.remaining) > abs(pos_size):
-            return order.asset.contract_amount(abs(order.remaining), order.limit)
-
-        return Amount(order.asset.currency, 0.0)
-
     def unrealized_pnl_value(self) -> float:
         """
         Return the unrealized profit and loss value denoted in the base currency of the account.
@@ -261,7 +243,10 @@ class Account:
         return pos.size if pos else Decimal()
 
     def get_position_list(self) -> list[dict[str, Any]]:
-        """Return all open positions including their pnl as a list of dicts"""
+        """Return all open positions including their pnl as a list of dicts.
+        This comes in handy for further processing, like converting
+        them to a dataframe.
+        """
         result: list[dict[str, Any]] = []
         for asset, pos in self.positions.items():
             result.append(
@@ -280,7 +265,9 @@ class Account:
         return result
 
     def get_order_list(self) -> list[dict[str, Any]]:
-        """Return all open orders as a list of dicts"""
+        """Return all open orders as a list of dicts.
+        This comes in handy for further processing, like converting
+        them to a dataframe."""
         result: list[dict[str, Any]] = []
         for order in self.orders:
             result.append(
@@ -306,7 +293,21 @@ class Account:
                 return order
 
     def __repr__(self) -> str:
-        """Condensed representation of this account."""
+        """Condensed representation of this account. It by default won't
+        display decimals for the various amounts. But you can use the float
+        formatting spec to influence this behavior: f"{account:{.4f}}"
+        """
+        return f"{self:,.0f}"
+
+    def __format__(self, format_spec: str) -> str:
+        """Return a float formatted string representation of the wallet.
+
+        Args:
+            format_spec (str): The format specification.
+
+        Returns:
+            str: The formatted string representation.
+        """
         p = [f"{v.size}@{k.symbol}" for k, v in self.positions.items()]
         p_str = ", ".join(p) or "none"
 
@@ -316,12 +317,12 @@ class Account:
         mkt = self.mkt_value() or Amount(self.base_currency, 0.0)
 
         result = (
-            f"buying power : {self.buying_power}\n"
-            f"cash         : {self.cash}\n"
-            f"equity       : {self.equity()}\n"
+            f"buying power : {self.buying_power:{format_spec}}\n"
+            f"cash         : {self.cash:{format_spec}}\n"
+            f"equity       : {self.equity():{format_spec}}\n"
             f"positions    : {p_str}\n"
             f"trades       : {len(self.trades)}\n"
-            f"mkt value    : {mkt}\n"
+            f"mkt value    : {mkt:{format_spec}}\n"
             f"orders       : {o_str}\n"
             f"last update  : {self.last_update}"
         )

roboquant-2.4.0/roboquant/ai/__init__.py

@@ -0,0 +1,8 @@
+"""roboquant.ai package.
+Provides a number of AI related classes and methods to support the development of AI based trading strategies.
+It relies on Stable Baselines3 for reinforcement learning and PyTorch for deep learning.
+
+This package also introduces the concept of Features, which are the building blocks for roboquant machine learning models
+and can be used to extract relevant information. The ones included by default are either based on an `Event` or an `Account`.
+Typically Event features are used for input data and Account features are used for reward/label/output data.
+"""

{roboquant-2.3.3 → roboquant-2.4.0}/roboquant/ai/features.py

@@ -12,16 +12,24 @@ from roboquant.event import Event, Bar, Quote
 from roboquant.strategies.buffer import OHLCVBuffer
 
 T = TypeVar("T")
-FloatArray = NDArray[np.float32]
+NPFloatArray = NDArray[np.float32]
+NPIntArray = NDArray[np.int64]
 
 
 class Feature(Generic[T]):
-    """Base class for different types of features.
-    The ones included by default are either based either an `Event` or an `Account`.
-    Typically Event features are used for input and Account features are used for reward/label/output."""
+    """Base class for different types of features. Features are the data building blocks for
+    roboquant machine learning models and can be used to extract relevant information.
+
+    The ones included by default are either based on an `Event` or an `Account`.
+    Typically Event features are used for input data and Account features are used for
+    reward/label/output data.
+
+    Features can be combined, sliced, nested, normalized and cached to create more
+    complex features.
+    """
 
     @abstractmethod
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         """
         Perform the calculation and return the result as a 1-dimensional NDArray of type float32.
         The result should always be the same size. If a value cannot be calculated at a certain
@@ -33,21 +41,22 @@ class Feature(Generic[T]):
         """Return the size of this feature"""
 
     def reset(self):
-        """Reset the state of the feature"""
+        """Reset the state of the feature. This is called at the start of a new epoch.
+        If the feature has no state, this can be left empty."""
 
-    def _shape(self):
-        """return the shape of this feature as a tuple"""
+    def _shape(self) -> tuple[int]:
+        """return the size of this feature as a shape tuple"""
         return (self.size(),)
 
-    def _zeros(self):
+    def _zeros(self) -> NPFloatArray:
         """Return a zero array of the correct shape"""
         return np.zeros(self._shape(), dtype=np.float32)
 
-    def _ones(self):
+    def _ones(self) -> NPFloatArray:
         """Return an array of ones of the correct shape"""
         return np.ones(self._shape(), dtype=np.float32)
 
-    def _full_nan(self) -> FloatArray:
+    def _full_nan(self) -> NPFloatArray:
         """Return a full NaN array of the correct shape"""
         return np.full(self._shape(), float("nan"), dtype=np.float32)
 
@@ -56,7 +65,7 @@ class Feature(Generic[T]):
             return ReturnFeature(self)
         return LongReturnsFeature(self, period)
 
-    def normalize(self, min_period=3) -> "Feature[T]":
+    def normalize(self, min_period: int=3) -> "Feature[T]":
         """Normalize the feature values by calculating the mean and standard deviation."""
         return NormalizeFeature(self, min_period)
 
@@ -82,7 +91,7 @@ class SlicedFeature(Feature[T]):
         self.feature = feature
         self._size = len(feature._zeros()[args])
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         values = self.feature.calc(value)
         return values[self.args]
 
@@ -93,8 +102,10 @@ class SlicedFeature(Feature[T]):
         return self.feature.reset()
 
 
-class FixedValueFeature(Feature):
-    """Feature that always returns a fixed value"""
+class FixedValueFeature(Feature[Any]):
+    """Feature that always returns a fixed value array.
+    This can be used for example to add a bias term to the input features.
+    """
 
     def __init__(self, value: ArrayLike) -> None:
         super().__init__()
@@ -103,9 +114,33 @@ class FixedValueFeature(Feature):
     def size(self) -> int:
         return len(self.value)
 
-    def calc(self, value: Any) -> FloatArray:
+    def calc(self, value: Any) -> NPFloatArray:
         return self.value
 
+class RandomFeature(Feature[Any]):
+    """Feature that always returns a random value array. If a seed is provided,
+    the seed will be used to initialize the random number generator,
+    so that the same random values are generated each epoch.
+
+    If used with a seed, you can check your strategy for overfitting by running
+    several epochs and checking if the results are improving.
+    """
+
+    def __init__(self, size: int, seed: int|None = None) -> None:
+        super().__init__()
+        self._size = size
+        self._seed = seed
+        self.reset()
+
+    def size(self) -> int:
+        return self._size
+
+    def calc(self, value: Any) -> NPFloatArray:
+        return np.random.rand(self._size).astype(np.float32)
+
+    def reset(self):
+        np.random.seed(self._seed)
+
 
 class CombinedFeature(Feature[T]):
     """Combine multiple features into one single feature by horizontal stacking them.
@@ -117,7 +152,7 @@ class CombinedFeature(Feature[T]):
         self.features = features
         self._size = sum(feature.size() for feature in self.features)
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         data = [feature.calc(value) for feature in self.features]
         return np.hstack(data, dtype=np.float32)
 
@@ -130,7 +165,9 @@ class CombinedFeature(Feature[T]):
 
 
 class NormalizeFeature(Feature[T]):
-    """online normalization calculator"""
+    """online normalization calculator
+    - min_count: minimum number of values to calculate the mean and standard deviation
+    """
 
     def __init__(self, feature: Feature[T], min_count: int = 3) -> None:
         super().__init__()
@@ -138,10 +175,11 @@ class NormalizeFeature(Feature[T]):
         self.min_count = min_count
         self.existing_aggregate = (self._zero_int(), self._zeros(), self._zeros())
 
-    def _zero_int(self):
-        return np.zeros((self.size(),), dtype="int")
+    def _zero_int(self) -> NPIntArray:
+        return np.zeros((self.size(),), dtype="int64")
 
-    def denormalize(self, value):
+    def denormalize(self, value) -> NPFloatArray:
+        """Denormalize the value"""
         (count, mean, m2) = self.existing_aggregate
         stdev = np.sqrt(m2 / count) - 1e-12
         return value * stdev + mean
@@ -155,14 +193,14 @@ class NormalizeFeature(Feature[T]):
         delta2 = new_value - mean
         m2[mask] += delta[mask] * delta2[mask]
 
-    def __normalize_values(self, values) -> FloatArray:
+    def __normalize_values(self, values) -> NPFloatArray:
         (count, mean, m2) = self.existing_aggregate
         stdev = self._full_nan()
         mask = count >= self.min_count
         stdev[mask] = np.sqrt(m2[mask] / count[mask]) + 1e-12  # type: ignore
         return (values - mean) / stdev
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         values = self.feature.calc(value)
         self.__update(values)
         return self.__normalize_values(values)
@@ -176,14 +214,15 @@ class NormalizeFeature(Feature[T]):
 
 
 class FillFeature(Feature[T]):
-    """If a feature contains a NaN value, use the last known value instead"""
+    """If the underlying feature contains a NaN value,
+    replace it with the last known value instead"""
 
     def __init__(self, feature: Feature[T]) -> None:
         super().__init__()
         self.feature: Feature = feature
         self.fill = self._full_nan()
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         values = self.feature.calc(value)
         mask = np.isnan(values)
         values[mask] = self.fill[mask]
@@ -199,14 +238,15 @@ class FillFeature(Feature[T]):
 
 
 class FillWithConstantFeature(Feature[T]):
-    """If a feature contains a NaN value, fill it with a constant value"""
+    """If the underlying feature contains a NaN value,
+    fill it with a constant value"""
 
     def __init__(self, feature: Feature[T], constant: float = 0.0) -> None:
         super().__init__()
         self.feature: Feature = feature
         self.fill = np.full(self._shape(), constant, dtype=np.float32)
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         values = self.feature.calc(value)
         mask = np.isnan(values)
         values[mask] = self.fill[mask]
@@ -227,9 +267,9 @@ class ReturnFeature(Feature[T]):
         self.feature: Feature = feature
         self.history = self._full_nan()
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         values = self.feature.calc(value)
-        r: FloatArray = values / self.history - np.float32(1.0)  # type: ignore
+        r: NPFloatArray = values / self.history - np.float32(1.0)  # type: ignore
         self.history = values
         return r
 
@@ -244,10 +284,10 @@ class ReturnFeature(Feature[T]):
 class LongReturnsFeature(Feature[T]):
     def __init__(self, feature: Feature[T], period: int) -> None:
         super().__init__()
-        self.history: deque[FloatArray] = deque(maxlen=period)
+        self.history: deque[NPFloatArray] = deque(maxlen=period)
         self.feature: Feature = feature
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         values = self.feature.calc(value)
         h = self.history
 
@@ -275,10 +315,10 @@ class MaxReturnFeature(Feature[T]):
     def __init__(self, feature: Feature[T], period: int) -> None:
         super().__init__()
         assert feature.size() == 1
-        self.history: deque[FloatArray] = deque(maxlen=period)
+        self.history: deque[NPFloatArray] = deque(maxlen=period)
         self.feature: Feature = feature
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         values = self.feature.calc(value)
         h = self.history
         h.append(values)
@@ -304,10 +344,10 @@ class MinReturnFeature(Feature[T]):
 
     def __init__(self, feature: Feature[T], period: int) -> None:
         super().__init__()
-        self.history: deque[FloatArray] = deque(maxlen=period)
+        self.history: deque[NPFloatArray] = deque(maxlen=period)
         self.feature: Feature = feature
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         values = self.feature.calc(value)
         h = self.history
         h.append(values)
@@ -336,7 +376,7 @@ class SMAFeature(Feature[T]):
         self.history = np.zeros((self.period, feature.size()), dtype=np.float32)
         self._cnt = 0
 
-    def calc(self, value: T) -> FloatArray:
+    def calc(self, value: T) -> NPFloatArray:
         values = self.feature.calc(value)
         idx = self._cnt % self.period
         self.history[idx] = values
@@ -364,7 +404,7 @@ class SMAFeature(Feature[T]):
 class EquityFeature(Feature[Account]):
     """Calculates the total equity value of the account"""
 
-    def calc(self, value: Account) -> FloatArray:
+    def calc(self, value: Account) -> NPFloatArray:
         return np.array(value.equity_value(), dtype=np.float32)
 
     def size(self):
@@ -380,7 +420,7 @@ class UnrealizedPNLFeature(Feature[Account]):
     ```
     """
 
-    def calc(self, value: Account) -> FloatArray:
+    def calc(self, value: Account) -> NPFloatArray:
         mkt_value = value.convert(value.mkt_value())
         pnl = value.unrealized_pnl_value()
         if mkt_value and pnl:
@@ -411,7 +451,7 @@ class DayOfWeekFeature(Feature[Event]):
         self.tz = tz
         self.one_hot_encoded = one_hot_encoded
 
-    def calc(self, value: Event) -> FloatArray:
+    def calc(self, value: Event) -> NPFloatArray:
         dt = datetime.astimezone(value.time, self.tz)
         weekday = dt.weekday()
         if not self.one_hot_encoded:
@@ -429,6 +469,7 @@ class DayOfMonthFeature(Feature[Event]):
     """Calculate a day of month where the first day of the month is 0 and the last day is 30.
     Result can be one-hot encoded or not, depending on the `one_hot_encoded` parameter.
     If `one_hot_encoded` is True, the result will be a 30-element array else the result will be a single value.
+
     For example, if the event time is the 15th of the month, the result will be:
     - one-hot encoded: [0.0, 0.0, ..., 1.0, 0.0, ..., 0.0] (1.0 at index 14)
     - not one-hot encoded: [14.0]
@@ -439,7 +480,7 @@ class DayOfMonthFeature(Feature[Event]):
         self.tz = tz
         self.one_hot_encoded = one_hot_encoded
 
-    def calc(self, value: Event) -> FloatArray:
+    def calc(self, value: Event) -> NPFloatArray:
         dt = datetime.astimezone(value.time, self.tz)
         day = dt.day - 1  # day of month is 1-31, we want 0-30
         if not self.one_hot_encoded:
@@ -467,7 +508,7 @@ class MonthOfYearFeature(Feature[Event]):
         self.tz = tz
         self.one_hot_encoded = one_hot_encoded
 
-    def calc(self, value: Event) -> FloatArray:
+    def calc(self, value: Event) -> NPFloatArray:
         dt = datetime.astimezone(value.time, self.tz)
         month = dt.month - 1  # month is 1-12, we want 0-11
         if not self.one_hot_encoded:
@@ -488,7 +529,7 @@ class TimeDifference(Feature[Event]):
         super().__init__()
         self._last_time: datetime | None = None
 
-    def calc(self, value: Event) -> FloatArray:
+    def calc(self, value: Event) -> NPFloatArray:
         if self._last_time:
             diff = value.time - self._last_time
             self._last_time = value.time
@@ -515,7 +556,7 @@ class TaFeature(Feature[Event]):
         self.period = period
         self.assets = list(assets)
 
-    def calc(self, value: Event) -> FloatArray:
+    def calc(self, value: Event) -> NPFloatArray:
         result = []
         nan = float("nan")
         for asset in self.assets:
@@ -598,7 +639,7 @@ class BarFeature(Feature[Event]):
         super().__init__()
         self.assets = assets
 
-    def calc(self, value: Event) -> FloatArray:
+    def calc(self, value: Event) -> NPFloatArray:
         result = self._full_nan()
         for idx, asset in enumerate(self.assets):
             item = value.price_items.get(asset)
@@ -622,7 +663,7 @@ class QuoteFeature(Feature[Event]):
         super().__init__()
         self.assets = assets
 
-    def calc(self, value: Event) -> FloatArray:
+    def calc(self, value: Event) -> NPFloatArray:
         result = self._full_nan()
         for idx, asset in enumerate(self.assets):
             item = value.price_items.get(asset)
@@ -637,20 +678,23 @@ class QuoteFeature(Feature[Event]):
 
 
 class CacheFeature(Feature[Event]):
-    """Cache the results of an event feature from a previous run. This can speed up the learning process considerable, but
-    this requires that:
+    """Cache the results of an event feature from a previous run. This can speed up the learning process
+    considerable, but this requires that:
 
     - the feed to have always an increasing time value (monotonic)
-    - the feature has to produce the same output at a given time.
+    - the underlying feature has to produce the same output at a given time (deterministic)
+
+    A reset doesn't clear the cache, but it will reset the underlying feature. If you want to clear
+    the cache, use the `clear()` method.
     """
 
     def __init__(self, feature: Feature[Event], validate=False) -> None:
         super().__init__()
         self.feature: Feature = feature
-        self._cache: dict[datetime, FloatArray] = {}
+        self._cache: dict[datetime, NPFloatArray] = {}
         self.validate = validate
 
-    def calc(self, value: Event) -> FloatArray:
+    def calc(self, value: Event) -> NPFloatArray:
         time = value.time
         if time in self._cache:
             values = self._cache[time]
@@ -678,14 +722,17 @@ class CacheFeature(Feature[Event]):
 
 
 class VolumeFeature(Feature[Event]):
-    """Extract the volume for one or more assets in the event"""
+    """Extract the trading volume for one or more assets in the event.
+    Make sure that the data avaialble in the event contains adjusted volume data
+    (for example for stock splits), otherwise the results will be incorrect.
+    """
 
     def __init__(self, *assets: Asset, volume_type: str = "DEFAULT") -> None:
         super().__init__()
         self.assets = assets
         self.volume_type = volume_type
 
-    def calc(self, value: Event):
+    def calc(self, value: Event) -> NPFloatArray:
         volumes = [value.get_volume(asset, self.volume_type) for asset in self.assets]
         return np.array(volumes, dtype=np.float32)
 

{roboquant-2.3.3 → roboquant-2.4.0}/roboquant/ai/strategies.py

@@ -19,7 +19,10 @@ logger = logging.getLogger(__name__)
 
 
 class FeatureStrategy(Strategy):
-    """Abstract base class for strategies that use event features as input."""
+    """Abstract base class for strategies that use event features as input.
+    Typically these features are used to create input data for machine learning models,
+    which can then be used to generate signals.
+    """
 
     def __init__(self, input_feature: Feature[Event], history: int, dtype="float32"):
         super().__init__()
@@ -104,9 +107,13 @@ class TimeSeriesStrategy(FeatureStrategy):
     """Strategy using a sequenced neural network to predict future time series values.
     The input and label features are calculated from events.
     The model is expected to be a PyTorch module that takes the input features and outputs predictions.
+    An example of a model could be a recurrent neural network (RNN) or a long short-term memory (LSTM) network.
+
     The strategy can be used to generate buy/sell signals based on the model's predictions.
     This strategy is suitable for time series forecasting tasks where the model learns from historical data
-    to predict future values. Right now it only supports a single asset, but this can be extended in the future.
+    to predict future values.
+
+    Right now this class only supports a single asset, but this can be extended.
     """
 
     def __init__(
@@ -140,7 +147,7 @@ class TimeSeriesStrategy(FeatureStrategy):
             else:
                 p = output.item()
 
-            logger.info("Prediction p=%s time=%s", p, dt)
+            logger.info("Prediction asset=%s p=%s time=%s", self.asset.symbol, p, dt)
             if p >= self.buy_pct:
                 return [Signal.buy(self.asset)]
             if p <= self.sell_pct:

{roboquant-2.3.3 → roboquant-2.4.0}/roboquant/alpaca/feed.py

@@ -27,7 +27,7 @@ from alpaca.trading.enums import AssetClass
 
 from roboquant.asset import Asset, Crypto, Option, Stock
 from roboquant.event import Bar, Event, PriceItem, Quote, TradePrice
-from roboquant.feeds.historic import HistoricFeed
+from roboquant.feeds.historic import InMemoryFeed
 from roboquant.feeds.live import LiveFeed
 
 
@@ -134,7 +134,7 @@ class AlpacaLiveFeed(LiveFeed):
             logger.warning("cannot subscribe to bars for options")
 
 
-class _AlpacaHistoricFeed(HistoricFeed):
+class _AlpacaHistoricFeed(InMemoryFeed):
     """Base class for Alpaca historic feeds.
     This class is not intended to be used directly."""