quantcore-lite 0.1.0__tar.gz

quantcore_lite-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 QuantCore Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

quantcore_lite-0.1.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: quantcore-lite
+Version: 0.1.0
+Summary: Open-core backtesting framework for quantitative trading strategies
+Author: QuantCore Team
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Septal083/quantcore
+Project-URL: Repository, https://github.com/Septal083/quantcore
+Project-URL: Issues, https://github.com/Septal083/quantcore/issues
+Project-URL: Changelog, https://github.com/Septal083/quantcore/blob/main/CHANGELOG.md
+Keywords: backtesting,trading,quantitative-finance,strategies
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: numpy>=1.23.0
+Requires-Dist: matplotlib>=3.6.0
+Requires-Dist: reportlab>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+[![PyPI version](https://img.shields.io/pypi/v/quantcore-lite)](https://pypi.org/project/quantcore-lite/)
+[![GitHub stars](https://img.shields.io/github/stars/Septal083/quantcore)](https://github.com/Septal083/quantcore/stargazers)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# QuantCore
+
+**Open-core backtesting framework for quantitative trading strategies.**
+
+QuantCore lets you backtest trading strategies against historical OHLCV data with a clean Python API and CLI. The free tier includes three battle-tested strategies and essential performance metrics. Upgrade to Pro for advanced strategies, Monte Carlo simulation, tearsheet PDF reports, and parameter optimization.
+
+## Installation
+
+```bash
+pip install quantcore-lite
+```
+
+## Quick Start
+
+### Python API
+
+```python
+import pandas as pd
+from quantcore import Backtest, MomentumStrategy
+
+# Load your OHLCV data
+data = pd.read_csv("market_data.csv", index_col=0, parse_dates=True)
+
+# Run a backtest with the Momentum strategy
+bt = Backtest(data, MomentumStrategy(lookback=20))
+bt.run()
+
+print(bt.summary())
+bt.export_csv("results.csv")
+```
+
+### CLI
+
+```bash
+quantcore backtest --data market_data.csv --strategy momentum
+quantcore backtest --data market_data.csv --strategy mean_reversion --output results.csv
+quantcore strategies
+```
+
+## Strategies
+
+### Momentum
+
+Buy when the rate of change over a lookback period is positive, sell when negative.
+
+```python
+from quantcore import Backtest, MomentumStrategy
+
+strategy = MomentumStrategy(lookback=20)
+bt = Backtest(data, strategy)
+bt.run()
+print(bt.summary())
+```
+
+### Mean Reversion
+
+Buy when price falls below its rolling mean by a threshold, sell when it reverts above.
+
+```python
+from quantcore import Backtest, MeanReversion
+
+strategy = MeanReversion(window=20, threshold=1.5)
+bt = Backtest(data, strategy)
+bt.run()
+print(bt.summary())
+```
+
+### Moving Average Crossover
+
+Buy on golden cross (short MA crosses above long MA), sell on death cross.
+
+```python
+from quantcore import Backtest, MovingAverageCrossover
+
+strategy = MovingAverageCrossover(short_window=20, long_window=50)
+bt = Backtest(data, strategy)
+bt.run()
+print(bt.summary())
+```
+
+## Performance Metrics
+
+Every backtest reports:
+
+| Metric | Description |
+|--------|-------------|
+| **Sharpe Ratio** | Risk-adjusted return (annualized) |
+| **Max Drawdown** | Largest peak-to-trough decline |
+| **CAGR** | Compound annual growth rate |
+| **Win Rate** | Percentage of profitable trades |
+| **Total Return** | Overall portfolio return |
+
+## Free vs Pro Comparison
+
+| Feature | Free | Pro |
+|---------|:----:|:---:|
+| Momentum strategy | ✅ | ✅ |
+| Mean Reversion strategy | ✅ | ✅ |
+| Moving Average Crossover strategy | ✅ | ✅ |
+| Performance metrics (Sharpe, CAGR, drawdown, win rate) | ✅ | ✅ |
+| CSV export | ✅ | ✅ |
+| CLI interface | ✅ | ✅ |
+| RSI, Bollinger Bands, MACD strategies | ❌ | ✅ |
+| Pairs Trading, Volatility Breakout, Turtle Trading | ❌ | ✅ |
+| Mean Reversion Z-Score, Kalman Filter, Dual Momentum, Sector Rotation | ❌ | ✅ |
+| Monte Carlo simulation (1000 runs, confidence intervals) | ❌ | ✅ |
+| Tearsheet PDF generator | ❌ | ✅ |
+| Parameter grid search optimizer | ❌ | ✅ |
+
+## ⭐ Pro Version
+
+Unlock 10 additional strategies, Monte Carlo simulation, tearsheet PDF reports, and parameter optimization.
+
+**[Get QuantCore Pro →](https://buy.polar.sh/polar_cl_rA97pLblKd1pRhwXezgssGgCp1NaKlDV0CeG74fP4q4)**
+
+Set your license key:
+
+```bash
+export QUANTCORE_LICENSE_KEY="your-license-key"
+```
+
+Then use Pro features:
+
+```bash
+quantcore backtest --data market_data.csv --strategy rsi --tearsheet report.pdf --monte-carlo
+quantcore optimize --data market_data.csv --strategy bollinger_bands
+```
+
+Pro features are validated via [Polar.sh](https://polar.sh) license keys.
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.

quantcore_lite-0.1.0/README.md

@@ -0,0 +1,137 @@
+[![PyPI version](https://img.shields.io/pypi/v/quantcore-lite)](https://pypi.org/project/quantcore-lite/)
+[![GitHub stars](https://img.shields.io/github/stars/Septal083/quantcore)](https://github.com/Septal083/quantcore/stargazers)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# QuantCore
+
+**Open-core backtesting framework for quantitative trading strategies.**
+
+QuantCore lets you backtest trading strategies against historical OHLCV data with a clean Python API and CLI. The free tier includes three battle-tested strategies and essential performance metrics. Upgrade to Pro for advanced strategies, Monte Carlo simulation, tearsheet PDF reports, and parameter optimization.
+
+## Installation
+
+```bash
+pip install quantcore-lite
+```
+
+## Quick Start
+
+### Python API
+
+```python
+import pandas as pd
+from quantcore import Backtest, MomentumStrategy
+
+# Load your OHLCV data
+data = pd.read_csv("market_data.csv", index_col=0, parse_dates=True)
+
+# Run a backtest with the Momentum strategy
+bt = Backtest(data, MomentumStrategy(lookback=20))
+bt.run()
+
+print(bt.summary())
+bt.export_csv("results.csv")
+```
+
+### CLI
+
+```bash
+quantcore backtest --data market_data.csv --strategy momentum
+quantcore backtest --data market_data.csv --strategy mean_reversion --output results.csv
+quantcore strategies
+```
+
+## Strategies
+
+### Momentum
+
+Buy when the rate of change over a lookback period is positive, sell when negative.
+
+```python
+from quantcore import Backtest, MomentumStrategy
+
+strategy = MomentumStrategy(lookback=20)
+bt = Backtest(data, strategy)
+bt.run()
+print(bt.summary())
+```
+
+### Mean Reversion
+
+Buy when price falls below its rolling mean by a threshold, sell when it reverts above.
+
+```python
+from quantcore import Backtest, MeanReversion
+
+strategy = MeanReversion(window=20, threshold=1.5)
+bt = Backtest(data, strategy)
+bt.run()
+print(bt.summary())
+```
+
+### Moving Average Crossover
+
+Buy on golden cross (short MA crosses above long MA), sell on death cross.
+
+```python
+from quantcore import Backtest, MovingAverageCrossover
+
+strategy = MovingAverageCrossover(short_window=20, long_window=50)
+bt = Backtest(data, strategy)
+bt.run()
+print(bt.summary())
+```
+
+## Performance Metrics
+
+Every backtest reports:
+
+| Metric | Description |
+|--------|-------------|
+| **Sharpe Ratio** | Risk-adjusted return (annualized) |
+| **Max Drawdown** | Largest peak-to-trough decline |
+| **CAGR** | Compound annual growth rate |
+| **Win Rate** | Percentage of profitable trades |
+| **Total Return** | Overall portfolio return |
+
+## Free vs Pro Comparison
+
+| Feature | Free | Pro |
+|---------|:----:|:---:|
+| Momentum strategy | ✅ | ✅ |
+| Mean Reversion strategy | ✅ | ✅ |
+| Moving Average Crossover strategy | ✅ | ✅ |
+| Performance metrics (Sharpe, CAGR, drawdown, win rate) | ✅ | ✅ |
+| CSV export | ✅ | ✅ |
+| CLI interface | ✅ | ✅ |
+| RSI, Bollinger Bands, MACD strategies | ❌ | ✅ |
+| Pairs Trading, Volatility Breakout, Turtle Trading | ❌ | ✅ |
+| Mean Reversion Z-Score, Kalman Filter, Dual Momentum, Sector Rotation | ❌ | ✅ |
+| Monte Carlo simulation (1000 runs, confidence intervals) | ❌ | ✅ |
+| Tearsheet PDF generator | ❌ | ✅ |
+| Parameter grid search optimizer | ❌ | ✅ |
+
+## ⭐ Pro Version
+
+Unlock 10 additional strategies, Monte Carlo simulation, tearsheet PDF reports, and parameter optimization.
+
+**[Get QuantCore Pro →](https://buy.polar.sh/polar_cl_rA97pLblKd1pRhwXezgssGgCp1NaKlDV0CeG74fP4q4)**
+
+Set your license key:
+
+```bash
+export QUANTCORE_LICENSE_KEY="your-license-key"
+```
+
+Then use Pro features:
+
+```bash
+quantcore backtest --data market_data.csv --strategy rsi --tearsheet report.pdf --monte-carlo
+quantcore optimize --data market_data.csv --strategy bollinger_bands
+```
+
+Pro features are validated via [Polar.sh](https://polar.sh) license keys.
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.

quantcore_lite-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quantcore-lite"
+version = "0.1.0"
+description = "Open-core backtesting framework for quantitative trading strategies"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    {name = "QuantCore Team"},
+]
+keywords = ["backtesting", "trading", "quantitative-finance", "strategies"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Office/Business :: Financial :: Investment",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+]
+dependencies = [
+    "pandas>=1.5.0",
+    "numpy>=1.23.0",
+    "matplotlib>=3.6.0",
+    "reportlab>=4.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Septal083/quantcore"
+Repository = "https://github.com/Septal083/quantcore"
+Issues = "https://github.com/Septal083/quantcore/issues"
+Changelog = "https://github.com/Septal083/quantcore/blob/main/CHANGELOG.md"
+
+[project.scripts]
+quantcore = "quantcore.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]

quantcore_lite-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

quantcore_lite-0.1.0/src/quantcore/__init__.py

@@ -0,0 +1,15 @@
+"""QuantCore — open-core backtesting framework for quantitative trading strategies."""
+
+__version__ = "0.1.0"
+
+from quantcore.engine import Backtest
+from quantcore.metrics import compute_metrics
+from quantcore.strategies import MeanReversion, MomentumStrategy, MovingAverageCrossover
+
+__all__ = [
+    "Backtest",
+    "compute_metrics",
+    "MomentumStrategy",
+    "MeanReversion",
+    "MovingAverageCrossover",
+]

quantcore_lite-0.1.0/src/quantcore/cli.py

@@ -0,0 +1,208 @@
+"""Command-line interface for QuantCore."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+from quantcore.engine import Backtest
+from quantcore.strategies import FREE_STRATEGIES
+
+
+def _get_all_strategies() -> dict:
+    """Return combined dict of free + pro strategies (pro only if licensed)."""
+    all_strats = dict(FREE_STRATEGIES)
+    try:
+        from quantcore.pro.license import validate_license
+
+        if validate_license():
+            from quantcore.pro.strategies import PRO_STRATEGIES
+
+            all_strats.update(PRO_STRATEGIES)
+    except Exception:
+        pass
+    return all_strats
+
+
+def cmd_backtest(args: argparse.Namespace) -> None:
+    """Run a backtest from the CLI."""
+    data_path = Path(args.data)
+    if not data_path.exists():
+        print(f"Error: Data file not found: {data_path}")
+        sys.exit(1)
+
+    data = pd.read_csv(data_path, parse_dates=True, index_col=0)
+
+    all_strategies = _get_all_strategies()
+    strategy_key = args.strategy.lower().replace("-", "_").replace(" ", "_")
+
+    if strategy_key not in all_strategies:
+        # Check if it's a pro strategy that requires license
+        from quantcore.pro.strategies import PRO_STRATEGIES
+
+        if strategy_key in PRO_STRATEGIES:
+            from quantcore.pro.license import require_pro
+
+            if not require_pro():
+                sys.exit(0)
+            all_strategies.update(PRO_STRATEGIES)
+        else:
+            available = ", ".join(sorted(all_strategies.keys()))
+            print(f"Error: Unknown strategy '{args.strategy}'. Available: {available}")
+            sys.exit(1)
+
+    strategy_cls = all_strategies[strategy_key]
+    strategy = strategy_cls()
+
+    bt = Backtest(
+        data,
+        strategy,
+        initial_capital=args.capital,
+        commission=args.commission,
+    )
+    bt.run()
+
+    print(bt.summary())
+    print()
+
+    if args.output:
+        out_path = bt.export_csv(args.output)
+        print(f"Results exported to: {out_path}")
+
+    if args.tearsheet:
+        from quantcore.pro.license import require_pro
+
+        if require_pro():
+            from quantcore.pro.monte_carlo import monte_carlo_simulation
+            from quantcore.pro.tearsheet import generate_tearsheet
+
+            mc = monte_carlo_simulation(bt.results, initial_capital=args.capital)
+            pdf_path = generate_tearsheet(
+                bt.results, bt.metrics, mc, strategy.name, args.tearsheet
+            )
+            print(f"Tearsheet saved to: {pdf_path}")
+
+    if args.monte_carlo:
+        from quantcore.pro.license import require_pro
+
+        if require_pro():
+            from quantcore.pro.monte_carlo import monte_carlo_simulation
+
+            mc = monte_carlo_simulation(
+                bt.results, n_simulations=args.mc_runs, initial_capital=args.capital
+            )
+            ci = mc["confidence_intervals"]
+            print(f"\nMonte Carlo ({mc['n_simulations']} simulations):")
+            print(f"  Median final value: ${mc['median_final']:,.2f}")
+            print(f"  Mean final value:   ${mc['mean_final']:,.2f}")
+            for pct, val in ci.items():
+                print(f"  {pct} percentile:    ${val:,.2f}")
+
+
+def cmd_strategies(args: argparse.Namespace) -> None:
+    """List available strategies."""
+    print("Free strategies:")
+    for name in sorted(FREE_STRATEGIES.keys()):
+        print(f"  - {name}")
+
+    print("\nPro strategies (requires license):")
+    from quantcore.pro.strategies import PRO_STRATEGIES
+
+    for name in sorted(PRO_STRATEGIES.keys()):
+        print(f"  - {name}")
+
+
+def cmd_optimize(args: argparse.Namespace) -> None:
+    """Run parameter grid search optimization."""
+    from quantcore.pro.license import require_pro
+
+    if not require_pro():
+        sys.exit(0)
+
+    from quantcore.pro.optimizer import grid_search
+
+    data = pd.read_csv(args.data, parse_dates=True, index_col=0)
+
+    all_strategies = dict(FREE_STRATEGIES)
+    from quantcore.pro.strategies import PRO_STRATEGIES
+
+    all_strategies.update(PRO_STRATEGIES)
+
+    strategy_key = args.strategy.lower().replace("-", "_").replace(" ", "_")
+    if strategy_key not in all_strategies:
+        print(f"Error: Unknown strategy '{args.strategy}'")
+        sys.exit(1)
+
+    # Default param grids per strategy
+    default_grids = {
+        "momentum": {"lookback": [10, 20, 30, 50]},
+        "mean_reversion": {"window": [10, 20, 30], "threshold": [1.0, 1.5, 2.0]},
+        "moving_average": {"short_window": [10, 20], "long_window": [30, 50, 100]},
+        "rsi": {"period": [7, 14, 21], "oversold": [20, 30], "overbought": [70, 80]},
+        "bollinger_bands": {"window": [10, 20, 30], "num_std": [1.5, 2.0, 2.5]},
+        "macd": {"fast": [8, 12], "slow": [21, 26], "signal": [7, 9]},
+    }
+
+    param_grid = default_grids.get(strategy_key, {"lookback": [10, 20, 30]})
+    results = grid_search(data, all_strategies[strategy_key], param_grid, metric=args.metric)
+
+    print(f"\nGrid search results for {strategy_key} (optimizing {args.metric}):\n")
+    for i, r in enumerate(results[:10]):
+        print(f"  #{i + 1}: {r['params']} -> {args.metric}={r['score']:.4f}")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the CLI argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="quantcore",
+        description="QuantCore — backtesting framework for quantitative trading strategies",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # backtest
+    bt_parser = subparsers.add_parser("backtest", help="Run a backtest")
+    bt_parser.add_argument("--data", "-d", required=True, help="Path to OHLCV CSV file")
+    bt_parser.add_argument(
+        "--strategy", "-s", required=True, help="Strategy name (e.g. momentum, mean_reversion)"
+    )
+    bt_parser.add_argument("--capital", "-c", type=float, default=100_000, help="Initial capital")
+    bt_parser.add_argument("--commission", type=float, default=0.001, help="Commission rate")
+    bt_parser.add_argument("--output", "-o", help="Output CSV path for results")
+    bt_parser.add_argument("--tearsheet", help="Output PDF path for tearsheet (Pro)")
+    bt_parser.add_argument("--monte-carlo", action="store_true", help="Run Monte Carlo sim (Pro)")
+    bt_parser.add_argument("--mc-runs", type=int, default=1000, help="Number of MC simulations")
+
+    # strategies
+    subparsers.add_parser("strategies", help="List available strategies")
+
+    # optimize
+    opt_parser = subparsers.add_parser("optimize", help="Grid search optimization (Pro)")
+    opt_parser.add_argument("--data", "-d", required=True, help="Path to OHLCV CSV file")
+    opt_parser.add_argument("--strategy", "-s", required=True, help="Strategy to optimize")
+    opt_parser.add_argument("--metric", "-m", default="sharpe_ratio", help="Metric to optimize")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Entry point for the quantcore CLI."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(0)
+
+    commands = {
+        "backtest": cmd_backtest,
+        "strategies": cmd_strategies,
+        "optimize": cmd_optimize,
+    }
+    commands[args.command](args)
+
+
+if __name__ == "__main__":
+    main()