roboquant 2.3.4__tar.gz → 2.4.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboquant
-Version: 2.3.4
+Version: 2.4.1
 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
@@ -46,16 +46,15 @@ Description-Content-Type: text/markdown
 ![PyPI - Version](https://img.shields.io/pypi/v/roboquant?)
 ![PyPI - License](https://img.shields.io/pypi/l/roboquant?)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/roboquant?)
-![PyPI - Status](https://img.shields.io/pypi/status/roboquant?)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/neurallayer/roboquant.py/verify.yml)
 [![discord](https://img.shields.io/discord/954650958300856340?label=discord)](https://discord.com/channels/954650958300856340/954650958300856343)
 
-Roboquant is an open-source algorithmic trading platform. It is flexible, user-friendly and completely free to use. It is designed for anyone serious about algo-trading. 
+Roboquant is an open-source algorithmic trading platform written in Python. It is flexible, user-friendly and completely free to use. It is designed for anyone serious about algo-trading. 
 
 So whether you are a beginning retail trader or an established trading firm, roboquant can help you to develop robust and fully automated trading strategies. You can find out more at [roboquant.org](https://roboquant.org).
 
 ## Usage
-The following code snippet shows the steps required to run a full back-test on a number of stocks.
+The following code snippet shows the required steps to run a full back-test on a number of stocks.
 
 ```python
 import roboquant as rq
@@ -66,6 +65,18 @@ account = rq.run(feed, strategy)
 print(account)
 ```
 
+## Features
+Below are some of the key features of *roboquant*:
+- [x] fast back testing and live trading
+- [x] AI/ML based strategies
+- [x] market data feeds from CSV files, Yahoo Finance, Alpaca and many crypto exchanges
+- [x] multi-currency trading
+- [x] multi-asset trading, stocks, options, forex and crypto out of the box
+- [x] larger-than-memory data feeds 
+- [x] TaLib based indicators and strategies
+- [x] plotting of prices and metrics
+- [x] modulair and extensible 
+
 ## Install
 Roboquant can be installed like most other Python packages, using tools like `uv`, `pip` or `conda`.
 Make sure you have Python version 3.12 or higher installed.
@@ -74,7 +85,7 @@ Make sure you have Python version 3.12 or higher installed.
 python3 -m pip install --upgrade roboquant
 ```
 
-The core of roboquant limits the number of dependencies. But you can install roboquant including one or more of the optional dependencies if you require certain additional functionality:
+The core installation of roboquant limits the number of dependencies. But you can install roboquant including one or more of the optional dependencies if you require certain additional functionality:
 
 ```shell
 # AI based strategies using PyTorch and SB3
@@ -90,30 +101,6 @@ python3 -m pip install --upgrade "roboquant[alpaca]"
 python3 -m pip install --upgrade "roboquant[crypto]"
 ```
 
-## Building from source
-Roboquant.py uses `uv` as the main tool for handling package dependencies. 
-
-```shell
-uv sync --all-extras --dev
-```
-
-You should now be in the virtual environment and ready to build/install roboquant:
-
-```shell
-uv build
-uv pip install .
-```
-
-Some other useful commands:
-
-```shell
-# build & validate the code
-./bin/verify.sh
-
-# publish, only works if UV_PUBLISH_TOKEN is set
-./bin/publish.sh
-```
-
 ## License
 Roboquant is made available under the Apache 2.0 license. You can read more about the Apache 2.0 license on this page: https://www.apache.org/licenses/LICENSE-2.0.html
 
@@ -121,6 +108,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.1}/README.md

@@ -4,16 +4,15 @@
 ![PyPI - Version](https://img.shields.io/pypi/v/roboquant?)
 ![PyPI - License](https://img.shields.io/pypi/l/roboquant?)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/roboquant?)
-![PyPI - Status](https://img.shields.io/pypi/status/roboquant?)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/neurallayer/roboquant.py/verify.yml)
 [![discord](https://img.shields.io/discord/954650958300856340?label=discord)](https://discord.com/channels/954650958300856340/954650958300856343)
 
-Roboquant is an open-source algorithmic trading platform. It is flexible, user-friendly and completely free to use. It is designed for anyone serious about algo-trading. 
+Roboquant is an open-source algorithmic trading platform written in Python. It is flexible, user-friendly and completely free to use. It is designed for anyone serious about algo-trading. 
 
 So whether you are a beginning retail trader or an established trading firm, roboquant can help you to develop robust and fully automated trading strategies. You can find out more at [roboquant.org](https://roboquant.org).
 
 ## Usage
-The following code snippet shows the steps required to run a full back-test on a number of stocks.
+The following code snippet shows the required steps to run a full back-test on a number of stocks.
 
 ```python
 import roboquant as rq
@@ -24,6 +23,18 @@ account = rq.run(feed, strategy)
 print(account)
 ```
 
+## Features
+Below are some of the key features of *roboquant*:
+- [x] fast back testing and live trading
+- [x] AI/ML based strategies
+- [x] market data feeds from CSV files, Yahoo Finance, Alpaca and many crypto exchanges
+- [x] multi-currency trading
+- [x] multi-asset trading, stocks, options, forex and crypto out of the box
+- [x] larger-than-memory data feeds 
+- [x] TaLib based indicators and strategies
+- [x] plotting of prices and metrics
+- [x] modulair and extensible 
+
 ## Install
 Roboquant can be installed like most other Python packages, using tools like `uv`, `pip` or `conda`.
 Make sure you have Python version 3.12 or higher installed.
@@ -32,7 +43,7 @@ Make sure you have Python version 3.12 or higher installed.
 python3 -m pip install --upgrade roboquant
 ```
 
-The core of roboquant limits the number of dependencies. But you can install roboquant including one or more of the optional dependencies if you require certain additional functionality:
+The core installation of roboquant limits the number of dependencies. But you can install roboquant including one or more of the optional dependencies if you require certain additional functionality:
 
 ```shell
 # AI based strategies using PyTorch and SB3
@@ -48,30 +59,6 @@ python3 -m pip install --upgrade "roboquant[alpaca]"
 python3 -m pip install --upgrade "roboquant[crypto]"
 ```
 
-## Building from source
-Roboquant.py uses `uv` as the main tool for handling package dependencies. 
-
-```shell
-uv sync --all-extras --dev
-```
-
-You should now be in the virtual environment and ready to build/install roboquant:
-
-```shell
-uv build
-uv pip install .
-```
-
-Some other useful commands:
-
-```shell
-# build & validate the code
-./bin/verify.sh
-
-# publish, only works if UV_PUBLISH_TOKEN is set
-./bin/publish.sh
-```
-
 ## License
 Roboquant is made available under the Apache 2.0 license. You can read more about the Apache 2.0 license on this page: https://www.apache.org/licenses/LICENSE-2.0.html
 
@@ -79,6 +66,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.1}/pyproject.toml

@@ -8,6 +8,9 @@ build-backend = "uv_build"
 [tool.ruff.lint]
 select = ["E", "F", "W"]
 
+[tool.ty.rules]
+unused-type-ignore-comment = "ignore"
+
 [tool.pyright]
 typeCheckingMode = "standard"
 reportPrivateImportUsage = "none" 
@@ -19,7 +22,7 @@ module-name = "roboquant"
 
 [project]
 name = "roboquant"
-version = "2.3.4"
+version = "2.4.1"
 authors = [{ name = "roboquant team", email = "info@roboquant.org" }]
 description = "A fast algorithmic trading platform with support for AI based strategies"
 readme = "README.md"
@@ -83,5 +86,5 @@ dev = [
   "ipykernel>=7.3.0",
   "ipywidgets>=8.1.6",
   "chronos-forecasting>=2.3.1",
+  "ty>=0.0.62",
 ]
-talib = ["ta-lib==0.6.5"]

{roboquant-2.3.4 → roboquant-2.4.1}/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.1}/roboquant/account.py

@@ -1,7 +1,6 @@
 from dataclasses import dataclass
 from datetime import datetime
 from decimal import Decimal
-from typing import Any
 
 from roboquant.asset import Asset
 from roboquant.monetary import USD, Amount, Currency, Wallet
@@ -32,7 +31,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
@@ -59,17 +58,17 @@ class Position:
         """Return a zero position size with no known prices"""
         return Position(Decimal(), float("nan"), float("nan"))
 
-
+@dataclass
 class Account:
     """Represents a trading account. The account maintains the following state during a run:
 
-    - Available buying power for orders in the base currency of the account.
-    - Cash available in the account.
-    - The open positions, each denoted in the currency of the asset.
-    - The open orders, each denoted in the currency of the asset.
-    - The trades that have been executed, each denoted in the currency of the asset.
-    - Calculated derived equity value of the account in the base currency of the account.
-    - The last time the account was updated.
+    Attributes:
+        buying_power (Amount): Available buying power for orders in the base currency of the account.
+        cash (Wallet): The cash available in the account.
+        positions (Dict[Asset, Position]): the open positions, each denoted in the currency of the asset.
+        orders (list[Order]): the open orders, each denoted in the currency of the asset.
+        trades (list[Trade]): the trades that have been executed, each denoted in the currency of the asset.
+        last_update (datetime): The last time the account was updated.
 
     Only the `broker` updates the account and does this only during its `sync` method.
     """
@@ -212,32 +211,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.
@@ -260,45 +241,6 @@ class Account:
         pos = self.positions.get(asset)
         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"""
-        result: list[dict[str, Any]] = []
-        for asset, pos in self.positions.items():
-            result.append(
-                {
-                    "asset class": asset.asset_class(),
-                    "symbol": asset.symbol,
-                    "currency": asset.currency,
-                    "size": pos.size,
-                    "type": "LONG" if pos.is_long else "SHORT",
-                    "avg price": pos.avg_price,
-                    "mkt price": pos.mkt_price,
-                    "value": asset.contract_value(pos.size, pos.mkt_price),
-                    "pnl": asset.contract_value(pos.size, pos.mkt_price - pos.avg_price),
-                }
-            )
-        return result
-
-    def get_order_list(self) -> list[dict[str, Any]]:
-        """Return all open orders as a list of dicts"""
-        result: list[dict[str, Any]] = []
-        for order in self.orders:
-            result.append(
-                {
-                    "id": order.id,
-                    "asset class": order.asset.asset_class(),
-                    "symbol": order.asset.symbol,
-                    "currency": order.asset.currency,
-                    "size": order.size,
-                    "type": "BUY" if order.is_buy else "SELL",
-                    "value": order.value(),
-                    "fill": order.fill,
-                    "tif": order.tif,
-                    "info": str(order.info) if order.info else "-",
-                }
-            )
-        return result
-
     def get_order(self, order_id: str) -> Order | None:
         """Return an order by its id, or None if no matching order can be found"""
         for order in self.orders:
@@ -306,7 +248,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 +272,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.1/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.
+"""