repository·master·Indexed 20 days ago
https://github.com/constverum/quantdomA Python-based backtesting framework for modeling financial strategies, portfolio management, and analyzing trading performance. Version 0.1.1 includes a GUI via MainWindow, a CLI for running backtests, and tools for visualizing price data (QuotesChart) and portfolio performance (EquityChart). It supports multiple data loaders (Yahoo, IEX, Stooq, etc.), technical indicator configuration, and comprehensive performance metrics including Sharpe and Sortino ratios.
To run Quantdom, ensure your environment meets the following requirements:
PyQt5PyQtGraphNumPyFor a complete list of dependencies, refer to the pyproject.toml file in the repository.
You can install Quantdom using one of the following methods:
Use pip to install the latest stable version:
$ pip install quantdomTo install the latest development version directly from the source:
$ pip install -U git+https://github.com/constverum/Quantdom.gitOnce installed, you can launch the Quantdom application by executing:
$ quantdomBinary packages are also available for specific operating systems via GitHub Releases:
.exe installer.dmg installer.zip archiveFollow these steps to perform a backtest within the Quantdom application:
quantdom command.Data tab and choose a market instrument (symbol) for backtesting.Quotes tab, specify the file containing your strategies, and select the strategy you wish to use.The AbstractStrategy follows a specific execution lifecycle when the run() method is called:
start() method is invoked, which immediately calls your implementation of init(). This is where you set up your state and parameters.Quotes. For every quote received, your implementation of handle(quote) is executed.run() method finishes.When initializing your class, you can provide a name, a period, and a list of symbols. The strategy will automatically use the first symbol in the list as self.symbol.
# Example of instantiation
strategy = MyStrategy(name="TrendFollower", period=14, symbols=["AAPL", "MSFT"])
strategy.run()The BasePortfolio class (exported as Portfolio) is the central manager for tracking account balance, leverage, and active/closed positions.
Key capabilities:
balance, equity, and a list of positions.add_position(position) to manually add a position or use the Order helper to open them.summarize() to calculate performance statistics (stats), performance metrics (performance), and equity/balance curves.run_optimization(strategy, params) to perform parameter sweeps across a strategy, utilizing optimization_mode() to ensure the portfolio state is backed up and restored between runs.from quantdom.lib.portfolio import Portfolio
# Initialize with custom balance and leverage
portfolio = BasePortfolio(balance=50_000, leverage=10)
# After running a strategy or manual trades, summarize results
portfolio.summarize()
print(portfolio.performance)
print(portfolio.equity_curve)The QuotesChart uses the ChartType enumeration to determine how price data is rendered. Supported styles include:
ChartType.CANDLESTICK: Renders OHLC data as candlesticks.ChartType.BAR: Renders OHLC data as bars._get_chart_points, it falls back to a standard line plot of the closing prices.To prevent UI freezing during symbol lookups, Quantdom uses a background thread mechanism:
QtCore.QThread that calls get_symbols().symbols_loaded(object).DataTabWidget connects this signal to on_symbols_loaded, which populates a QtGui.QStandardItemModel used by the symbol combo box and a QCompleter for easy searching.To create a custom trading strategy, inherit from AbstractStrategy. You must implement the init method for setup and the handle method to process incoming market data (quote).
init(self, ...): Initialize strategy parameters, state variables (like counters or signal flags), and set the Portfolio.initial_balance.handle(self, quote): This method is called for every new quote. Use the quote object to access market data (e.g., quote.open, quote.close, quote.time, quote.symbol).Order: Use Order.open(**props) to open a new position and Order.close(position, ...) to close an existing one.Portfolio: Access global portfolio settings like Portfolio.initial_balance.This strategy enters a position after a specific sequence of bullish or bearish bars.
from quantdom import AbstractStrategy, Order, Portfolio
class ThreeBarStrategy(AbstractStrategy):
def init(self, high_bars=3, low_bars=3):
Portfolio.initial_balance = 100000 # default value
self.seq_low_bars = 0
self.seq_high_bars = 0
self.signal = None
self.last_position = None
self.volume = 100 # shares
self.high_bars = high_bars
self.low_bars = low_bars
def handle(self, quote):
if self.signal:
props = {
'symbol': self.symbol, # current selected symbol
'otype': self.signal,
'price': quote.open,
'volume': self.volume,
'time': quote.time,
}
if not self.last_position:
self.last_position = Order.open(**kwargs)
elif self.last_position.type != self.signal:
Order.close(self.last_position, price=quote.open, time=quote.time)
self.last_position = Order.open(**props)
self.signal = False
self.seq_high_bars = self.seq_low_bars = 0
if quote.close > quote.open:
self.seq_high_bars += 1
self.seq_low_bars = 0
else:
self.seq_high_bars = 0
self.seq_low_bars += 1
if self.seq_high_bars == self.high_bars:
self.signal = Order.BUY
elif self.seq_low_bars == self.low_bars:
self.signal = Order.SELLfrom quantdom import AbstractStrategy, Order, Portfolio
class ThreeBarStrategy(AbstractStrategy):
def init(self, high_bars=3, low_bars=3):
Portfolio.initial_balance = 100000 # default value
self.seq_low_bars = 0
self.seq_high_bars = 0
self.signal = None
self.last_position = None
self.volume = 100 # shares
self.high_bars = high_bars
self.low_bars = low_bars
def handle(self, quote):
if self.signal:
props = {
'symbol': self.symbol, # current selected symbol
'otype': self.signal,
'price': quote.open,
'volume': self.volume,
'time': quote.time,
}
if not self.last_position:
self.last_position = Order.open(**props)
elif self.last_position.type != self.signal:
Order.close(self.last_position, price=quote.open, time=quote.time)
self.last_position = Order.open(**props)
self.signal = False
self.seq_high_bars = self.seq_low_bars = 0
if quote.close > quote.open:
self.seq_high_bars += 1
self.seq_low_bars = 0
else:
self.seq_high_bars = 0
self.seq_low_bars += 1
if self.seq_high_bars == self.high_bars:
self.signal = Order.BUY
elif self.seq_low_bars == self.low_bars:
self.signal = Order.SELLThe module provides utility functions to calculate risk-adjusted return ratios based on daily percentage returns derived from Stats.
annualized_sharpe_ratio(stats): Calculates the Sharpe ratio using the formula: sqrt(ANNUAL_PERIOD) * mean(returns) / std(returns).annualized_sortino_ratio(stats): Calculates the Sortino ratio, which only considers the standard deviation of negative returns (downside deviation).Both functions rely on day_percentage_returns(stats) to aggregate trade profits into daily return buckets.
from quantdom.lib.performance import annualized_sharpe_ratio, annualized_sortino_ratio
# stats is a Stats object
sharpe = annualized_sharpe_ratio(stats)
sortino = annualized_sortino_ratio(stats)The Order class provides static methods to interact with the global Portfolio instance to execute trades.
Order.open(symbol, otype, price, volume, time, sl=None, tp=None): Creates a new Position and automatically adds it to the Portfolio.Order.close(position, price, time, volume=None): Closes an existing position at a specific price and time, updating the portfolio balance.OrderType constants include BUY, SELL, BUY_LIMIT, SELL_LIMIT, BUY_STOP, and SELL_STOP.
from quantdom.lib.portfolio import Order, OrderType
# Open a long position
pos = Order.open(
symbol=my_symbol,
otype=OrderType.BUY,
price=1.05850,
volume=1.0,
time=timestamp,
sl=1.05500,
tp=1.06500
)
# Close the position later
Order.close(pos, price=1.06000, time=later_timestamp)Use ResultsTable to display high-level performance metrics from the Portfolio object. The table automatically configures its columns based on Portfolio.performance.columns. When calling .plot(), it populates the table with values, units, and headers defined in the portfolio's performance data. It supports 'separated' rows for grouping and applies color coding (blue for positive, red for negative) to specific metrics if configured.
from quantdom.lib.tables import ResultsTable
# Assuming a Portfolio instance has been initialized elsewhere
table = ResultsTable()
table.plot()The LogTable is a simple UI component designed to show a list of log messages with associated timestamps. It uses a two-column format: Time and Message.
from quantdom.lib.tables import LogTable
table = LogTable()
# Note: plot() is currently a no-op in the source