investing-algorithm-framework 8.5.0

A framework for creating trading bots

Investing Algorithm Framework

Create trading strategies. Compare them side by side. Pick the best one and Deploy 🚀

<sub>Sponsored by

Marketplace for trading bots</sub>

Introduction

Investing Algorithm Framework is a Python framework for creating, backtesting, and deploying trading strategies.

Most quant frameworks stop at "here's your backtest result." You get a number, maybe a chart, and then you're on your own figuring out which strategy is actually better.

This framework is built around the full loop: create strategies → vector backtest for signals analysis → compare them in a single report → event backtest the most promising strategies → deploy the winner. It generates a self-contained HTML dashboard that lets you rank, filter, and visually compare every strategy you've tested — all in one view, no notebooks required.

Features

• 📊 30+ Metrics — CAGR, Sharpe, Sortino, Calmar, VaR, CVaR, Max DD, Recovery & more
• ⚡ Vector Backtesting for Signal Analysis — Quickly test your strategy logic on historical data to see how signals would have behaved before committing to full event-driven backtests
• 🏃 Event-Driven Backtesting — Once promising strategies are identified via vector backtests, run full event-driven backtests to simulate realistic execution and portfolio management
• 🔀 Permutation Testing / Monte Carlo Simulations — Assess the statistical robustness of your strategies by running them across randomized market scenarios to see how often your results could occur by chance
• 🚀 Deployment — Once the best strategy is identified through backtesting and comparison, deploy it to production locally or in the cloud (AWS Lambda / Azure Functions) to start live trading
• ⚔️ Multi-Strategy Comparison — Rank, filter & compare strategies in a single interactive report
• 🪟 Multi-Window Robustness — Test across different time periods with window coverage analysis
• 📈 Equity & Drawdown Charts — Overlay equity curves, rolling Sharpe, drawdown & return distributions
• 🗓️ Monthly Heatmaps & Yearly Returns — Calendar heatmap per strategy with return/growth toggles
• 🎯 Return Scenario Projections — Good, average, bad & very bad year projections from backtest data
• 📉 Benchmark Comparison — Beat-rate analysis vs Buy & Hold, DCA, risk-free & custom benchmarks
• 📄 One-Click HTML Report — Self-contained file, no server, dark & light theme, shareable
• 🌐 Load External Data — Fetch CSV, JSON, or Parquet from any URL with caching and auto-refresh
• � Record Custom Variables — Track any indicator or metric during backtests with context.record()
• �🚀 Build → Backtest → Deploy — Local dev, cloud deploy (AWS / Azure), or monetize on Finterion

Usage

To get started, install the framework and scaffold a new project:

pip install investing-algorithm-framework

# Generate project structure
investing-algorithm-framework init

# Or for cloud deployment
investing-algorithm-framework init --type aws_lambda
investing-algorithm-framework init --type azure_function

The documentation provides guides and API reference. The quick start will walk you through your first strategy.

Creating a Strategy

The framework is designed around the TradingStrategy class. You define what data your strategy needs and when to buy or sell — the framework handles execution, position management, and reporting.

from typing import Dict, Any

import pandas as pd
from pyindicators import ema, rsi, crossover, crossunder

from investing_algorithm_framework import (
    TradingStrategy, DataSource, TimeUnit, DataType,
    PositionSize, ScalingRule, StopLossRule,
)


