roboquant 2.3.4__tar.gz → 2.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboquant
-Version: 2.3.4
+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.4 → 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.4 → roboquant-2.4.0}/pyproject.toml

@@ -19,7 +19,7 @@ module-name = "roboquant"
 
 [project]
 name = "roboquant"
-version = "2.3.4"
+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.4 → 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.4 → 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.4 → roboquant-2.4.0}/roboquant/ai/features.py

@@ -12,14 +12,15 @@ 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. 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 either an `Event` or an `Account`.
+    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.
 
@@ -28,7 +29,7 @@ class Feature(Generic[T]):
     """
 
     @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
@@ -43,19 +44,19 @@ class Feature(Generic[T]):
         """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)
 
@@ -64,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)
 
@@ -90,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]
 
@@ -101,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__()
@@ -111,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.
@@ -125,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)
 
@@ -138,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__()
@@ -146,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
@@ -163,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)
@@ -184,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]
@@ -207,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]
@@ -235,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
 
@@ -252,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
 
@@ -283,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)
@@ -312,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)
@@ -344,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
@@ -372,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):
@@ -388,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:
@@ -419,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:
@@ -448,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:
@@ -476,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:
@@ -497,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
@@ -524,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:
@@ -607,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)
@@ -631,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)
@@ -659,10 +691,10 @@ class CacheFeature(Feature[Event]):
     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]
@@ -691,8 +723,8 @@ class CacheFeature(Feature[Event]):
 
 class VolumeFeature(Feature[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.
+    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:
@@ -700,7 +732,7 @@ class VolumeFeature(Feature[Event]):
         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.4 → 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."""
 

{roboquant-2.3.4 → roboquant-2.4.0}/roboquant/asset.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from decimal import Decimal
@@ -155,18 +156,17 @@ class Crypto(Asset):
     """
 
     @staticmethod
-    def from_symbol(symbol: str, sep: str = "/"):
-        """Create a Crypto asset from a symbol string. Based on the separator it will
-        try to determine the currency.
+    def from_symbol(symbol: str):
+        """Create a Crypto asset from a symbol string. It will automatically extract the quote currency from the symbol,
+        which is assumed to be the last part of the symbol.
 
         Args:
             symbol (str): The symbol string of the crypto asset.
-            sep (str, optional): The separator used in the symbol string. Defaults to "/".
 
         Returns:
             Crypto: The created crypto asset.
         """
-        currency = symbol.split(sep)[-1]
+        currency = re.split(r"[^a-zA-Z0-9\s]", symbol)[-1]
         return Crypto(symbol, Currency(currency))
 
     def serialize(self):
@@ -204,18 +204,16 @@ class Forex(Asset):
     """
 
     @staticmethod
-    def from_symbol(symbol: str, sep: str = "/"):
-        """Create a Forex asset from a symbol string. The second part of the symbol is the
+    def from_symbol(symbol: str) -> "Forex":
+        """Create a Forex asset from a symbol string. The last part of the symbol is assumed to be the
         currency.
 
         Args:
             symbol (str): The symbol string of the forex asset.
-            sep (str, optional): The separator used in the symbol string. Defaults to "/".
-
         Returns:
             Forex: The created forex asset.
         """
-        currency = symbol.split(sep)[-1]
+        currency = re.split(r"[^a-zA-Z0-9\s]", symbol)[-1]
         return Forex(symbol, Currency(currency))
 
     def serialize(self):

{roboquant-2.3.4 → roboquant-2.4.0}/roboquant/brokers/broker.py

@@ -149,7 +149,7 @@ class LiveBroker(Broker):
         order = Order(
             asset=asset,
             size=-Decimal(size), # Negative size for sell orders
-            limit=float(limit),
+            limit=limit,
             tif=tif,
         )
         order.fill = - Decimal(fill) # Negative fill for sell orders