class RSIEMACrossoverStrategy(TradingStrategy):
    """
    EMA crossover + RSI filter strategy with position scaling and stop losses.

    Buy when RSI is oversold AND a recent EMA crossover occurred.
    Sell when RSI is overbought AND a recent EMA crossunder occurred.
    Scale into winners, trail a stop loss, and let the framework handle the rest.
    """
    time_unit = TimeUnit.HOUR
    interval = 2
    symbols = ["BTC", "ETH"]
    data_sources = [
        DataSource(
            identifier="BTC_ohlcv", symbol="BTC/EUR",
            data_type=DataType.OHLCV, time_frame="2h",
            market="BITVAVO", pandas=True, warmup_window=100,
        ),
        DataSource(
            identifier="ETH_ohlcv", symbol="ETH/EUR",
            data_type=DataType.OHLCV, time_frame="2h",
            market="BITVAVO", pandas=True, warmup_window=100,
        ),
    ]

    # Risk management
    position_sizes = [
        PositionSize(symbol="BTC", percentage_of_portfolio=20),
        PositionSize(symbol="ETH", percentage_of_portfolio=20),
    ]
    scaling_rules = [
        ScalingRule(
            symbol="BTC", max_entries=3,
            scale_in_percentage=[50, 25], cooldown_in_bars=5,
        ),
        ScalingRule(
            symbol="ETH", max_entries=3,
            scale_in_percentage=[50, 25], cooldown_in_bars=5,
        ),
    ]
    stop_losses = [
        StopLossRule(
            symbol="BTC", percentage_threshold=5,
            sell_percentage=100, trailing=True,
        ),
        StopLossRule(
            symbol="ETH", percentage_threshold=5,
            sell_percentage=100, trailing=True,
        ),
    ]

    def generate_buy_signals(
        self, data: Dict[str, Any]
    ) -> Dict[str, pd.Series]:
        signals = {}

        for symbol in self.symbols:
            df = data[f"{symbol}_ohlcv"]
            ema_short = ema(df, period=12, source_column="Close",
                           result_column="ema_short")
            ema_long = ema(ema_short, period=26, source_column="Close",
                          result_column="ema_long")
            ema_cross = crossover(ema_long,
                                  first_column="ema_short",
                                  second_column="ema_long",
                                  result_column="ema_crossover")
            rsi_data = rsi(df, period=14, source_column="Close",
                          result_column="rsi")

            rsi_oversold = rsi_data["rsi"] < 30
            recent_crossover = (
                ema_cross["ema_crossover"].rolling(window=10).max() > 0
            )
            signals[symbol] = (rsi_oversold & recent_crossover).fillna(False)

        return signals

    def generate_sell_signals(
        self, data: Dict[str, Any]
    ) -> Dict[str, pd.Series]:
        signals = {}

        for symbol in self.symbols:
            df = data[f"{symbol}_ohlcv"]
            ema_short = ema(df, period=12, source_column="Close",
                           result_column="ema_short")
            ema_long = ema(ema_short, period=26, source_column="Close",
                          result_column="ema_long")
            ema_cross = crossunder(ema_long,
                                   first_column="ema_short",
                                   second_column="ema_long",
                                   result_column="ema_crossunder")
            rsi_data = rsi(df, period=14, source_column="Close",
                          result_column="rsi")

            rsi_overbought = rsi_data["rsi"] >= 70
            recent_crossunder = (
                ema_cross["ema_crossunder"].rolling(window=10).max() > 0
            )
            signals[symbol] = (rsi_overbought & recent_crossunder).fillna(False)

        return signals

Create as many strategy variants as you want — different parameters, different indicators, different symbols — then backtest them all and compare in a single report.

Backtest Report Dashboard

Every backtest produces a single HTML file you can open in any browser, share with teammates, or archive. No server, no dependencies, no Jupyter required.

from investing_algorithm_framework import BacktestReport

# After running backtests
report = BacktestReport(backtest)
report.show()  # Opens dashboard in your browser

# Or load previously saved backtests from disk
report = BacktestReport.open(directory_path="path/to/backtests")
report.show()

# Compare multiple strategies side by side
report = BacktestReport.open(backtests=[backtest_a, backtest_b, backtest_c])
report.show()

# Save as a self-contained HTML file
report.save("my_report.html")

Overview page — KPI cards, key metrics ranking table, trading activity, return scenarios, equity curves, metric bar charts, monthly returns heatmap, return distributions, and window coverage matrix.

Strategy pages — Deep dive into each strategy with per-run equity curves, rolling Sharpe, drawdown, monthly/yearly returns, and portfolio summary.

Capabilities

Backtest Report Dashboard	Self-contained HTML report with ranking tables, equity curves, metric charts, heatmaps, and strategy comparison
Event-Driven Backtesting	Realistic, order-by-order simulation
Vectorized Backtesting	Fast signal research and prototyping
50+ Metrics	CAGR, Sharpe, Sortino, max drawdown, win rate, profit factor, recovery factor, volatility, and more
Live Trading	Connect to exchanges via CCXT for real-time execution
Portfolio Management	Position tracking, trade management, persistence
Cloud Deployment	Deploy to AWS Lambda, Azure Functions, or run as a web service
Market Data Providers	Built-in providers for CCXT, Yahoo Finance, Alpha Vantage, and Polygon — or build your own
Load External Data	Fetch CSV, JSON, or Parquet from any URL with caching, date parsing, and pre/post-processing
Record Custom Variables	Track any indicator or metric during backtests with context.record()
Strategies	OHLCV, tickers, custom data — Polars and Pandas native
Extensible	Custom data providers, order executors, and strategy classes

Plugins

Plugin	Description
PyIndicators	Technical analysis indicators (EMA, RSI, MACD, etc.)
Finterion Plugin	Share and monetize strategies on Finterion's marketplace

Development

git clone https://github.com/coding-kitties/investing-algorithm-framework.git
cd investing-algorithm-framework
poetry install

# Run all tests
python -m unittest discover -s tests

Resources

• Documentation — Guides and API reference
• Quick Start — Get up and running
• Discord — Chat and support
• Reddit — Strategy discussion

Contributing

• Open an issue for bugs or ideas
• Read the Contributing Guide
• PRs go against the dev branch

Risk Disclaimer

If you use this framework for real trading, do not risk money you are afraid to lose. Test thoroughly with backtesting first. Start small. We assume no responsibility for your investment results.

Acknowledgements

We want to thank all contributors to this project. A full list can be found in AUTHORS.md.

Sponsor

Finterion — Marketplace for trading bots. Monetize your strategies by publishing them on Finterion.