Algo-trading was 😵💫, we made it 🤩
# Jesse
[](https://pypi.org/project/jesse)
[](https://pepy.tech/project/jesse)
[](https://hub.docker.com/r/salehmir/jesse)
[](https://github.com/jesse-ai/jesse)
[](https://codecov.io/gh/jesse-ai/jesse)
---
Jesse is an advanced crypto trading framework that aims to **simplify** **researching** and defining **YOUR OWN trading strategies** for backtesting, optimizing, and live trading.
## What is Jesse?
Watch this video to get a quick overview of Jesse:
[](https://www.youtube.com/watch?v=0EqN3OOqeJM)
## Why Jesse?
In short, Jesse is more **accurate** than other solutions, and way more **simple**.
In fact, it is so simple that in case you already know Python, you can get started today, in **matter of minutes**, instead of **weeks and months**.
## Key Features
- 📝 **Simple Syntax**: Define both simple and advanced trading strategies with the simplest syntax in the fastest time.
- 📊 **Comprehensive Indicator Library**: Access a complete library of technical indicators with easy-to-use syntax.
- 📈 **Smart Ordering**: Supports market, limit, and stop orders, automatically choosing the best one for you.
- ⏰ **Multiple Timeframes and Symbols**: Backtest and livetrade multiple timeframes and symbols simultaneously without look-ahead bias.
- 🔒 **Self-Hosted and Privacy-First**: Designed with your privacy in mind, fully self-hosted to ensure your trading strategies and data remain secure.
- 🛡️ **Risk Management**: Built-in helper functions for robust risk management.
- 📋 **Metrics System**: A comprehensive metrics system to evaluate your trading strategy's performance.
- 🔍 **Debug Mode**: Observe your strategy in action with a detailed debug mode.
- 🔧 **Optimize Mode**: Fine-tune your strategies using AI, without needing a technical background.
- 📈 **Leveraged and Short-Selling**: First-class support for leveraged trading and short-selling.
- 🔀 **Partial Fills**: Supports entering and exiting positions in multiple orders, allowing for greater flexibility.
- 🔔 **Advanced Alerts**: Create real-time alerts within your strategies for effective monitoring.
- 🤖 **JesseGPT**: Jesse has its own GPT, JesseGPT, that can help you write strategies, optimize them, debug them, and much more.
- 🔧 **Built-in Code Editor**: Write, edit, and debug your strategies with a built-in code editor.
- 📺 **Youtube Channel**: Jesse has a Youtube channel with screencast tutorials that go through example strategies step by step.
## Dive Deeper into Jesse's Capabilities
### Stupid Simple
Craft complex trading strategies with remarkably simple Python. Access 300+ indicators, multi-symbol/timeframe support, spot/futures trading, partial fills, and risk management tools. Focus on logic, not boilerplate.
```python
class GoldenCross(Strategy):
def should_long(self):
# go long when the EMA 8 is above the EMA 21
short_ema = ta.ema(self.candles, 8)
long_ema = ta.ema(self.candles, 21)
return short_ema > long_ema
def go_long(self):
entry_price = self.price - 10 # limit buy order at $10 below the current price
qty = utils.size_to_qty(self.balance*0.05, entry_price) # spend only 5% of my total capital
self.buy = qty, entry_price # submit entry order
self.take_profit = qty, entry_price*1.2 # take profit at 20% above the entry price
self.stop_loss = qty, entry_price*0.9 # stop loss at 10% below the entry price
```
### Backtest
Execute highly accurate and fast backtests without look-ahead bias. Utilize debugging logs, interactive charts with indicator support, and detailed performance metrics to validate your strategies thoroughly.
### Live/Paper Trading
Deploy strategies live with robust monitoring tools. Supports paper trading, multiple accounts, real-time logs & notifications (Telegram, Slack, Discord), interactive charts, spot/futures, DEX, and a built-in code editor.
### Benchmark
Accelerate research using the benchmark feature. Run batch backtests, compare across timeframes, symbols, and strategies. Filter and sort results by key performance metrics for efficient analysis.
### AI
Leverage our AI assistant even with limited Python knowledge. Get help writing and improving strategies, implementing ideas, debugging, optimizing, and understanding code. Your personal AI quant.
### Optimize Your Strategies
Unsure about optimal parameters? Let the optimization mode decide using simple syntax. Fine-tune any strategy parameter with the Optuna library and easy cross-validation.
```python
@property
def slow_sma(self):
return ta.sma(self.candles, self.hp['slow_sma_period'])
@property
def fast_sma(self):
return ta.sma(self.candles, self.hp['fast_sma_period'])
def hyperparameters(self):
return [
{'name': 'slow_sma_period', 'type': int, 'min': 150, 'max': 210, 'default': 200},
{'name': 'fast_sma_period', 'type': int, 'min': 20, 'max': 100, 'default': 50},
]
```
## Getting Started
Head over to the "getting started" section of the [documentation](https://docs.jesse.trade/docs/getting-started). The
documentation is **short yet very informative**.
## Resources
- [⚡️ Website](https://jesse.trade)
- [🎓 Documentation](https://docs.jesse.trade)
- [🎥 Youtube channel (screencast tutorials)](https://jesse.trade/youtube)
- [🛟 Help center](https://jesse.trade/help)
- [💬 Discord community](https://jesse.trade/discord)
- [🤖 JesseGPT](https://jesse.trade/gpt) (Requires a free account)
## What's next?
You can see the project's **[roadmap here](https://docs.jesse.trade/docs/roadmap.html)**. **Subscribe** to our mailing list at [jesse.trade](https://jesse.trade) to get the good stuff as soon they're released. Don't worry, We won't send you spam—Pinky promise.
## Disclaimer
This software is for educational purposes only. USE THE SOFTWARE AT **YOUR OWN RISK**. THE AUTHORS AND ALL AFFILIATES ASSUME **NO RESPONSIBILITY FOR YOUR TRADING RESULTS**. **Do not risk money that you are afraid to lose**. There might be **bugs** in the code - this software DOES NOT come with **ANY warranty**.
================================================
FILE: codecov.yml
================================================
ignore:
- "tests/**"
================================================
FILE: conftest.py
================================================
def pytest_configure(config):
config.addinivalue_line(
"filterwarnings",
"ignore:Please use `import python_multipart` instead.:PendingDeprecationWarning",
)
================================================
FILE: jesse/__init__.py
================================================
import os
import warnings
from contextlib import asynccontextmanager
from fastapi.responses import FileResponse
from fastapi.staticfiles import StaticFiles
from jesse.services.web import fastapi_app
import jesse.helpers as jh
# import cli to register the routes. Do NOT remove this import.
from jesse.cli import cli
# to silent stupid pandas warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
# get the jesse directory
JESSE_DIR = os.path.dirname(os.path.abspath(__file__))
# define lifespan (replaces deprecated @on_event("shutdown"))
@asynccontextmanager
async def lifespan(app):
yield
from jesse.services.db import database
database.close_connection()
from jesse.services.lsp import terminate_lsp_server
terminate_lsp_server()
fastapi_app.router.lifespan_context = lifespan
# load homepage
@fastapi_app.get("/")
async def index():
return FileResponse(f"{JESSE_DIR}/static/index.html")
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Routes
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
from jesse.controllers.websocket_controller import router as websocket_router
from jesse.controllers.optimization_controller import router as optimization_router
from jesse.controllers.monte_carlo_controller import router as monte_carlo_router
from jesse.controllers.exchange_controller import router as exchange_router
from jesse.controllers.backtest_controller import router as backtest_router
from jesse.controllers.candles_controller import router as candles_router
from jesse.controllers.strategy_controller import router as strategy_router
from jesse.controllers.auth_controller import router as auth_router
from jesse.controllers.config_controller import router as config_router
from jesse.controllers.notification_controller import router as notification_router
from jesse.controllers.system_controller import router as system_router
from jesse.controllers.file_controller import router as file_router
from jesse.controllers.lsp_controller import router as lsp_router
from jesse.controllers.closed_trade_controller import router as closed_trade_router
from jesse.controllers.order_controller import router as order_router
from jesse.controllers.tabs_controller import router as tabs_router
# register routers
fastapi_app.include_router(websocket_router)
fastapi_app.include_router(optimization_router)
fastapi_app.include_router(monte_carlo_router)
fastapi_app.include_router(exchange_router)
fastapi_app.include_router(backtest_router)
fastapi_app.include_router(candles_router)
fastapi_app.include_router(strategy_router)
fastapi_app.include_router(auth_router)
fastapi_app.include_router(config_router)
fastapi_app.include_router(notification_router)
fastapi_app.include_router(system_router)
fastapi_app.include_router(file_router)
fastapi_app.include_router(lsp_router)
fastapi_app.include_router(closed_trade_router)
fastapi_app.include_router(order_router)
fastapi_app.include_router(tabs_router)
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Live Trade Plugin
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
if jh.has_live_trade_plugin():
from jesse.controllers.live_controller import router as live_router
fastapi_app.include_router(live_router)
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Static Files (Must be loaded at the end to prevent overlapping with API endpoints)
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
fastapi_app.mount("/", StaticFiles(directory=f"{JESSE_DIR}/static"), name="static")
================================================
FILE: jesse/candle_pipelines/__init__.py
================================================
from .base_candles import BaseCandlesPipeline
from .gaussian_noise import GaussianNoiseCandlesPipeline
from .gaussian_resampler import GaussianResamplerCandlesPipeline
from .moving_block_bootstrap import MovingBlockBootstrapCandlesPipeline
================================================
FILE: jesse/candle_pipelines/base_candles.py
================================================
import numpy as np
class BaseCandlesPipeline:
def __init__(self, batch_size: int) -> None:
self._batch_size = batch_size
self._output: np.ndarray = np.zeros((batch_size, 6))
self.last_price = 0.0
def get_candles(self, candles: np.ndarray, index: int, candles_step: int = -1) -> np.ndarray:
index = index % self._batch_size
if index == 0:
if self.last_price == 0.0:
self.last_price = candles[0, 1] # the first time use open price instead of last close
else:
self.last_price = self._output[-1, 2] # later use the last_price
inject_candle = self.process(candles, self._output[:len(candles)])
if not inject_candle:
self._output[:] = candles
if candles_step == -1:
return self._output[index]
if index + candles_step <= self._batch_size:
return self._output[index:index + candles_step]
raise ValueError("Batch size to candle pipeline supported only multiplication of the minimum timeframe in your"
" routes.")
def process(self, original_1m_candles: np.ndarray, out: np.ndarray) -> bool:
"""
:param original_1m_candles: get original 1m candles to modify it for research purposes to test various scenarios.
Get the next `batch_size` 1m candles.
:param out: The candles that will be injected to the simulation instead of the original 1m candles.
Contains the previous batch.
:return: True if out is modified, False otherwise
"""
return False
================================================
FILE: jesse/candle_pipelines/gaussian_noise.py
================================================
import numpy as np
import jesse.helpers as jh
from .base_candles import BaseCandlesPipeline
class GaussianNoiseCandlesPipeline(BaseCandlesPipeline):
def __init__(self, batch_size: int, *,
close_mu: float = 0.0,
close_sigma: float,
high_mu: float = 0.0,
high_sigma: float,
low_mu: float = 0.0,
low_sigma: float,
) -> None:
"""
Add gaussian noise to candles
"""
super().__init__(batch_size)
self._first_time = True
self.close_mu = close_mu
self.close_sigma = close_sigma
self.high_mu = high_mu
self.high_sigma = high_sigma
self.low_mu = low_mu
self.low_sigma = low_sigma
def process(self, original_1m_candles: np.ndarray, out: np.ndarray) -> bool:
eps = 1e-12
if not self._first_time:
last_price = out[-1, 2] # last_close_price
else:
self._first_time = False
# in case we don't have history set the price as the first price so the bias will be 0
last_price = original_1m_candles[0, 1]
out[:] = original_1m_candles[:]
n = len(out)
# close price
noise = np.random.normal(self.close_mu, self.close_sigma, size=n).cumsum()
out[:, 2] = np.maximum(out[:, 2] + noise, eps)
# open price
out[1:, 1] = out[:-1, 2]
out[0, 1] = max(last_price, eps)
# high
high_std = 0.0 if self.high_sigma == 0.0 else np.random.normal(0, self.high_sigma, size=n)
out[:, 3] = out[:, 3] + self.high_mu + high_std
# low
low_std = 0.0 if self.low_sigma == 0.0 else np.random.normal(0, self.low_sigma, size=n)
out[:, 4] = out[:, 4] + self.low_mu + low_std
# enforce bounds and positivity
out[:, 1] = np.maximum(out[:, 1], eps)
out[:, 2] = np.maximum(out[:, 2], eps)
out[:, 3] = np.maximum(np.maximum(out[:, 1], out[:, 2]), np.maximum(out[:, 3], out[:, 4]))
out[:, 4] = np.minimum(np.minimum(out[:, 1], out[:, 2]), np.minimum(out[:, 3], out[:, 4]))
out[:, 4] = np.maximum(out[:, 4], eps)
return True
================================================
FILE: jesse/candle_pipelines/gaussian_resampler.py
================================================
import numpy as np
from typing import Optional
from .base_candles import BaseCandlesPipeline
class GaussianResamplerCandlesPipeline(BaseCandlesPipeline):
def __init__(self, batch_size: int, *,
mu: float = 0.0, sigma: Optional[float] = None,
) -> None:
"""
Add gaussian noise to candles
"""
super().__init__(batch_size)
self.mu = mu
self.sigma = sigma
def process(self, original_1m_candles: np.ndarray, out: np.ndarray) -> bool:
eps = 1e-12
out[:] = original_1m_candles[:]
# close price
closes = original_1m_candles[:, 2]
n = len(out)
med_price = float(np.nan_to_num(np.median(closes), nan=0.0))
delta_close = np.diff(closes, prepend=self.last_price)
mu_delta = float(np.nan_to_num(np.mean(delta_close[1:]), nan=0.0))
sigma_delta_close = float(np.nan_to_num(np.std(delta_close[1:]), nan=0.0))
# derive scale factor from relative returns if sigma is not provided
if self.sigma is None:
if n >= 2:
rel_returns = np.diff(closes) / np.maximum(closes[:-1], eps)
ret_std = float(np.nan_to_num(np.std(rel_returns), nan=0.0))
else:
ret_std = 0.0
target_abs_close_std = max((ret_std * med_price) if ret_std > 0.0 else (med_price * 0.0005), eps)
scale_factor = target_abs_close_std / max(sigma_delta_close, eps)
else:
scale_factor = self.sigma
std_close = sigma_delta_close * scale_factor
# debug the effective parameters used for the close process
out[:, 2] = np.random.normal(mu_delta + self.mu, std_close, size=n).cumsum() + self.last_price
out[:, 2] = np.maximum(out[:, 2], eps)
# open price
out[1:, 1] = out[:-1, 2]
out[0, 1] = max(self.last_price, eps)
# high
delta_high_close = original_1m_candles[:, 3] - original_1m_candles[:, 2]
mu_delta = float(np.nan_to_num(np.mean(delta_high_close), nan=0.0))
sigma_delta_high = float(np.nan_to_num(np.std(delta_high_close), nan=0.0))
std_high = sigma_delta_high * scale_factor
out[:, 3] = out[:, 2] + np.random.normal(mu_delta + self.mu, std_high, size=n)
delta_close_low = original_1m_candles[:, 2] - original_1m_candles[:, 4]
mu_delta = float(np.nan_to_num(np.mean(delta_close_low), nan=0.0))
sigma_delta_low = float(np.nan_to_num(np.std(delta_close_low), nan=0.0))
std_low = sigma_delta_low * scale_factor
out[:, 4] = out[:, 2] - np.random.normal(mu_delta + self.mu, std_low, size=n)
# enforce bounds and positivity
out[:, 1] = np.maximum(out[:, 1], eps)
out[:, 2] = np.maximum(out[:, 2], eps)
out[:, 3] = np.maximum(np.maximum(out[:, 1], out[:, 2]), np.maximum(out[:, 3], out[:, 4]))
out[:, 4] = np.minimum(np.minimum(out[:, 1], out[:, 2]), np.minimum(out[:, 3], out[:, 4]))
out[:, 4] = np.maximum(out[:, 4], eps)
return True
================================================
FILE: jesse/candle_pipelines/moving_block_bootstrap.py
================================================
import numpy as np
from .base_candles import BaseCandlesPipeline
class MovingBlockBootstrapCandlesPipeline(BaseCandlesPipeline):
def __init__(self, batch_size: int, **_ignored) -> None:
"""
Generate synthetic candles by moving-block bootstrap on multivariate
tuples of (delta_close, delta_high, delta_low).
Parameters
----------
batch_size : int
Size of the internal regeneration buffer in minutes. The pipeline
derives a reasonable bootstrap block length from this, so there is
no separate block-size argument.
"""
super().__init__(batch_size)
# Derive block size from batch size. Heuristic: max(10, batch_size // 10),
# then clamp to [1, batch_size - 1]. This preserves short-horizon
# dependence while allowing variety.
derived_block_size = max(10, batch_size // 10)
derived_block_size = max(1, min(batch_size - 1, derived_block_size))
self._block_size = derived_block_size
# Independent RNG per pipeline instance to avoid identical scenarios
self._rng = np.random.default_rng()
def _bootstrap_blocks(self, arr: np.ndarray, n: int) -> np.ndarray:
"""
Sample overlapping blocks of rows from `arr` to build a length-n output.
`arr` is shape (T, 3) for the three deltas.
"""
T, D = arr.shape
if T == 0:
return np.zeros((n, 3), dtype=arr.dtype)
# Use the configured block_size, but not beyond available data
effective_block_size = max(1, min(self._block_size, T))
max_start = T - effective_block_size
# how many blocks needed to reach n rows
num_blocks = int(np.ceil(n / effective_block_size)) + 1
starts = self._rng.integers(0, max_start + 1, size=num_blocks)
blocks = [arr[s : s + effective_block_size] for s in starts]
boot = np.vstack(blocks)
return boot[:n]
def process(self, original_1m_candles: np.ndarray, out: np.ndarray) -> bool:
# copy everything first (timestamps, volumes, etc)
out[:] = original_1m_candles[:]
n = len(out)
# strictly positive floor to avoid invalid negative prices
eps = 1e-12
# compute the 3 deltas for each bar
delta_close = np.diff(original_1m_candles[:, 2], prepend=self.last_price)
delta_high = original_1m_candles[:, 3] - original_1m_candles[:, 2]
delta_low = original_1m_candles[:, 2] - original_1m_candles[:, 4]
# stack into shape (T, 3), skipping the first delta_close entry (prepend)
deltas = np.column_stack([delta_close[1:], delta_high[1:], delta_low[1:]])
# bootstrap blocks of the 3-tuples
boot_deltas = self._bootstrap_blocks(deltas, n)
# rebuild close prices (ensure strictly positive)
boot_close = np.cumsum(boot_deltas[:, 0]) + self.last_price
boot_close = np.maximum(boot_close, eps)
out[:, 2] = boot_close
# rebuild opens
out[1:, 1] = boot_close[:-1]
out[0, 1] = max(self.last_price, eps)
# rebuild high and low from the bootstrapped ranges
out[:, 3] = boot_close + boot_deltas[:, 1]
out[:, 4] = boot_close - boot_deltas[:, 2]
# enforce the true high/low bounds and positivity
out[:, 1] = np.maximum(out[:, 1], eps)
out[:, 2] = np.maximum(out[:, 2], eps)
out[:, 3] = np.maximum.reduce([out[:, 1], out[:, 2], out[:, 3], out[:, 4]])
out[:, 4] = np.minimum.reduce([out[:, 1], out[:, 2], out[:, 3], out[:, 4]])
out[:, 4] = np.maximum(out[:, 4], eps)
return True
================================================
FILE: jesse/cli.py
================================================
import time
import click
from importlib.metadata import version as get_version
import uvicorn
import jesse.helpers as jh
from jesse.services.multiprocessing import process_manager
from jesse.services.web import fastapi_app
@click.group()
@click.version_option(get_version("jesse"))
def cli() -> None:
"""CLI entrypoint for Jesse."""
pass
@cli.command()
@click.option(
"--strict/--no-strict",
default=True,
help="Default is the strict mode which will raise an exception if the values for license is not set.",
)
def install_live(strict: bool) -> None:
"""Install and configure the live trading plugin."""
from jesse.services.installer import install
install(is_live_plugin_already_installed=jh.has_live_trade_plugin(), strict=strict)
@cli.command()
def run() -> None:
"""Start the Jesse application server."""
# Display welcome message
welcome_message = """
██╗███████╗███████╗███████╗███████╗
██║██╔════╝██╔════╝██╔════╝██╔════╝
██║█████╗ ███████╗███████╗█████╗
██ ██║██╔══╝ ╚════██║╚════██║██╔══╝
╚█████╔╝███████╗███████║███████║███████╗
╚════╝ ╚══════╝╚══════╝╚══════╝╚══════╝
"""
version = get_version("jesse")
print(welcome_message)
print(f"Main Framework Version: {version}")
# Check if jesse-live is installed and display its version
if jh.has_live_trade_plugin():
try:
from jesse_live.version import __version__ as live_version
print(f"Live Plugin Version: {live_version}")
except ImportError:
pass
jh.validate_cwd()
print("")
# run all the db migrations
from jesse.services.migrator import run as run_migrations
import peewee
try:
run_migrations()
except peewee.OperationalError:
sleep_seconds = 10
print(f"Database wasn't ready. Sleep for {sleep_seconds} seconds and try again.")
time.sleep(sleep_seconds)
run_migrations()
# Install Python Language Server if needed
try:
from jesse.services.lsp import install_lsp_server
install_lsp_server()
except Exception as e:
print(jh.color(f"Error installing Python Language Server: {str(e)}", "red"))
pass
# read port from .env file, if not found, use default
from jesse.services.env import ENV_VALUES
if "APP_PORT" in ENV_VALUES:
port = int(ENV_VALUES["APP_PORT"])
else:
port = 9000
if "APP_HOST" in ENV_VALUES:
host = ENV_VALUES["APP_HOST"]
else:
host = "0.0.0.0"
# run the lsp server
try:
from jesse.services.lsp import run_lsp_server
run_lsp_server()
except Exception as e:
print(jh.color(f"Error running Python Language Server: {str(e)}", "red"))
pass
# run the main application
process_manager.flush()
uvicorn.run(fastapi_app, host=host, port=port, log_level="info")
================================================
FILE: jesse/config.py
================================================
import jesse.helpers as jh
from jesse.modes.utils import get_exchange_type
from jesse.enums import exchanges
from jesse.info import exchange_info
# Main configuration used by the Jesse framework. These values are modified
# at runtime based on the mode (backtest, live, or optimize) and user settings.
config = {
# these values are related to the user's environment
'env': {
'caching': {
'driver': 'pickle'
},
'logging': {
'strategy_execution': True,
'order_submission': True,
'order_cancellation': True,
'order_execution': True,
'position_opened': True,
'position_increased': True,
'position_reduced': True,
'position_closed': True,
'shorter_period_candles': False,
'trading_candles': True,
'balance_update': True,
'exchange_ws_reconnection': True
},
# fill it later in this file using data in info.py
'exchanges': {
exchanges.SANDBOX: {
'fee': 0,
'type': 'futures',
# accepted values are: 'cross' and 'isolated'
'futures_leverage_mode': 'cross',
# 1x, 2x, 10x, 50x, etc. Enter as integers
'futures_leverage': 1,
'balance': 10_000,
},
},
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Optimize mode (using Optuna)
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# Below configurations are related to the optimize mode
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
'optimization': {
# available ratio options: sharpe, calmar, sortino, omega, serenity, smart sharpe, smart sortino
'objective_function': 'sharpe',
# number of trials per each hyperparameter
'trials': 200,
# number of best candidates to keep and display
'best_candidates_count': 20,
},
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Data
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# Below configurations are related to the data
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
'data': {
# The minimum number of warmup candles that is loaded before each session.
'warmup_candles_num': 240,
'generate_candles_from_1m': False,
'persistency': True,
},
},
# These values are just placeholders used by Jesse at runtime
'app': {
# list of currencies to consider
'considering_symbols': [],
# The symbol to trade.
'trading_symbols': [],
# list of time frames to consider
'considering_timeframes': [],
# Which candle type do you intend trade on
'trading_timeframes': [],
# list of exchanges to consider
'considering_exchanges': [],
# list of exchanges to consider
'trading_exchanges': [],
'considering_candles': [],
# dict of registered live trade drivers
'live_drivers': {},
# Accepted values are: 'backtest', 'livetrade', 'fitness'.
'trading_mode': '',
# this would enable many console.log()s in the code, which are helpful for debugging.
'debug_mode': False,
# this is only used for the live unit tests
'is_unit_testing': False,
},
}
# set exchange config values based on the info
for key in exchange_info:
config['env']['exchanges'][key] = {
'fee': exchange_info[key]['fee'],
'type': exchange_info[key]['type'],
'futures_leverage_mode': 'cross',
'futures_leverage': 1,
'balance': 10_000
}
def set_config(conf: dict) -> None:
global config
# optimization mode only
if jh.is_optimizing():
# objective function
if 'objective_function' in conf:
config['env']['optimization']['objective_function'] = conf['objective_function']
# warm_up_candles
config['env']['data']['warmup_candles_num'] = int(conf['warm_up_candles'])
# number of trials per each hyperparameter
config['env']['optimization']['trials'] = int(conf['trials'])
# best candidates count
if 'best_candidates_count' in conf:
config['env']['optimization']['best_candidates_count'] = int(conf['best_candidates_count'])
# backtest and live
if jh.is_backtesting() or jh.is_live():
# warm_up_candles
config['env']['data']['warmup_candles_num'] = int(conf['warm_up_candles'])
# logs
config['env']['logging'] = conf['logging']
# exchanges
for key, e in conf['exchanges'].items():
if not jh.is_live() and e['type']:
exchange_type = e['type']
else:
exchange_type = get_exchange_type(e['name'])
config['env']['exchanges'][e['name']] = {
'fee': float(e['fee']),
'type': exchange_type,
'balance': float(e['balance'])
}
if config['env']['exchanges'][e['name']]['type'] == 'futures':
# 1x, 2x, 10x, 50x, etc. Enter as integers
config['env']['exchanges'][e['name']]['futures_leverage'] = int(e.get('futures_leverage', 1))
# accepted values are: 'cross' and 'isolated'
config['env']['exchanges'][e['name']]['futures_leverage_mode'] = e.get('futures_leverage_mode', 'cross')
# live mode only
if jh.is_live():
config['env']['notifications'] = conf['notifications']
config['env']['data']['persistency'] = conf['persistency']
config['env']['data']['generate_candles_from_1m'] = conf['generate_candles_from_1m']
# TODO: must become a config value later when we go after multi account support?
config['env']['identifier'] = 'main'
def reset_config() -> None:
global config
config = backup_config.copy()
backup_config = config.copy()
================================================
FILE: jesse/constants.py
================================================
from jesse.enums import timeframes
CANDLE_SOURCE_MAPPING = {
"open": lambda c: c[:, 1],
"close": lambda c: c[:, 2],
"high": lambda c: c[:, 3],
"low": lambda c: c[:, 4],
"volume": lambda c: c[:, 5],
"hl2": lambda c: (c[:, 3] + c[:, 4]) / 2,
"hlc3": lambda c: (c[:, 3] + c[:, 4] + c[:, 2]) / 3,
"ohlc4": lambda c: (c[:, 1] + c[:, 3] + c[:, 4] + c[:, 2]) / 4,
}
TIMEFRAME_PRIORITY = [
timeframes.DAY_1,
timeframes.HOUR_12,
timeframes.HOUR_8,
timeframes.HOUR_6,
timeframes.HOUR_4,
timeframes.HOUR_3,
timeframes.HOUR_2,
timeframes.HOUR_1,
timeframes.MINUTE_45,
timeframes.MINUTE_30,
timeframes.MINUTE_15,
timeframes.MINUTE_5,
timeframes.MINUTE_3,
timeframes.MINUTE_1,
]
TIMEFRAME_TO_ONE_MINUTES = {
timeframes.MINUTE_1: 1,
timeframes.MINUTE_3: 3,
timeframes.MINUTE_5: 5,
timeframes.MINUTE_15: 15,
timeframes.MINUTE_30: 30,
timeframes.MINUTE_45: 45,
timeframes.HOUR_1: 60,
timeframes.HOUR_2: 60 * 2,
timeframes.HOUR_3: 60 * 3,
timeframes.HOUR_4: 60 * 4,
timeframes.HOUR_6: 60 * 6,
timeframes.HOUR_8: 60 * 8,
timeframes.HOUR_12: 60 * 12,
timeframes.DAY_1: 60 * 24,
timeframes.DAY_3: 60 * 24 * 3,
timeframes.WEEK_1: 60 * 24 * 7,
timeframes.MONTH_1: 60 * 24 * 30,
}
SUPPORTED_COLORS = {
'black',
'red',
'green',
'yellow',
'blue',
'magenta',
'cyan',
'white',
#'gray',
}
================================================
FILE: jesse/controllers/__init__.py
================================================
from .exchange_controller import get_exchange_supported_symbols
================================================
FILE: jesse/controllers/auth_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header, BackgroundTasks
from fastapi.responses import JSONResponse
import requests
from jesse.services.env import ENV_VALUES
from jesse.services import auth as authenticator
from jesse.services.multiprocessing import process_manager
from jesse.services.web import LoginRequestJson
import jesse.helpers as jh
from jesse.info import JESSE_API2_URL
router = APIRouter(prefix="/auth", tags=["Authentication"])
@router.post("/login")
def login(json_request: LoginRequestJson):
"""
Authenticate user with password and return a token
"""
return authenticator.password_to_token(json_request.password)
@router.post("/user-validation")
def login(json_request: LoginRequestJson):
"""
Authenticate user with password and return a token
"""
return authenticator.user_validation(json_request.password)
@router.post("")
def auth(json_request: LoginRequestJson):
"""
Authenticate user with password and return a token
"""
return authenticator.password_to_token(json_request.password)
@router.post("/shutdown")
async def shutdown(background_tasks: BackgroundTasks, authorization: Optional[str] = Header(None)):
"""
Shutdown the application
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
background_tasks.add_task(jh.terminate_app)
return JSONResponse({'message': 'Shutting down...'})
@router.post("/jesse-trade-token")
async def jesse_trade_token(authorization: Optional[str] = Header(None)):
"""
Exchange LICENSE_API_TOKEN for jesse.trade bearer token
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
if 'LICENSE_API_TOKEN' not in ENV_VALUES or not ENV_VALUES['LICENSE_API_TOKEN']:
return JSONResponse({
'status': 'error',
'message': 'LICENSE_API_TOKEN not found in .env file'
}, status_code=400)
license_token = ENV_VALUES['LICENSE_API_TOKEN']
try:
response = requests.post(
f'{JESSE_API2_URL}/auth/exchange-token',
json={'license_api_token': license_token},
timeout=10
)
if response.status_code == 200:
data = response.json()
return JSONResponse({
'status': 'success',
'access_token': data.get('access_token'),
'user': data.get('user')
})
else:
return JSONResponse({
'status': 'error',
'message': f'Failed to exchange token: {response.text}'
}, status_code=response.status_code)
except requests.exceptions.RequestException as e:
return JSONResponse({
'status': 'error',
'message': f'Error connecting to jesse.trade: {str(e)}'
}, status_code=500)
================================================
FILE: jesse/controllers/backtest_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header, Query, Body
from fastapi.responses import JSONResponse, FileResponse
import json
from jesse.services import auth as authenticator
from jesse.services.multiprocessing import process_manager
from jesse.services.web import BacktestRequestJson, CancelRequestJson, UpdateBacktestSessionStateRequestJson, GetBacktestSessionsRequestJson, UpdateBacktestSessionNotesRequestJson
import jesse.helpers as jh
from jesse.models.BacktestSession import (
get_backtest_sessions as get_sessions,
update_backtest_session_state,
update_backtest_session_notes,
delete_backtest_session,
get_backtest_session_by_id as get_backtest_session_by_id_from_db,
update_backtest_session_status,
purge_backtest_sessions
)
from jesse.services.transformers import get_backtest_session, get_backtest_session_for_load_more
from jesse.modes.backtest_mode import run as run_backtest
from jesse.modes.data_provider import get_backtest_logs, download_backtest_log
router = APIRouter(prefix="/backtest", tags=["Backtest"])
@router.post("")
def backtest(request_json: BacktestRequestJson, authorization: Optional[str] = Header(None)):
"""
Start a backtest process
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
jh.validate_cwd()
process_manager.add_task(
run_backtest,
request_json.id,
request_json.debug_mode,
request_json.config,
request_json.exchange,
request_json.routes,
request_json.data_routes,
request_json.start_date,
request_json.finish_date,
None,
request_json.export_chart,
request_json.export_tradingview,
request_json.export_csv,
request_json.export_json,
request_json.fast_mode,
request_json.benchmark
)
return JSONResponse({'message': 'Started backtesting...'}, status_code=202)
@router.post("/cancel")
def cancel_backtest(request_json: CancelRequestJson, authorization: Optional[str] = Header(None)):
"""
Cancel a backtest process
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
process_manager.cancel_process(request_json.id)
update_backtest_session_status(request_json.id, 'cancelled')
return JSONResponse({'message': f'Backtest process with ID of {request_json.id} was requested for termination'},
status_code=202)
@router.get("/logs/{session_id}")
def get_logs(session_id: str, token: str = Query(...)):
"""
Get logs as text for a specific session. Similar to download but returns text content instead of file.
"""
if not authenticator.is_valid_token(token):
return authenticator.unauthorized_response()
try:
content = get_backtest_logs(session_id)
if content is None:
return JSONResponse({'error': 'Log file not found'}, status_code=404)
return JSONResponse({'content': content}, status_code=200)
except Exception as e:
return JSONResponse({'error': str(e)}, status_code=500)
@router.get("/download-log/{session_id}")
def download_backtest_log(session_id: str, token: str = Query(...)):
"""
Download log file for a specific backtest session
"""
if not authenticator.is_valid_token(token):
return authenticator.unauthorized_response()
try:
return download_backtest_log(session_id)
except Exception as e:
return JSONResponse({'error': str(e)}, status_code=500)
@router.post("/sessions")
def get_backtest_sessions(request_json: GetBacktestSessionsRequestJson = Body(default=GetBacktestSessionsRequestJson()), authorization: Optional[str] = Header(None)):
"""
Get a list of backtest sessions sorted by most recently updated with pagination
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# Get sessions from the database with pagination and filters
sessions = get_sessions(
limit=request_json.limit,
offset=request_json.offset,
title_search=request_json.title_search,
status_filter=request_json.status_filter,
date_filter=request_json.date_filter
)
# Transform the sessions using the transformer
transformed_sessions = [get_backtest_session(session) for session in sessions]
return JSONResponse({
'sessions': transformed_sessions,
'count': len(transformed_sessions)
})
@router.post("/sessions/{session_id}")
def get_backtest_session_by_id(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get a single backtest session by ID
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# Get the session from the database
session = get_backtest_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
# Transform the session using the transformer
transformed_session = get_backtest_session_for_load_more(session)
transformed_session = jh.clean_infinite_values(transformed_session)
return JSONResponse({
'session': transformed_session
})
@router.post("/update-state")
def update_session_state(request_json: UpdateBacktestSessionStateRequestJson, authorization: Optional[str] = Header(None)):
"""
Update the state of a backtest session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
update_backtest_session_state(request_json.id, request_json.state)
return JSONResponse({
'message': 'Backtest session state updated successfully'
})
@router.post("/sessions/{session_id}/remove")
def remove_backtest_session(session_id: str, authorization: Optional[str] = Header(None)):
"""
Remove a backtest session from the database
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_backtest_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
# Delete the session from the database
result = delete_backtest_session(session_id)
if not result:
return JSONResponse({
'error': f'Failed to delete session with ID {session_id}'
}, status_code=500)
return JSONResponse({
'message': 'Backtest session removed successfully'
})
@router.post("/sessions/{session_id}/notes")
def update_session_notes(session_id: str, request_json: UpdateBacktestSessionNotesRequestJson, authorization: Optional[str] = Header(None)):
"""
Update the notes (title, description, strategy_codes) of a backtest session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_backtest_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
update_backtest_session_notes(session_id, request_json.title, request_json.description, request_json.strategy_codes)
return JSONResponse({
'message': 'Backtest session notes updated successfully'
})
@router.post("/purge-sessions")
def purge_sessions(request_json: dict = Body(...), authorization: Optional[str] = Header(None)):
"""
Purge backtest sessions older than specified days
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
days_old = request_json.get('days_old', None)
deleted_count = purge_backtest_sessions(days_old)
return JSONResponse({
'message': f'Successfully purged {deleted_count} session(s)',
'deleted_count': deleted_count
}, status_code=200)
@router.post("/sessions/{session_id}/chart-data")
def get_backtest_session_chart_data(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get chart data for a specific backtest session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_backtest_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
chart_data = jh.clean_infinite_values(json.loads(session.chart_data)) if session.chart_data else None
return JSONResponse({
'chart_data': chart_data
})
@router.post("/sessions/{session_id}/strategy-code")
def get_backtest_session_strategy_codes(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get strategy codes for a specific backtest session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_backtest_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
return JSONResponse({
'strategy_code': json.loads(session.strategy_codes) if session.strategy_codes else {}
})
================================================
FILE: jesse/controllers/candles_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header
from starlette.responses import JSONResponse
from jesse.repositories import candle_repository
from jesse.services import auth as authenticator
from jesse.services.multiprocessing import process_manager
from jesse.services.web import ImportCandlesRequestJson, CancelRequestJson, GetCandlesRequestJson, DeleteCandlesRequestJson
import jesse.helpers as jh
router = APIRouter(prefix="/candles", tags=["Candles"])
@router.post("/import")
def import_candles(request_json: ImportCandlesRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Import candles for a specific exchange and symbol
"""
jh.validate_cwd()
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes import import_candles_mode
process_manager.add_task(
import_candles_mode.run,
request_json.id,
request_json.exchange,
request_json.symbol,
request_json.start_date
)
return JSONResponse({'message': 'Started importing candles...'}, status_code=202)
@router.post("/cancel-import")
def cancel_import_candles(request_json: CancelRequestJson, authorization: Optional[str] = Header(None)):
"""
Cancel an import candles process
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
process_manager.cancel_process(request_json.id)
return JSONResponse({'message': f'Candles process with ID of {request_json.id} was requested for termination'},
status_code=202)
@router.post("/clear-cache")
def clear_candles_database_cache(authorization: Optional[str] = Header(None)):
"""
Clear the candles database cache
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services.cache import cache
cache.flush()
return JSONResponse({
'status': 'success',
'message': 'Candles database cache cleared successfully',
}, status_code=200)
@router.post("/get")
def get_candles(json_request: GetCandlesRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Get candles for a specific exchange, symbol, and timeframe
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
jh.validate_cwd()
from jesse.modes.data_provider import get_candles as gc
arr = gc(json_request.exchange, json_request.symbol, json_request.timeframe)
return JSONResponse({
'id': json_request.id,
'data': arr
}, status_code=200)
@router.post("/existing")
def get_existing_candles(authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Get all existing candles in the database
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
data = candle_repository.get_existing_candles()
return JSONResponse({'data': data}, status_code=200)
except Exception as e:
return JSONResponse({'error': str(e)}, status_code=500)
@router.post("/delete")
def delete_candles(json_request: DeleteCandlesRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Delete candles for a specific exchange and symbol
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
candle_repository.delete_candles_from_db(json_request.exchange, json_request.symbol)
return JSONResponse({'message': 'Candles deleted successfully'}, status_code=200)
except Exception as e:
return JSONResponse({'error': str(e)}, status_code=500)
================================================
FILE: jesse/controllers/closed_trade_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header, Query, Body
from fastapi.responses import JSONResponse
from jesse.services import auth as authenticator
from jesse.repositories import closed_trade_repository
from jesse.services.transformers import get_closed_trade_for_list, get_closed_trade_details
from jesse.services.web import GetTradesHistoryRequestJson
router = APIRouter(prefix="/closed-trades", tags=["Closed Trades"])
@router.get("/list")
def get_closed_trades(
session_id: str = Query(...),
limit: int = Query(10, ge=1, le=1000),
authorization: Optional[str] = Header(None)
) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
# Query trades for the session with limit
trades = closed_trade_repository.find_by_session_id(session_id, limit=limit)
# Transform trades for list view
trades_list = [get_closed_trade_for_list(trade) for trade in trades]
return JSONResponse({
'data': trades_list
}, status_code=200)
except Exception as e:
return JSONResponse({
'error': str(e)
}, status_code=500)
@router.get("/{trade_id}")
def get_closed_trade_by_id(trade_id: str, authorization: Optional[str] = Header(None)) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
# Fetch trade by ID
trade = closed_trade_repository.find_by_id(trade_id)
if not trade:
return JSONResponse({
'error': 'Trade not found'
}, status_code=404)
# Transform trade with full details including orders
trade_details = get_closed_trade_details(trade)
return JSONResponse({
'data': trade_details
}, status_code=200)
except Exception as e:
return JSONResponse({
'error': str(e)
}, status_code=500)
@router.post("/live-history")
def get_trades_live_history(
request_json: GetTradesHistoryRequestJson = Body(...),
authorization: Optional[str] = Header(None)
) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
# Fetch trades with filters
trades = closed_trade_repository.find_by_filters(
id_search=request_json.id_search,
status_filter=request_json.status_filter,
symbol_filter=request_json.symbol_filter,
date_filter=request_json.date_filter,
exchange_filter=request_json.exchange_filter,
type_filter=request_json.type_filter,
limit=request_json.limit,
offset=request_json.offset
)
# Transform trades for list view
trades_list = [get_closed_trade_for_list(trade) for trade in trades]
return JSONResponse({
'trades': trades_list
}, status_code=200)
except Exception as e:
import traceback
import jesse.helpers as jh
jh.debug(f"Error fetching trades history: {str(e)}")
jh.debug(traceback.format_exc())
return JSONResponse({
'error': str(e)
}, status_code=500)
================================================
FILE: jesse/controllers/config_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header
from fastapi.responses import JSONResponse
from jesse.services import auth as authenticator
from jesse.services.web import ConfigRequestJson
import jesse.helpers as jh
router = APIRouter(prefix="/config", tags=["Configuration"])
@router.post("/get")
def get_config(json_request: ConfigRequestJson, authorization: Optional[str] = Header(None)):
"""
Get the current configuration
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.data_provider import get_config as gc
return JSONResponse({
'data': gc(json_request.current_config, has_live=jh.has_live_trade_plugin())
}, status_code=200)
@router.post("/update")
def update_config(json_request: ConfigRequestJson, authorization: Optional[str] = Header(None)):
"""
Update the configuration
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.data_provider import update_config as uc
uc(json_request.current_config)
return JSONResponse({'message': 'Updated configurations successfully'}, status_code=200)
================================================
FILE: jesse/controllers/exchange_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header
from starlette.responses import JSONResponse
from jesse.modes.import_candles_mode import CandleExchange
from jesse.modes.import_candles_mode.drivers import drivers, driver_names
from jesse.services import auth as authenticator
from jesse.services.redis import sync_redis
from jesse.services.web import ExchangeSupportedSymbolsRequestJson, StoreExchangeApiKeyRequestJson, DeleteExchangeApiKeyRequestJson
from jesse.services.env import is_dev_env
router = APIRouter(prefix="/exchange", tags=["Exchange"])
@router.post('/supported-symbols')
def exchange_supported_symbols(request_json: ExchangeSupportedSymbolsRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# if is_dev_env():
# return JSONResponse({
# 'data': [
# 'BTC-USDT', 'ETH-USDT', 'SOL-USDT', 'DOGE-USDT'
# ]
# }, status_code=200)
return get_exchange_supported_symbols(request_json.exchange)
@router.get('/api-keys')
def get_exchange_api_keys_endpoint(authorization: Optional[str] = Header(None)) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.exchange_api_keys import get_exchange_api_keys
return get_exchange_api_keys()
@router.post('/api-keys/store')
def store_exchange_api_keys_endpoint(json_request: StoreExchangeApiKeyRequestJson,
authorization: Optional[str] = Header(None)) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.exchange_api_keys import store_exchange_api_keys
return store_exchange_api_keys(
json_request.exchange, json_request.name, json_request.api_key, json_request.api_secret,
json_request.additional_fields, json_request.general_notifications_id, json_request.error_notifications_id
)
@router.post('/api-keys/delete')
def delete_exchange_api_keys_endpoint(json_request: DeleteExchangeApiKeyRequestJson,
authorization: Optional[str] = Header(None)) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.exchange_api_keys import delete_exchange_api_keys
return delete_exchange_api_keys(json_request.id)
def get_exchange_supported_symbols(exchange: str) -> JSONResponse:
# first try to get from cache
cache_key = f'exchange-symbols:{exchange}'
cached_result = sync_redis.get(cache_key)
if cached_result is not None:
return JSONResponse({
'data': eval(cached_result)
}, status_code=200)
arr = []
try:
driver: CandleExchange = drivers[exchange]()
except KeyError:
raise ValueError(f'{exchange} is not a supported exchange. Supported exchanges are: {driver_names}')
try:
arr = driver.get_available_symbols()
# cache successful result for 5 minutes
sync_redis.setex(cache_key, 300, str(arr))
except Exception as e:
return JSONResponse({
'error': str(e)
}, status_code=500)
return JSONResponse({
'data': arr
}, status_code=200)
================================================
FILE: jesse/controllers/file_controller.py
================================================
from fastapi import APIRouter, Query, Header, UploadFile, Form, File
from typing import Optional
from jesse.services import auth as authenticator
from jesse.modes import data_provider
from jesse.services.web import ImportApiKeyRequestJson, LoginRequestJson
from jesse.services.env import ENV_VALUES
import jesse.helpers as jh
router = APIRouter(prefix="/download", tags=["Download"])
@router.get("/{mode}/{file_type}/{session_id}")
def download(mode: str, file_type: str, session_id: str, token: str = Query(...)):
"""
Download files such as logs or other generated files.
Log files require session_id because there is one log per each session. Except for the optimize mode.
"""
if not authenticator.is_valid_token(token):
return authenticator.unauthorized_response()
return data_provider.download_file(mode, file_type, session_id)
@router.post("/download-api-keys")
def download_api_keys(
request_json: LoginRequestJson,
authorization: Optional[str] = Header(None)
):
"""
Download exchange API Keys - requires password verification
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# Verify password for this sensitive operation
if request_json.password != ENV_VALUES['PASSWORD']:
return authenticator.unauthorized_response()
jh.validate_cwd()
return data_provider.download_api_keys()
@router.post("/import-api-keys")
async def import_api_keys(
request_json: ImportApiKeyRequestJson,
authorization: Optional[str] = Header(None)
):
"""
Import exchange API keys from CSV text received in the request body.
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
# remove leading/trailing whitespace
csv_content = request_json.content.strip()
# validate CSV content
if not data_provider.validate_csv_content(csv_content):
return {
'success': False,
'error': 'Invalid CSV content or potential security threat detected'
}
# import exchange API keys
result = data_provider.import_api_keys_from_csv(csv_content)
return result
except Exception as e:
return {
'success': False,
'error': str(e)
}
================================================
FILE: jesse/controllers/live_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header, Body
from fastapi.responses import JSONResponse
from jesse.services import auth as authenticator
from jesse.services.multiprocessing import process_manager
from jesse.services.web import (
LiveRequestJson,
LiveCancelRequestJson,
GetLogsRequestJson,
GetOrdersRequestJson,
GetLiveSessionsRequestJson,
UpdateLiveSessionNotesRequestJson,
UpdateLiveSessionStateRequestJson
)
import jesse.helpers as jh
from jesse.repositories import live_session_repository
from jesse.services import transformers
from jesse_live import live_mode
from jesse_live.services.data_provider import get_logs as gl, get_orders as go
from jesse.enums import live_session_statuses, live_session_modes
router = APIRouter(prefix="/live", tags=["Live Trading"])
@router.post("")
def live(request_json: LiveRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Start live trading
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
jh.validate_cwd()
trading_mode = live_session_modes.LIVETRADE if request_json.paper_mode is False else live_session_modes.PAPERTRADE
live_session_repository.store_live_session(
id=request_json.id,
status=live_session_statuses.STARTING,
session_mode=trading_mode,
exchange=request_json.exchange,
state={
'form': {
'debug_mode': request_json.debug_mode,
'paper_mode': request_json.paper_mode,
'exchange': request_json.exchange,
'exchange_api_key_id': request_json.exchange_api_key_id,
'notification_api_key_id': request_json.notification_api_key_id,
'routes': request_json.routes,
'data_routes': request_json.data_routes,
}
},
)
# execute live session
process_manager.add_task(
live_mode.run,
request_json.id,
request_json.debug_mode,
request_json.exchange,
request_json.exchange_api_key_id,
request_json.notification_api_key_id,
request_json.config,
request_json.routes,
request_json.data_routes,
trading_mode,
)
mode = 'live' if request_json.paper_mode is False else 'paper'
return JSONResponse({'message': f"Started {mode} trading..."}, status_code=202)
@router.post("/cancel")
def cancel_live(request_json: LiveCancelRequestJson, authorization: Optional[str] = Header(None)):
"""
Cancel live trading
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
process_manager.cancel_process(request_json.id)
return JSONResponse({'message': f'Live process with ID of {request_json.id} terminated.'}, status_code=200)
@router.post('/logs')
def get_logs(json_request: GetLogsRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Get logs for a live trading session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
arr = gl(json_request.id, json_request.type, json_request.start_time)
return JSONResponse({
'id': json_request.id,
'data': arr
}, status_code=200)
@router.post('/orders')
def get_orders(json_request: GetOrdersRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Get orders for a live trading session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
arr = go(json_request.session_id)
return JSONResponse({
'id': json_request.id,
'data': arr
}, status_code=200)
@router.post("/sessions")
def get_live_sessions(
request_json: GetLiveSessionsRequestJson = Body(default=GetLiveSessionsRequestJson()),
authorization: Optional[str] = Header(None)
):
"""
Get a list of live sessions sorted by most recently updated with pagination
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# Get sessions from the database with pagination and filters
sessions = live_session_repository.get_live_sessions(
limit=request_json.limit,
offset=request_json.offset,
title_search=request_json.title_search,
status_filter=request_json.status_filter,
date_filter=request_json.date_filter,
mode_filter=request_json.mode_filter
)
# Transform the sessions using the transformer
transformed_sessions = [transformers.get_live_session(session) for session in sessions]
return JSONResponse({
'sessions': transformed_sessions,
'count': len(transformed_sessions)
})
@router.post("/sessions/{session_id}")
def get_live_session_by_id(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get a single live session by ID
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# Get the session from the database
session = live_session_repository.get_live_session_by_id(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
# Transform the session using the transformer
transformed_session = transformers.get_live_session(session)
return JSONResponse({
'session': transformed_session
})
@router.post("/sessions/{session_id}/remove")
def remove_live_session(session_id: str, authorization: Optional[str] = Header(None)):
"""
Remove a live session from the database
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = live_session_repository.get_live_session_by_id(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
# Delete the session from the database
result = live_session_repository.delete_live_session(session_id)
if not result:
return JSONResponse({
'error': f'Failed to delete session with ID {session_id}'
}, status_code=500)
return JSONResponse({
'message': 'Live session removed successfully'
})
@router.post("/sessions/{session_id}/notes")
def update_session_notes(
session_id: str,
request_json: UpdateLiveSessionNotesRequestJson,
authorization: Optional[str] = Header(None)
):
"""
Update the notes (title, description, strategy_codes) of a live session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = live_session_repository.get_live_session_by_id(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
live_session_repository.update_live_session_notes(
session_id,
request_json.title,
request_json.description,
request_json.strategy_codes
)
return JSONResponse({
'message': 'Live session notes updated successfully'
})
@router.post("/update-state")
def update_state(request_json: UpdateLiveSessionStateRequestJson, authorization: Optional[str] = Header(None)):
"""
Upsert live session state (creates draft if doesn't exist, updates if exists)
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
live_session_repository.upsert_live_session_state(request_json.id, request_json.state)
return JSONResponse({
'message': 'Live session state updated successfully'
}, status_code=200)
@router.post("/purge-sessions")
def purge_sessions(request_json: dict = Body(...), authorization: Optional[str] = Header(None)):
"""
Purge live sessions older than specified days
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
days_old = request_json.get('days_old', None)
deleted_count = live_session_repository.purge_live_sessions(days_old)
return JSONResponse({
'message': f'Successfully purged {deleted_count} session(s)',
'deleted_count': deleted_count
}, status_code=200)
@router.get("/equity-curve")
def get_equity_curve(
session_id: str,
from_ms: Optional[int] = None,
to_ms: Optional[int] = None,
timeframe: str = 'auto',
max_points: int = 1000,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
"""
Get equity curve for a live session with downsampling
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.repositories import live_equity_repository
try:
if from_ms is None:
session = live_session_repository.get_live_session_by_id(session_id)
if session and getattr(session, 'created_at', None):
from_ms = session.created_at
else:
# fallback: last 24h
from_ms = jh.now(True) - (24 * 60 * 60 * 1000)
result = live_equity_repository.query_equity_curve(
session_id=session_id,
from_ms=from_ms,
to_ms=to_ms,
timeframe=timeframe,
max_points=max_points
)
return JSONResponse(result, status_code=200)
except Exception as e:
return JSONResponse({
'message': f'Error fetching equity curve: {str(e)}'
}, status_code=500)
================================================
FILE: jesse/controllers/lsp_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header
from fastapi.responses import JSONResponse
from jesse.helpers import get_os
from jesse.services import auth as authenticator
from jesse.services.lsp import LSP_DEFAULT_PORT
router = APIRouter(prefix='/lsp-config', tags=['LSP Configuration'])
@router.get("")
def get_lsp_config(authorization: Optional[str] = Header(None))->JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services.env import ENV_VALUES
# Check if formatting is available on the current platform
# Formatting is only available on non-windows platforms
isFormattingAvailable = get_os() != 'windows'
return JSONResponse(
{'ws_port': ENV_VALUES['LSP_PORT'] if 'LSP_PORT' in ENV_VALUES else LSP_DEFAULT_PORT,
'ws_path':'/lsp',
'is_formatting_available': isFormattingAvailable}, status_code=200)
================================================
FILE: jesse/controllers/monte_carlo_controller.py
================================================
from fastapi import APIRouter, Header, Request
from typing import Optional
from fastapi.responses import JSONResponse
import json
from jesse.services import auth as authenticator
from jesse.services.multiprocessing import process_manager
from jesse.services.web import (
MonteCarloRequestJson,
CancelMonteCarloRequestJson,
UpdateMonteCarloSessionStateRequestJson,
TerminateMonteCarloRequestJson,
UpdateMonteCarloSessionNotesRequestJson,
GetMonteCarloSessionsRequestJson
)
from jesse import helpers as jh
from jesse.models.MonteCarloSession import (
get_monte_carlo_sessions,
update_monte_carlo_session_state,
update_monte_carlo_session_status,
delete_monte_carlo_session,
get_monte_carlo_session_by_id,
update_monte_carlo_session_notes,
purge_monte_carlo_sessions,
get_running_monte_carlo_session_id
)
from jesse.services.transformers import get_monte_carlo_session, get_monte_carlo_session_for_load_more
from jesse.modes.monte_carlo_mode import run as run_monte_carlo
router = APIRouter(prefix="/monte-carlo", tags=["Monte Carlo"])
@router.post("")
async def monte_carlo(request: Request, request_json: MonteCarloRequestJson, authorization: Optional[str] = Header(None)):
"""
Start a Monte Carlo simulation
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
jh.validate_cwd()
# Check Python version before imports
if jh.python_version() == (3, 13):
return JSONResponse({
'error': 'Monte Carlo mode is not supported on Python 3.13',
'message': 'The Ray library used for Monte Carlo does not support Python 3.13 yet. Please use Python 3.12 or lower.'
}, status_code=500)
# Validate at least one type is selected
if not request_json.run_trades and not request_json.run_candles:
return JSONResponse({
'error': 'At least one Monte Carlo type must be selected',
'message': 'Please select either Trades, Candles, or both.'
}, status_code=400)
# Validate routes
if not request_json.routes or len(request_json.routes) == 0:
return JSONResponse({
'error': 'At least one route is required',
'message': 'Please add at least one trading route.'
}, status_code=400)
# Generate unique session ID if not provided
session_id = request_json.id or jh.generate_unique_id()
# Check if session already exists
existing_session = get_monte_carlo_session_by_id(session_id)
if existing_session:
return JSONResponse({
'error': f'Monte Carlo session with ID {session_id} already exists',
'message': 'A session with this ID is already running or completed.'
}, status_code=409)
# Check session existence in monte carlo models
from jesse.models.MonteCarloSession import get_monte_carlo_session_by_id as db_get_mc_session_by_id
if db_get_mc_session_by_id(session_id):
return JSONResponse({
'error': f'Monte Carlo session with ID {session_id} already exists (in DB)',
'message': 'A session with this ID already exists in the database.'
}, status_code=409)
process_manager.add_task(
run_monte_carlo,
session_id,
request_json.config,
request_json.exchange,
request_json.routes,
request_json.data_routes,
request_json.start_date,
request_json.finish_date,
request_json.run_trades,
request_json.run_candles,
request_json.num_scenarios,
request_json.fast_mode,
request_json.cpu_cores,
request_json.pipeline_type,
request_json.pipeline_params,
request_json.state,
)
return JSONResponse({
'message': 'Started Monte Carlo simulation...',
'session_id': session_id
}, status_code=202)
@router.post("/cancel")
def cancel_monte_carlo(request_json: CancelMonteCarloRequestJson, authorization: Optional[str] = Header(None)):
"""
Cancel a Monte Carlo simulation
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
process_manager.cancel_process(request_json.id)
return JSONResponse(
{'message': f'Monte Carlo process with ID of {request_json.id} was requested for termination'},
status_code=202
)
@router.post("/terminate")
def terminate_monte_carlo(request_json: TerminateMonteCarloRequestJson, authorization: Optional[str] = Header(None)):
"""
Terminate a Monte Carlo simulation
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# First update the status to 'terminated'
update_monte_carlo_session_status(request_json.id, 'terminated')
# Then request cancellation of the current process
process_manager.cancel_process(request_json.id)
return JSONResponse(
{'message': f'Monte Carlo process with ID of {request_json.id} was terminated'},
status_code=202
)
@router.post("/resume")
async def resume_monte_carlo(request_json: MonteCarloRequestJson, authorization: Optional[str] = Header(None)):
"""
Resume a Monte Carlo simulation
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
jh.validate_cwd()
# Check Python version
if jh.python_version() == (3, 13):
return JSONResponse({
'error': 'Monte Carlo mode is not supported on Python 3.13',
'message': 'The Ray library used for Monte Carlo does not support Python 3.13 yet. Please use Python 3.12 or lower.'
}, status_code=500)
# Get the session from the database
session = get_monte_carlo_session_by_id(request_json.id)
if not session:
return JSONResponse({
'error': f'Session with ID {request_json.id} not found'
}, status_code=404)
# Transform the session using the transformer
transformed_session = get_monte_carlo_session_for_load_more(session)
process_manager.add_task(
run_monte_carlo,
request_json.id,
request_json.config,
request_json.exchange,
request_json.routes,
request_json.data_routes,
request_json.start_date,
request_json.finish_date,
request_json.run_trades,
request_json.run_candles,
request_json.num_scenarios,
request_json.fast_mode,
request_json.cpu_cores,
request_json.pipeline_type,
request_json.pipeline_params,
request_json.state,
)
return JSONResponse({
'session': transformed_session
})
@router.post("/sessions")
def get_monte_carlo_sessions_endpoint(request_json: GetMonteCarloSessionsRequestJson = GetMonteCarloSessionsRequestJson(), authorization: Optional[str] = Header(None)):
"""
Get a list of Monte Carlo sessions sorted by most recently updated with pagination and filters
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# Get sessions from the database with pagination and filters
sessions = get_monte_carlo_sessions(
limit=request_json.limit,
offset=request_json.offset,
title_search=request_json.title_search,
status_filter=request_json.status_filter,
date_filter=request_json.date_filter
)
# Transform the sessions using the transformer
transformed_sessions = [get_monte_carlo_session(session) for session in sessions]
return JSONResponse({
'sessions': transformed_sessions,
'count': len(transformed_sessions)
})
@router.post("/sessions/{session_id}")
def get_monte_carlo_session_by_id_endpoint(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get a single Monte Carlo session by ID
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# Get the session from the database
session = get_monte_carlo_session_by_id(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
# Transform the session using the transformer
transformed_session = get_monte_carlo_session_for_load_more(session)
# Ensure JSON-safe values (replace NaN/Inf with None)
transformed_session = jh.clean_infinite_values(transformed_session)
return JSONResponse({
'session': transformed_session
})
@router.post("/sessions/{session_id}/equity-curves")
def get_monte_carlo_equity_curves(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get equity curve data for a Monte Carlo session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_monte_carlo_session_by_id(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
trades_equity_curves = None
candles_equity_curves = None
# Extract trades equity curves
if session.trades_session and session.trades_session.results:
results = jh.clean_infinite_values(json.loads(session.trades_session.results))
# Extract original equity curve
original_curve = None
if results.get('original') and results['original'].get('equity_curve'):
for curve in results['original']['equity_curve']:
if curve.get('name') == 'Portfolio':
original_curve = curve
break
# Extract all scenario equity curves
scenario_curves = []
if results.get('scenarios'):
for scenario in results['scenarios']:
if scenario.get('equity_curve'):
for curve in scenario['equity_curve']:
if curve.get('name') == 'Portfolio':
scenario_curves.append(curve)
break
trades_equity_curves = {
'original': original_curve,
'scenarios': scenario_curves
}
# Extract candles equity curves
if session.candles_session and session.candles_session.results:
results = jh.clean_infinite_values(json.loads(session.candles_session.results))
# Extract original equity curve
original_curve = None
if results.get('original') and results['original'].get('equity_curve'):
for curve in results['original']['equity_curve']:
if curve.get('name') == 'Portfolio':
original_curve = curve
break
# Extract all scenario equity curves
scenario_curves = []
if results.get('scenarios'):
for scenario in results['scenarios']:
if scenario.get('equity_curve'):
for curve in scenario['equity_curve']:
if curve.get('name') == 'Portfolio':
scenario_curves.append(curve)
break
candles_equity_curves = {
'original': original_curve,
'scenarios': scenario_curves
}
return JSONResponse({
'trades': trades_equity_curves,
'candles': candles_equity_curves
})
@router.post("/update-state")
def update_session_state(
request_json: UpdateMonteCarloSessionStateRequestJson,
authorization: Optional[str] = Header(None)
):
"""
Update the state of a Monte Carlo session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
update_monte_carlo_session_state(request_json.id, request_json.state)
return JSONResponse({
'message': 'Monte Carlo session state updated successfully'
})
@router.post("/sessions/{session_id}/remove")
def remove_monte_carlo_session(session_id: str, authorization: Optional[str] = Header(None)):
"""
Remove a Monte Carlo session from the database
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_monte_carlo_session_by_id(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
# Delete the session from the database
result = delete_monte_carlo_session(session_id)
if not result:
return JSONResponse({
'error': f'Failed to delete session with ID {session_id}'
}, status_code=500)
return JSONResponse({
'message': 'Monte Carlo session removed successfully'
})
@router.post("/sessions/{session_id}/notes")
def update_session_notes(session_id: str, request_json: UpdateMonteCarloSessionNotesRequestJson, authorization: Optional[str] = Header(None)):
"""
Update the notes (title, description, strategy_codes) of a Monte Carlo session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_monte_carlo_session_by_id(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
update_monte_carlo_session_notes(session_id, request_json.title, request_json.description, request_json.strategy_codes)
return JSONResponse({
'message': 'Monte Carlo session notes updated successfully'
})
@router.post("/sessions/{session_id}/strategy-code")
def get_session_strategy_code(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get the strategy code for a Monte Carlo session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_monte_carlo_session_by_id(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
return JSONResponse({
'strategy_code': json.loads(session.strategy_codes) if session.strategy_codes else {}
})
@router.post("/sessions/{session_id}/logs")
def get_session_logs(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get the logs for a Monte Carlo session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes import data_provider
content = data_provider.get_monte_carlo_logs(session_id)
if content is None:
return JSONResponse({
'error': 'Log file not found'
}, status_code=404)
return JSONResponse({
'logs': content
})
@router.post("/purge-sessions")
def purge_sessions(request_json: dict, authorization: Optional[str] = Header(None)):
"""
Purge Monte Carlo sessions older than specified days
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
days_old = request_json.get('days_old', None)
deleted_count = purge_monte_carlo_sessions(days_old)
return JSONResponse({
'message': f'Successfully purged {deleted_count} session(s)',
'deleted_count': deleted_count
}, status_code=200)
@router.get("/running-session")
def get_running_session(authorization: Optional[str] = Header(None)):
"""
Get the running session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
return JSONResponse({
'session_id': get_running_monte_carlo_session_id()
})
================================================
FILE: jesse/controllers/notification_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header
from fastapi.responses import JSONResponse
from jesse.services import auth as authenticator
from jesse.services.web import StoreNotificationApiKeyRequestJson, DeleteNotificationApiKeyRequestJson
router = APIRouter(prefix="/notification", tags=["Notification"])
@router.get("/api-keys")
def get_notification_api_keys(authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Get all notification API keys
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.notification_api_keys import get_notification_api_keys
return get_notification_api_keys()
@router.post("/api-keys/store")
def store_notification_api_keys(
json_request: StoreNotificationApiKeyRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
"""
Store a new notification API key
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.notification_api_keys import store_notification_api_keys
return store_notification_api_keys(
json_request.name, json_request.driver, json_request.fields
)
@router.post("/api-keys/delete")
def delete_notification_api_keys(
json_request: DeleteNotificationApiKeyRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
"""
Delete a notification API key
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.notification_api_keys import delete_notification_api_keys
return delete_notification_api_keys(json_request.id)
================================================
FILE: jesse/controllers/optimization_controller.py
================================================
from fastapi import APIRouter, Header, Query, Body
from typing import Optional, List
from fastapi.responses import JSONResponse, FileResponse
from pydantic import BaseModel
import json
from jesse.services import auth as authenticator
from jesse.services.multiprocessing import process_manager
from jesse.services.web import OptimizationRequestJson, CancelRequestJson, UpdateOptimizationSessionStateRequestJson, UpdateOptimizationSessionStatusRequestJson, TerminateOptimizationRequestJson, UpdateOptimizationSessionNotesRequestJson, GetOptimizationSessionsRequestJson
from jesse import helpers as jh
from jesse.models.OptimizationSession import get_optimization_sessions as get_sessions, update_optimization_session_state, update_optimization_session_status, delete_optimization_session, reset_optimization_session, update_optimization_session_notes, purge_optimization_sessions, get_running_optimization_session_id
from jesse.services.transformers import get_optimization_session, get_optimization_session_for_load_more
from jesse.models.OptimizationSession import get_optimization_session_by_id as get_optimization_session_by_id_from_db
from jesse.modes.optimize_mode import run as run_optimization
router = APIRouter(prefix="/optimization", tags=["Optimization"])
@router.post("")
async def optimization(request_json: OptimizationRequestJson, authorization: Optional[str] = Header(None)):
"""
Start an optimization process
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
jh.validate_cwd()
# Check Python version before imports
if jh.python_version() == (3, 13):
return JSONResponse({
'error': 'Optimization is not supported on Python 3.13',
'message': 'The Ray library used for optimization does not support Python 3.13 yet. Please use Python 3.12 or lower.'
}, status_code=500)
# Validate routes
if not request_json.routes or len(request_json.routes) == 0:
return JSONResponse({
'error': 'At least one route is required',
'message': 'Please add at least one trading route.'
}, status_code=400)
# Generate unique session ID if not provided
session_id = request_json.id or jh.generate_unique_id()
# Check if session already exists
existing_session = get_optimization_session_by_id_from_db(session_id)
if existing_session:
return JSONResponse({
'error': f'Optimization session with ID {session_id} already exists',
'message': 'A session with this ID is already running or completed.'
}, status_code=409)
process_manager.add_task(
run_optimization,
session_id,
request_json.config,
request_json.exchange,
request_json.routes,
request_json.data_routes,
request_json.training_start_date,
request_json.training_finish_date,
request_json.testing_start_date,
request_json.testing_finish_date,
request_json.optimal_total,
request_json.fast_mode,
request_json.cpu_cores,
request_json.state,
)
return JSONResponse({
'message': 'Started optimization...',
'session_id': session_id
}, status_code=202)
@router.post("/rerun")
async def rerun_optimization(request_json: OptimizationRequestJson, authorization: Optional[str] = Header(None)):
"""
Start an optimization process
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
jh.validate_cwd()
# Check Python version before imports
if jh.python_version() == (3, 13):
return JSONResponse({
'error': 'Optimization is not supported on Python 3.13',
'message': 'The Ray library used for optimization does not support Python 3.13 yet. Please use Python 3.12 or lower.'
}, status_code=500)
# Get the session from the database
session = get_optimization_session_by_id_from_db(request_json.id)
if not session:
return JSONResponse({
'error': f'Session with ID {request_json.id} not found'
}, status_code=404)
# reset the session
reset_optimization_session(request_json.id)
process_manager.add_task(
run_optimization,
request_json.id,
request_json.config,
request_json.exchange,
request_json.routes,
request_json.data_routes,
request_json.training_start_date,
request_json.training_finish_date,
request_json.testing_start_date,
request_json.testing_finish_date,
request_json.optimal_total,
request_json.fast_mode,
request_json.cpu_cores,
request_json.state,
)
return JSONResponse({'message': 'Started optimization...'}, status_code=202)
@router.post("/cancel")
def cancel_optimization(request_json: CancelRequestJson, authorization: Optional[str] = Header(None)):
"""
Cancel an optimization process
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
process_manager.cancel_process(request_json.id)
return JSONResponse({'message': f'Optimization process with ID of {request_json.id} was requested for termination'},
status_code=202)
@router.get("/download-log")
def download_optimization_log(token: str = Query(...)):
"""
Download optimization log file
"""
if not authenticator.is_valid_token(token):
return authenticator.unauthorized_response()
from jesse.modes import data_provider
return data_provider.download_file('optimize', 'log')
@router.post("/sessions")
def get_optimization_sessions(request_json: GetOptimizationSessionsRequestJson = Body(default=GetOptimizationSessionsRequestJson()), authorization: Optional[str] = Header(None)):
"""
Get a list of optimization sessions sorted by most recently updated with pagination and filtering
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# Get sessions from the database with pagination and filters
sessions = get_sessions(
limit=request_json.limit,
offset=request_json.offset,
title_search=request_json.title_search,
status_filter=request_json.status_filter,
date_filter=request_json.date_filter
)
# Transform the sessions using the transformer
transformed_sessions = [get_optimization_session(session) for session in sessions]
return JSONResponse({
'sessions': transformed_sessions,
'count': len(transformed_sessions)
})
@router.post("/sessions/{session_id}")
def get_optimization_session_by_id(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get a single optimization session by ID
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# Get the session from the database
session = get_optimization_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
# Transform the session using the transformer
transformed_session = get_optimization_session_for_load_more(session)
return JSONResponse({
'session': transformed_session
})
@router.post("/update-state")
def update_session_state(request_json: UpdateOptimizationSessionStateRequestJson, authorization: Optional[str] = Header(None)):
"""
Update the state of an optimization session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
update_optimization_session_state(request_json.id, request_json.state)
return JSONResponse({
'message': 'Optimization session state updated successfully'
})
@router.post("/terminate")
def terminate_optimization(request_json: TerminateOptimizationRequestJson, authorization: Optional[str] = Header(None)):
"""
Terminate an optimization process
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
# First update the status to 'terminated'
update_optimization_session_status(request_json.id, 'terminated')
# Then request cancellation of the current process
process_manager.cancel_process(request_json.id)
return JSONResponse({'message': f'Optimization process with ID of {request_json.id} was terminated'}, status_code=202)
@router.post("/resume")
async def resume_optimization(request_json: OptimizationRequestJson, authorization: Optional[str] = Header(None)):
"""
Resume an optimization process
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
jh.validate_cwd()
# Check Python version before imports
if jh.python_version() == (3, 13):
return JSONResponse({
'error': 'Optimization is not supported on Python 3.13',
'message': 'The Ray library used for optimization does not support Python 3.13 yet. Please use Python 3.12 or lower.'
}, status_code=500)
# Get the session from the database
session = get_optimization_session_by_id_from_db(request_json.id)
if not session:
return JSONResponse({
'error': f'Session with ID {request_json.id} not found'
}, status_code=404)
# Transform the session using the transformer
transformed_session = get_optimization_session_for_load_more(session)
process_manager.add_task(
run_optimization,
request_json.id,
request_json.config,
request_json.exchange,
request_json.routes,
request_json.data_routes,
request_json.training_start_date,
request_json.training_finish_date,
request_json.testing_start_date,
request_json.testing_finish_date,
request_json.optimal_total,
request_json.fast_mode,
request_json.cpu_cores,
request_json.state,
)
return JSONResponse({
'session': transformed_session
})
@router.post("/sessions/{session_id}/remove")
def remove_optimization_session(session_id: str, authorization: Optional[str] = Header(None)):
"""
Remove an optimization session from the database
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_optimization_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
# Delete the session from the database
result = delete_optimization_session(session_id)
if not result:
return JSONResponse({
'error': f'Failed to delete session with ID {session_id}'
}, status_code=500)
return JSONResponse({
'message': 'Optimization session removed successfully'
})
@router.post("/sessions/{session_id}/notes")
def update_session_notes(session_id: str, request_json: UpdateOptimizationSessionNotesRequestJson, authorization: Optional[str] = Header(None)):
"""
Update the notes (title, description, strategy_codes) of an optimization session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_optimization_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
update_optimization_session_notes(session_id, request_json.title, request_json.description, request_json.strategy_codes)
return JSONResponse({
'message': 'Optimization session notes updated successfully'
})
@router.post("/sessions/{session_id}/get-notes")
def get_session_notes(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get the notes of an optimization session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_optimization_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
return JSONResponse({
'title': session.title,
'description': session.description,
})
@router.post("/sessions/{session_id}/strategy-codes")
def get_session_strategy_codes(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get the strategy codes of an optimization session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session = get_optimization_session_by_id_from_db(session_id)
if not session:
return JSONResponse({
'error': f'Session with ID {session_id} not found'
}, status_code=404)
return JSONResponse({
'strategy_codes': json.loads(session.strategy_codes) if session.strategy_codes else {}
})
@router.post("/sessions/{session_id}/logs")
def get_session_logs(session_id: str, authorization: Optional[str] = Header(None)):
"""
Get the logs for an optimization session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes import data_provider
content = data_provider.get_optimization_logs(session_id)
if content is None:
return JSONResponse({
'error': 'Log file not found'
}, status_code=404)
return JSONResponse({
'logs': content
})
@router.post("/purge-sessions")
def purge_sessions(request_json: dict = Body(...), authorization: Optional[str] = Header(None)):
"""
Purge optimization sessions older than specified days
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
days_old = request_json.get('days_old', None)
deleted_count = purge_optimization_sessions(days_old)
return JSONResponse({
'message': f'Successfully purged {deleted_count} session(s)',
'deleted_count': deleted_count
}, status_code=200)
@router.get("/running-session")
def get_running_session(authorization: Optional[str] = Header(None)):
"""
Get the running session
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
return JSONResponse({
'session_id': get_running_optimization_session_id()
})
================================================
FILE: jesse/controllers/order_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header, Body
from fastapi.responses import JSONResponse
from jesse.services import auth as authenticator
from jesse.repositories import order_repository
from jesse.services.transformers import get_order_details
from jesse.models.Order import Order
from jesse.services.web import GetOrdersHistoryRequestJson
router = APIRouter(prefix="/orders", tags=["Orders"])
@router.get("/{order_id}")
def get_order_by_id(order_id: str, authorization: Optional[str] = Header(None)) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
# Fetch order by ID
order: Order | None = order_repository.find_by_id(order_id)
if not order:
return JSONResponse({
'error': 'Order not found'
}, status_code=404)
# Transform order with details
order_details = get_order_details(order)
return JSONResponse({
'data': order_details
}, status_code=200)
except Exception as e:
import traceback
import jesse.helpers as jh
jh.debug(f"Error fetching order {order_id}: {str(e)}")
jh.debug(traceback.format_exc())
return JSONResponse({
'error': str(e)
}, status_code=500)
@router.post("/live-history")
def get_orders_live_history(
request_json: GetOrdersHistoryRequestJson = Body(...),
authorization: Optional[str] = Header(None)
) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
# Fetch orders with filters
orders = order_repository.find_by_filters(
id_search=request_json.id_search,
status_filter=request_json.status_filter,
symbol_filter=request_json.symbol_filter,
date_filter=request_json.date_filter,
exchange_filter=request_json.exchange_filter,
type_filter=request_json.type_filter,
side_filter=request_json.side_filter,
limit=request_json.limit,
offset=request_json.offset
)
# Transform orders using transformer (handles UUID conversion)
orders_list = [get_order_details(order) for order in orders]
return JSONResponse({
'orders': orders_list
}, status_code=200)
except Exception as e:
import traceback
import jesse.helpers as jh
jh.debug(f"Error fetching orders history: {str(e)}")
jh.debug(traceback.format_exc())
return JSONResponse({
'error': str(e)
}, status_code=500)
================================================
FILE: jesse/controllers/strategy_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header, Query
from fastapi.responses import JSONResponse
import requests
import re
from jesse.services import auth as authenticator
from jesse.services.web import (
NewStrategyRequestJson,
GetStrategyRequestJson,
SaveStrategyRequestJson,
DeleteStrategyRequestJson,
ImportStrategyRequestJson
)
import jesse.helpers as jh
from jesse.info import JESSE_API2_URL
router = APIRouter(prefix="/strategy", tags=["Strategy"])
@router.post("/make")
def make_strategy(json_request: NewStrategyRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Create a new strategy
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import strategy_handler
return strategy_handler.generate(json_request.name)
@router.get("/all")
def get_strategies(authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Get all strategies
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import strategy_handler
return strategy_handler.get_strategies()
@router.post("/get")
def get_strategy(
json_request: GetStrategyRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
"""
Get a specific strategy
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import strategy_handler
return strategy_handler.get_strategy(json_request.name)
@router.post("/save")
def save_strategy(
json_request: SaveStrategyRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
"""
Save a strategy
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import strategy_handler
return strategy_handler.save_strategy(json_request.name, json_request.content)
@router.post("/delete")
def delete_strategy(
json_request: DeleteStrategyRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
"""
Delete a strategy
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import strategy_handler
return strategy_handler.delete_strategy(json_request.name)
@router.get("/index")
async def index_jesse_trade_strategies(
period: str = Query(...),
sort_by: str = Query("Sharpe Ratio"),
submitted_after: Optional[str] = Query(None),
submitted_before: Optional[str] = Query(None),
authorization: Optional[str] = Header(None),
jesse_trade_token: Optional[str] = Header(None, alias="X-Jesse-Trade-Token")
) -> JSONResponse:
"""
Browse strategies from jesse.trade
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
headers = {}
if jesse_trade_token:
headers['Authorization'] = f'Bearer {jesse_trade_token}'
params = {'period': period, 'sort_by': sort_by}
if submitted_after:
params['submitted_after'] = submitted_after
if submitted_before:
params['submitted_before'] = submitted_before
response = requests.get(
f'{JESSE_API2_URL}/strategies',
params=params,
headers=headers,
timeout=10
)
if response.status_code == 200:
return JSONResponse(response.json())
else:
return JSONResponse({
'status': 'error',
'message': f'Failed to fetch strategies: {response.text}'
}, status_code=response.status_code)
except requests.exceptions.RequestException as e:
return JSONResponse({
'status': 'error',
'message': f'Error connecting to jesse.trade: {str(e)}'
}, status_code=500)
@router.get("/periods")
async def get_jesse_trade_periods(
authorization: Optional[str] = Header(None)
) -> JSONResponse:
"""
Get available trading periods from jesse.trade
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
response = requests.get(
f'{JESSE_API2_URL}/strategies/periods',
timeout=10
)
if response.status_code == 200:
return JSONResponse(response.json())
else:
return JSONResponse({
'status': 'error',
'message': f'Failed to fetch periods: {response.text}'
}, status_code=response.status_code)
except requests.exceptions.RequestException as e:
return JSONResponse({
'status': 'error',
'message': f'Error connecting to jesse.trade: {str(e)}'
}, status_code=500)
@router.get("/jesse-trade/{slug}")
async def get_jesse_trade_strategy(
slug: str,
authorization: Optional[str] = Header(None),
jesse_trade_token: Optional[str] = Header(None, alias="X-Jesse-Trade-Token")
) -> JSONResponse:
"""
Get a specific strategy from jesse.trade
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
headers = {}
if jesse_trade_token:
headers['Authorization'] = f'Bearer {jesse_trade_token}'
response = requests.get(
f'{JESSE_API2_URL}/strategies/{slug}',
headers=headers,
timeout=10
)
if response.status_code == 200:
return JSONResponse(response.json())
else:
return JSONResponse({
'status': 'error',
'message': f'Failed to fetch strategy: {response.text}'
}, status_code=response.status_code)
except requests.exceptions.RequestException as e:
return JSONResponse({
'status': 'error',
'message': f'Error connecting to jesse.trade: {str(e)}'
}, status_code=500)
@router.get("/jesse-trade/{slug}/metrics")
async def get_jesse_trade_strategy_metrics(
slug: str,
period: str = Query(...),
symbol: str = Query(...),
timeframe: str = Query(...),
authorization: Optional[str] = Header(None),
jesse_trade_token: Optional[str] = Header(None, alias="X-Jesse-Trade-Token")
) -> JSONResponse:
"""
Get metrics for a specific strategy from jesse.trade
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
headers = {}
if jesse_trade_token:
headers['Authorization'] = f'Bearer {jesse_trade_token}'
response = requests.get(
f'{JESSE_API2_URL}/strategies/{slug}/metrics',
params={'period': period, 'symbol': symbol, 'timeframe': timeframe},
headers=headers,
timeout=10
)
if response.status_code == 200:
return JSONResponse(response.json())
else:
return JSONResponse({
'status': 'error',
'message': f'Failed to fetch strategy metrics: {response.text}'
}, status_code=response.status_code)
except requests.exceptions.RequestException as e:
return JSONResponse({
'status': 'error',
'message': f'Error connecting to jesse.trade: {str(e)}'
}, status_code=500)
@router.post("/import")
async def import_strategy(
json_request: ImportStrategyRequestJson,
authorization: Optional[str] = Header(None),
jesse_trade_token: Optional[str] = Header(None, alias="X-Jesse-Trade-Token")
) -> JSONResponse:
"""
Import a strategy from jesse.trade
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
try:
# Fetch the strategy from jesse.trade
headers = {}
if jesse_trade_token:
headers['Authorization'] = f'Bearer {jesse_trade_token}'
response = requests.get(
f'{JESSE_API2_URL}/strategies/{json_request.slug}',
headers=headers,
timeout=10
)
if response.status_code != 200:
return JSONResponse({
'status': 'error',
'message': f'Failed to fetch strategy: {response.text}'
}, status_code=response.status_code)
strategy_data = response.json()
# Check if code is available
if not strategy_data.get('code'):
return JSONResponse({
'status': 'error',
'message': 'Strategy code not available. You may not have access to this strategy.'
}, status_code=403)
# Extract the Python class name from the code
code = strategy_data.get('code')
class_match = re.search(r'class\s+(\w+)', code)
if not class_match:
return JSONResponse({
'status': 'error',
'message': 'No Python class definition found in strategy code. Cannot import strategy.'
}, status_code=400)
class_name = class_match.group(1)
# Import the strategy
from jesse.services import strategy_handler
return strategy_handler.import_strategy(
name=class_name,
code=code
)
except requests.exceptions.RequestException as e:
return JSONResponse({
'status': 'error',
'message': f'Error connecting to jesse.trade: {str(e)}'
}, status_code=500)
================================================
FILE: jesse/controllers/system_controller.py
================================================
from typing import Optional
from fastapi import APIRouter, Header
from fastapi.responses import JSONResponse
from jesse.services import auth as authenticator
from jesse.services.web import FeedbackRequestJson, ReportExceptionRequestJson, HelpSearchRequestJson
from jesse.services.multiprocessing import process_manager
import jesse.helpers as jh
router = APIRouter(prefix="/system", tags=["System"])
@router.post("/feedback")
def feedback(json_request: FeedbackRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Send feedback to the Jesse team
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import jesse_trade
return jesse_trade.feedback(json_request.description, json_request.email)
@router.post("/report-exception")
def report_exception(json_request: ReportExceptionRequestJson,
authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Report an exception to the Jesse team
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import jesse_trade
return jesse_trade.report_exception(
json_request.description,
json_request.traceback,
json_request.mode,
json_request.attach_logs,
json_request.session_id,
json_request.email,
has_live=jh.has_live_trade_plugin()
)
@router.post("/general-info")
def general_info(authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Get general information about the system
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services.general_info import get_general_info
try:
data = get_general_info(has_live=jh.has_live_trade_plugin())
except Exception as e:
jh.error(str(e))
return JSONResponse({
'error': str(e)
}, status_code=500)
return JSONResponse(
data,
status_code=200
)
@router.post("/active-workers")
def active_workers(authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Get a list of active workers
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
return JSONResponse({
'data': list(process_manager.active_workers)
}, status_code=200)
@router.post("/help-search")
def help_search(json_request: HelpSearchRequestJson, authorization: Optional[str] = Header(None)) -> JSONResponse:
"""
Proxy endpoint for help center search to avoid CORS issues
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
import requests
from jesse.info import JESSE_API_URL
from jesse.services.auth import get_access_token
try:
url = f'{JESSE_API_URL}/help/search?item={json_request.query}'
access_token = get_access_token()
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Accept': 'application/json, text/plain, */*'
}
if access_token:
headers['Authorization'] = f'Bearer {access_token}'
res = requests.get(url, headers=headers, timeout=10)
if res.status_code == 200:
return JSONResponse(res.json(), status_code=200)
else:
return JSONResponse({
'error': f'Search request failed with status {res.status_code}'
}, status_code=res.status_code)
except Exception as e:
return JSONResponse({
'error': str(e)
}, status_code=500)
================================================
FILE: jesse/controllers/tabs_controller.py
================================================
from fastapi import APIRouter, Header
from pydantic import BaseModel
from typing import List, Optional
from jesse.repositories import open_tab_repository
from jesse.services import auth as authenticator
router = APIRouter()
class TabsListRequest(BaseModel):
module: str
class TabsAddRequest(BaseModel):
module: str
id: str
class TabsRemoveRequest(BaseModel):
module: str
id: str
class TabsReorderRequest(BaseModel):
module: str
ids: List[str]
class TabsResponse(BaseModel):
ids: List[str]
@router.post('/tabs/list', response_model=TabsResponse)
async def list_tabs(req: TabsListRequest, authorization: Optional[str] = Header(None)):
"""
Get ordered list of open tab session IDs for a module
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session_ids = open_tab_repository.get_open_tab_session_ids(req.module)
return TabsResponse(ids=session_ids)
@router.post('/tabs/add', response_model=TabsResponse)
async def add_tab(req: TabsAddRequest, authorization: Optional[str] = Header(None)):
"""
Add a new tab (or update if exists). Returns ordered list.
For singleton modules, ensures only 1 tab exists.
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session_ids = open_tab_repository.add_open_tab(req.module, req.id)
return TabsResponse(ids=session_ids)
@router.post('/tabs/remove', response_model=TabsResponse)
async def remove_tab(req: TabsRemoveRequest, authorization: Optional[str] = Header(None)):
"""
Remove a tab and reorder remaining tabs. Returns ordered list.
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session_ids = open_tab_repository.remove_open_tab(req.module, req.id)
return TabsResponse(ids=session_ids)
@router.post('/tabs/reorder', response_model=TabsResponse)
async def reorder_tabs(req: TabsReorderRequest, authorization: Optional[str] = Header(None)):
"""
Reorder tabs to match the provided session_ids list.
For singleton modules, ensures only 1 tab exists.
"""
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
session_ids = open_tab_repository.reorder_open_tabs(req.module, req.ids)
return TabsResponse(ids=session_ids)
================================================
FILE: jesse/controllers/websocket_controller.py
================================================
from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query
from starlette.websockets import WebSocket, WebSocketDisconnect
from jesse.services import auth as authenticator
from jesse.services.ws_manager import ws_manager
import jesse.helpers as jh
router = APIRouter(tags=["WebSocket"])
@router.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket, token: str = Query(...)):
from jesse.services.env import ENV_VALUES
if not authenticator.is_valid_token(token):
return
# Use connection manager to handle this websocket
connection_id = str(id(websocket))
jh.terminal_debug(f"WebSocket {connection_id} connecting")
await ws_manager.connect(websocket)
channel_pattern = f"{ENV_VALUES['APP_PORT']}:channel:*"
# Start Redis listener if not already started
await ws_manager.start_redis_listener(channel_pattern)
try:
# Keep the connection alive and handle pong responses
while True:
message = await websocket.receive_text()
try:
data = jh.json_loads(message)
# Handle pong responses for heartbeat
if data.get('type') == 'pong':
pass
except:
pass
except WebSocketDisconnect:
jh.terminal_debug(f"WebSocket {connection_id} disconnected")
ws_manager.disconnect(websocket)
# Optionally stop Redis listener if no more clients
await ws_manager.stop_redis_listener()
except Exception as e:
jh.terminal_debug(f"WebSocket error: {str(e)}")
ws_manager.disconnect(websocket)
await ws_manager.stop_redis_listener()
================================================
FILE: jesse/enums/__init__.py
================================================
from dataclasses import dataclass
@dataclass
class sides:
BUY = 'buy'
SELL = 'sell'
@dataclass
class trade_types:
LONG = 'long'
SHORT = 'short'
@dataclass
class order_statuses:
ACTIVE = 'ACTIVE'
CANCELED = 'CANCELED'
EXECUTED = 'EXECUTED'
PARTIALLY_FILLED = 'PARTIALLY FILLED'
QUEUED = 'QUEUED'
LIQUIDATED = 'LIQUIDATED'
REJECTED = 'REJECTED'
@dataclass
class timeframes:
MINUTE_1 = '1m'
MINUTE_3 = '3m'
MINUTE_5 = '5m'
MINUTE_15 = '15m'
MINUTE_30 = '30m'
MINUTE_45 = '45m'
HOUR_1 = '1h'
HOUR_2 = '2h'
HOUR_3 = '3h'
HOUR_4 = '4h'
HOUR_6 = '6h'
HOUR_8 = '8h'
HOUR_12 = '12h'
DAY_1 = '1D'
DAY_3 = '3D'
WEEK_1 = '1W'
MONTH_1 = '1M'
@dataclass
class colors:
GREEN = 'green'
YELLOW = 'yellow'
RED = 'red'
MAGENTA = 'magenta'
BLACK = 'black'
@dataclass
class order_types:
MARKET = 'MARKET'
LIMIT = 'LIMIT'
STOP = 'STOP'
FOK = 'FOK'
STOP_LIMIT = 'STOP LIMIT'
@dataclass
class exchanges:
SANDBOX = 'Sandbox'
COINBASE_SPOT = 'Coinbase Spot'
BITFINEX_SPOT = 'Bitfinex Spot'
BINANCE_SPOT = 'Binance Spot'
BINANCE_US_SPOT = 'Binance US Spot'
BINANCE_PERPETUAL_FUTURES = 'Binance Perpetual Futures'
BINANCE_PERPETUAL_FUTURES_TESTNET = 'Binance Perpetual Futures Testnet'
BYBIT_USDT_PERPETUAL = 'Bybit USDT Perpetual'
BYBIT_USDC_PERPETUAL = 'Bybit USDC Perpetual'
BYBIT_USDT_PERPETUAL_TESTNET = 'Bybit USDT Perpetual Testnet'
BYBIT_USDC_PERPETUAL_TESTNET = 'Bybit USDC Perpetual Testnet'
BYBIT_SPOT = 'Bybit Spot'
BYBIT_SPOT_TESTNET = 'Bybit Spot Testnet'
FTX_PERPETUAL_FUTURES = 'FTX Perpetual Futures'
FTX_SPOT = 'FTX Spot'
FTX_US_SPOT = 'FTX US Spot'
BITGET_SPOT = 'Bitget Spot'
BITGET_USDT_PERPETUAL = 'Bitget USDT Perpetual'
BITGET_USDT_PERPETUAL_TESTNET = 'Bitget USDT Perpetual Testnet'
DYDX_PERPETUAL = "Dydx Perpetual"
DYDX_PERPETUAL_TESTNET = "Dydx Perpetual Testnet"
APEX_OMNI_PERPETUAL_TESTNET = 'Apex Omni Perpetual Testnet'
APEX_OMNI_PERPETUAL = 'Apex Omni Perpetual'
GATE_USDT_PERPETUAL = 'Gate USDT Perpetual'
GATE_SPOT = 'Gate Spot'
HYPERLIQUID_PERPETUAL = 'Hyperliquid Perpetual'
HYPERLIQUID_PERPETUAL_TESTNET = 'Hyperliquid Perpetual Testnet'
@dataclass
class migration_actions:
ADD = 'add'
DROP = 'drop'
RENAME = 'rename'
MODIFY_TYPE = 'modify_type'
ALLOW_NULL = 'allow_null'
DENY_NULL = 'deny_null'
ADD_INDEX = 'add_index'
DROP_INDEX = 'drop_index'
@dataclass
class order_submitted_via:
STOP_LOSS = 'stop-loss'
TAKE_PROFIT = 'take-profit'
@dataclass
class live_session_statuses:
DRAFT = 'draft'
STARTING = 'starting'
RUNNING = 'running'
STOPPED = 'stopped'
TERMINATED = 'terminated'
@dataclass
class live_session_modes:
LIVETRADE = 'livetrade'
PAPERTRADE = 'papertrade'
================================================
FILE: jesse/exceptions/__init__.py
================================================
class EmptyPosition(Exception):
pass
class OpenPositionError(Exception):
pass
class OrderNotAllowed(Exception):
pass
class ConflictingRules(Exception):
pass
class InvalidStrategy(Exception):
pass
class CandleNotFoundInDatabase(Exception):
pass
class CandleNotFoundInExchange(Exception):
pass
class SymbolNotFound(Exception):
pass
class RouteNotFound(Exception):
def __init__(self, symbol, timeframe):
message = f"Data route is required but missing: symbol='{symbol}', timeframe='{timeframe}'"
super().__init__(message)
class InvalidRoutes(Exception):
pass
class ExchangeInMaintenance(Exception):
pass
class ExchangeNotResponding(Exception):
pass
class ExchangeRejectedOrder(Exception):
pass
class ExchangeRejectedLeverageNumber(Exception):
pass
class ExchangeOrderNotFound(Exception):
pass
class InvalidShape(Exception):
pass
class InvalidConfig(Exception):
pass
class InvalidTimeframe(Exception):
pass
class InvalidSymbol(Exception):
pass
class NegativeBalance(Exception):
pass
class InsufficientMargin(Exception):
pass
class InsufficientBalance(Exception):
pass
class Termination(Exception):
pass
class InvalidExchangeApiKeys(Exception):
pass
class ExchangeError(Exception):
pass
class NotSupportedError(Exception):
pass
class CandlesNotFound(Exception):
pass
class InvalidDateRange(Exception):
pass
================================================
FILE: jesse/exchanges/__init__.py
================================================
from .sandbox.Sandbox import Sandbox
================================================
FILE: jesse/exchanges/exchange.py
================================================
from abc import ABC, abstractmethod
from typing import Union
from jesse.models.Order import Order
class Exchange(ABC):
"""
The interface that every Exchange driver has to implement
"""
@abstractmethod
def market_order(self, symbol: str, qty: float, current_price: float, side: str, reduce_only: bool) -> Order:
pass
@abstractmethod
def limit_order(self, symbol: str, qty: float, price: float, side: str, reduce_only: bool) -> Order:
pass
@abstractmethod
def stop_order(self, symbol: str, qty: float, price: float, side: str, reduce_only: bool) -> Order:
pass
@abstractmethod
def cancel_all_orders(self, symbol: str) -> None:
pass
@abstractmethod
def cancel_order(self, symbol: str, order_id: str) -> None:
pass
@abstractmethod
def _fetch_precisions(self) -> None:
pass
================================================
FILE: jesse/exchanges/sandbox/Sandbox.py
================================================
from jesse.models.Order import Order
import jesse.helpers as jh
from typing import List
from jesse.enums import order_types
from jesse.exchanges.exchange import Exchange
from jesse.store import store
from jesse.services import order_service
class Sandbox(Exchange):
def __init__(self, name='Sandbox'):
super().__init__()
self.name = name
def market_order(self, symbol: str, qty: float, current_price: float, side: str, reduce_only: bool) -> Order:
return order_service.create_order({
'id': jh.generate_unique_id(),
'symbol': symbol,
'exchange': self.name,
'side': side,
'type': order_types.MARKET,
'reduce_only': reduce_only,
'qty': jh.prepare_qty(qty, side),
'price': current_price,
})
def limit_order(self, symbol: str, qty: float, price: float, side: str, reduce_only: bool) -> Order:
return order_service.create_order({
'id': jh.generate_unique_id(),
'symbol': symbol,
'exchange': self.name,
'side': side,
'type': order_types.LIMIT,
'reduce_only': reduce_only,
'qty': jh.prepare_qty(qty, side),
'price': price,
})
def stop_order(self, symbol: str, qty: float, price: float, side: str, reduce_only: bool) -> Order:
return order_service.create_order({
'id': jh.generate_unique_id(),
'symbol': symbol,
'exchange': self.name,
'side': side,
'type': order_types.STOP,
'reduce_only': reduce_only,
'qty': jh.prepare_qty(qty, side),
'price': price,
})
def cancel_all_orders(self, symbol: str) -> List[Order]:
orders: list[Order] = store.orders.get_active_orders(self.name, symbol)
canceled_orders: List[Order] = []
for o in orders:
order_service.cancel_order(o)
canceled_orders.append(o)
if not jh.is_unit_testing():
store.orders.storage[f'{self.name}-{symbol}'].clear()
return canceled_orders
def cancel_order(self, symbol: str, order_id: str) -> None:
order = store.orders.get_order_by_id(self.name, symbol, order_id)
order_service.cancel_order(order)
def _fetch_precisions(self) -> None:
pass
================================================
FILE: jesse/exchanges/sandbox/__init__.py
================================================
from .Sandbox import Sandbox
================================================
FILE: jesse/factories/__init__.py
================================================
from .candle_factory import fake_candle
from .candle_factory import range_candles
from .candle_factory import candles_from_close_prices
from .order_factory import fake_order
================================================
FILE: jesse/factories/candle_factory.py
================================================
from random import randint
from typing import Union
import numpy as np
# 2021-01-01T00:00:00+00:00
first_timestamp = 1609459080000
open_price = randint(40, 100)
close_price = randint(open_price, 110) if randint(0, 1) else randint(
30, open_price)
max_price = max(open_price, close_price)
high_price = max_price if randint(0, 1) else randint(max_price, max_price + 10)
min_price = min(open_price, close_price)
low_price = min_price if randint(0, 1) else randint(min_price, min_price + 10)
def range_candles(count: int) -> np.ndarray:
"""
Generates a range of candles with random values.
"""
fake_candle(reset=True)
arr = np.zeros((count, 6))
for i in range(count):
arr[i] = fake_candle()
return arr
def candles_from_close_prices(prices: Union[list, range]) -> np.ndarray:
"""
Generates a range of candles from a list of close prices.
The first candle has the timestamp of "2021-01-01T00:00:00+00:00"
"""
fake_candle(reset=True)
global first_timestamp
arr = []
prev_p = np.nan
for p in prices:
# first prev_p
if np.isnan(prev_p):
prev_p = p - 0.5
first_timestamp += 60000
open_p = prev_p
close_p = p
high_p = max(open_p, close_p)
low_p = min(open_p, close_p)
vol = randint(0, 200)
arr.append([first_timestamp, open_p, close_p, high_p, low_p, vol])
# save prev_p for next candle
prev_p = p
return np.array(arr)
def fake_candle(attributes: dict = None, reset: bool = False) -> np.ndarray:
global first_timestamp
global open_price
global close_price
global max_price
global high_price
global min_price
global low_price
if reset:
first_timestamp = 1609459080000
open_price = randint(40, 100)
close_price = randint(open_price, 110)
high_price = max(open_price, close_price)
low_price = min(open_price, close_price)
if attributes is None:
attributes = {}
first_timestamp += 60000
open_price = close_price
close_price += randint(1, 8)
high_price = max(open_price, close_price)
low_price = min(open_price - 1, close_price)
volume = randint(1, 100)
timestamp = first_timestamp
return np.array([
attributes.get('timestamp', timestamp),
attributes.get('open', open_price),
attributes.get('close', close_price),
attributes.get('high', high_price),
attributes.get('low', low_price),
attributes.get('volume', volume)
], dtype=np.float64)
================================================
FILE: jesse/factories/order_factory.py
================================================
from random import randint
import jesse.helpers as jh
from jesse.enums import exchanges, sides, order_types, order_statuses
from jesse.models.Order import Order
from jesse.services import order_service
first_timestamp = 1552309186171
def fake_order(attributes: dict = None) -> Order:
"""
:param attributes:
:return:
"""
if attributes is None:
attributes = {}
global first_timestamp
first_timestamp += 60000
exchange = exchanges.SANDBOX
symbol = 'BTC-USD'
side = sides.BUY
order_type = order_types.LIMIT
price = randint(40, 100)
qty = randint(1, 10)
status = order_statuses.ACTIVE
created_at = first_timestamp
return Order({
"id": jh.generate_unique_id(),
'symbol': attributes.get('symbol', symbol),
'exchange': attributes.get('exchange', exchange),
'side': attributes.get('side', side),
'type': attributes.get('type', order_type),
'qty': attributes.get('qty', qty),
'price': attributes.get('price', price),
'status': attributes.get('status', status),
'created_at': attributes.get('created_at', created_at),
})
================================================
FILE: jesse/helpers.py
================================================
import hashlib
from datetime import datetime
import math
import os
import gzip
import json
from functools import lru_cache
import random
import string
import sys
import uuid
from typing import List, Tuple, Union, Any, Optional
from pprint import pprint
import arrow
import click
import numpy as np
import base64
from jesse.constants import CANDLE_SOURCE_MAPPING
from jesse.constants import TIMEFRAME_PRIORITY
from jesse.constants import SUPPORTED_COLORS
from jesse.enums import timeframes
CACHED_CONFIG = dict()
def app_currency() -> str:
from jesse.info import exchange_info
from jesse.routes import router
if router.routes[0].exchange in exchange_info and 'settlement_currency' in exchange_info[router.routes[0].exchange]:
return exchange_info[router.routes[0].exchange]['settlement_currency']
else:
return quote_asset(router.routes[0].symbol)
@lru_cache
def app_mode() -> str:
from jesse.config import config
return config['app']['trading_mode']
def arrow_to_timestamp(arrow_time: arrow.arrow.Arrow) -> int:
return arrow_time.int_timestamp * 1000
def base_asset(symbol: str) -> str:
return symbol.split('-')[0]
def binary_search(arr: list, item) -> int:
"""
performs a simple binary search on a sorted list
:param arr: list
:param item:
:return: int
"""
from bisect import bisect_left
i = bisect_left(arr, item)
if i != len(arr) and arr[i] == item:
return i
else:
return -1
def class_iter(Class):
return (value for variable, value in vars(Class).items() if
not callable(getattr(Class, variable)) and not variable.startswith("__"))
def clean_orderbook_list(arr) -> List[List[float]]:
return [[float(i[0]), float(i[1])] for i in arr]
def color(msg_text: str, msg_color: str) -> str:
if not msg_text:
return ''
if msg_color in SUPPORTED_COLORS:
return click.style(msg_text, fg=msg_color)
if msg_color == 'gray':
return click.style(msg_text, fg='white')
raise ValueError('unsupported color')
def convert_number(old_max: float, old_min: float, new_max: float, new_min: float, old_value: float) -> float:
"""
convert a number from one range (ex 40-119) to another
range (ex 0-30) while keeping the ratio.
"""
# validation
if old_value > old_max or old_value < old_min:
raise ValueError(f'old_value:{old_value} must be within the range. {old_min}-{old_max}')
old_range = (old_max - old_min)
new_range = (new_max - new_min)
return (((old_value - old_min) * new_range) / old_range) + new_min
def dashless_symbol(symbol: str) -> str:
return symbol.replace("-", "")
def dashy_symbol(symbol: str) -> str:
if '-' in symbol:
return symbol
from jesse.config import config
for s in config['app']['considering_symbols']:
if dashless_symbol(s) == symbol:
return s
suffixes = [
'UST', 'FDUSD', 'TUSD', 'EUT', 'EUR', 'GBP', 'JPY', 'MIM', 'TRY'
]
for suffix in suffixes:
if symbol.endswith(suffix):
return f"{symbol[:-len(suffix)]}-{suffix}"
if "USD" in symbol[-4:]: # Only look at the last 4 letters
idx = symbol.rfind("USD")
return f"{symbol[:idx]}-{symbol[idx:]}"
return f"{symbol[:3]}-{symbol[3:]}"
def underline_to_dashy_symbol(symbol: str) -> str:
return symbol.replace('_', '-')
def dashy_to_underline(symbol: str) -> str:
return symbol.replace('-', '_')
def get_base_asset(symbol: str) -> str:
return symbol.split('-')[0]
def get_quote_asset(symbol: str) -> str:
return symbol.split('-')[1]
def date_diff_in_days(date1: arrow.arrow.Arrow, date2: arrow.arrow.Arrow) -> int:
if type(date1) is not arrow.arrow.Arrow or type(
date2) is not arrow.arrow.Arrow:
raise TypeError('dates must be Arrow instances')
dif = date2 - date1
return abs(dif.days)
def date_to_timestamp(date: str) -> int:
"""
converts date string into timestamp. "2015-08-01" => 1438387200000
:param date: str
:return: int
"""
return arrow_to_timestamp(arrow.get(date, 'YYYY-MM-DD'))
def dna_to_hp(strategy_hp, dna: str):
# First, try to decode as Base64
try:
import base64
import json
# Try to decode the DNA as base64
decoded_bytes = base64.b64decode(dna)
# Try to parse as JSON
decoded_json = json.loads(decoded_bytes.decode('utf-8'))
# If successful, the decoded JSON should be the hyperparameters
return decoded_json
except (ValueError, base64.binascii.Error, json.JSONDecodeError):
# If decoding fails, use the legacy method
hp = {}
for gene, h in zip(dna, strategy_hp):
if h['type'] is int:
decoded_gene = int(
round(
convert_number(119, 40, h['max'], h['min'], ord(gene))
)
)
elif h['type'] is float:
decoded_gene = convert_number(119, 40, h['max'], h['min'], ord(gene))
else:
raise TypeError('Only int and float types are implemented')
hp[h['name']] = decoded_gene
return hp
def dump_exception() -> None:
"""
a useful debugging helper
"""
import traceback
print(traceback.format_exc())
terminate_app()
def estimate_average_price(order_qty: float, order_price: float, current_qty: float,
current_entry_price: float) -> float:
"""Estimates the new entry price for the position.
This is used after having a new order and updating the currently holding position.
Arguments:
order_qty {float} -- qty of the new order
order_price {float} -- price of the new order
current_qty {float} -- current(pre-calculation) qty
current_entry_price {float} -- current(pre-calculation) entry price
Returns:
float -- the new/averaged entry price
"""
return (abs(order_qty) * order_price + abs(current_qty) *
current_entry_price) / (abs(order_qty) + abs(current_qty))
def estimate_PNL(qty: float, entry_price: float, exit_price: float, trade_type: str, trading_fee: float = 0) -> float:
qty = abs(qty)
profit = qty * (exit_price - entry_price)
if trade_type == 'short':
profit *= -1
fee = trading_fee * qty * (entry_price + exit_price)
return profit - fee
def estimate_PNL_percentage(qty: float, entry_price: float, exit_price: float, trade_type: str) -> float:
qty = abs(qty)
profit = qty * (exit_price - entry_price)
if trade_type == 'short':
profit *= -1
return (profit / (qty * entry_price)) * 100
def file_exists(path: str) -> bool:
return os.path.isfile(path)
def clear_file(path: str) -> None:
with open(path, 'w') as f:
f.write('')
def make_directory(path: str) -> None:
if not os.path.exists(path):
os.makedirs(path)
def floor_with_precision(num: float, precision: int = 0) -> float:
temp = 10 ** precision
return math.floor(num * temp) / temp
def format_currency(num: float) -> str:
return f'{num:,}'
def format_price(price: float) -> str:
"""
Formats the price for logging.
- If abs(price) is >= 1, it will be truncated to 2 decimal places.
- If abs(price) is < 1, it will be truncated to 5 significant digits.
"""
if price is None:
return ""
if price == 0:
return "0.00"
# to handle scientific notation
price_str = f'{price:.20f}'
if abs(price) >= 1:
if '.' not in price_str:
return f"{price:.2f}"
integer_part, decimal_part = price_str.split('.')
return f"{integer_part}.{decimal_part[:2]}"
# For numbers between -1 and 1
# find sign
sign = ''
if price < 0:
sign = '-'
price_str = f'{abs(price):.20f}'
decimal_part = price_str.split('.')[1]
first_non_zero_index = -1
for i, digit in enumerate(decimal_part):
if digit != '0':
first_non_zero_index = i
break
# This case should ideally not be hit if price is not 0, but as a safeguard:
if first_non_zero_index == -1:
return "0.00"
# Use 5 significant digits for all values below 1
end_index = first_non_zero_index + 5
formatted_decimal = decimal_part[:end_index]
return f"{sign}0.{formatted_decimal}"
def generate_unique_id() -> str:
return str(uuid.uuid4())
def generate_short_unique_id() -> str:
return str(uuid.uuid4())[:22]
def get_arrow(timestamp: int) -> arrow.arrow.Arrow:
return timestamp_to_arrow(timestamp)
def get_candle_source(candles: np.ndarray, source_type: str = "close") -> np.ndarray:
"""
Returns the candles corresponding to the selected type.
"""
try:
return CANDLE_SOURCE_MAPPING[source_type](candles)
except KeyError:
raise ValueError(f"Source type '{source_type}' not recognised")
def get_config(keys: str, default: Any = None) -> Any:
"""
Gets keys as a single string separated with "." and returns value.
Also accepts a default value so that the app would work even if
the required config value is missing from config.py file.
Example: get_config('env.logging.order_submission', True)
:param keys: str
:param default: None
:return:
"""
if not str:
raise ValueError('keys string cannot be empty')
if is_unit_testing() or keys not in CACHED_CONFIG:
if os.environ.get(keys.upper().replace(".", "_").replace(" ", "_")) is not None:
CACHED_CONFIG[keys] = os.environ.get(keys.upper().replace(".", "_").replace(" ", "_"))
else:
from functools import reduce
from jesse.config import config
CACHED_CONFIG[keys] = reduce(lambda d, k: d.get(k, default) if isinstance(d, dict) else default,
keys.split("."), config)
return CACHED_CONFIG[keys]
def get_store():
from jesse.store import store
return store
def get_strategy_class(strategy_name: str):
from pydoc import locate
import os
import re
if not is_unit_testing():
strategy_class = locate(f'strategies.{strategy_name}.{strategy_name}')
if strategy_class is None:
# Try to find any class that inherits from Strategy in the module
module = locate(f'strategies.{strategy_name}')
if module:
strategy_file = os.path.join('strategies', strategy_name, '__init__.py')
if os.path.exists(strategy_file):
with open(strategy_file, 'r') as f:
content = f.read()
# Find the class definition
class_pattern = r'class\s+(\w+)'
match = re.search(class_pattern, content)
if match:
old_class_name = match.group(1)
if old_class_name != strategy_name:
# Replace the class name in the file
new_content = re.sub(f'class {old_class_name}', f'class {strategy_name}', content)
with open(strategy_file, 'w') as f:
f.write(new_content)
# Reload the module to get the updated class
import importlib
module_path = f'strategies.{strategy_name}'
if module_path in sys.modules:
del sys.modules[module_path]
strategy_class = locate(f'strategies.{strategy_name}.{strategy_name}')
return strategy_class
for attr_name in dir(module):
attr = getattr(module, attr_name)
if isinstance(attr, type) and attr.__module__ == f'strategies.{strategy_name}':
# Create a new class with the correct name as fallback
strategy_class = type(strategy_name, (attr,), {})
break
return strategy_class
path = sys.path[0]
# live plugin
if path.endswith('jesse-live'):
strategy_dir = f'tests.strategies.{strategy_name}.{strategy_name}'
# main framework
else:
strategy_dir = f'jesse.strategies.{strategy_name}.{strategy_name}'
return locate(strategy_dir)
def insecure_hash(msg: str) -> str:
return hashlib.md5(msg.encode()).hexdigest()
def insert_list(index: int, item, arr: list) -> list:
"""
helper to insert an item in a Python List without removing the item
"""
if index == -1:
return arr + [item]
return arr[:index] + [item] + arr[index:]
def is_backtesting() -> bool:
from jesse.config import config
return config['app']['trading_mode'] == 'backtest'
def is_debuggable(debug_item) -> bool:
from jesse.config import config
try:
return is_debugging() and config['env']['logging'][debug_item]
except KeyError:
return True
def is_debugging() -> bool:
from jesse.config import config
return config['app']['debug_mode']
def is_importing_candles() -> bool:
from jesse.config import config
return config['app']['trading_mode'] == 'candles'
@lru_cache
def is_live() -> bool:
return is_livetrading() or is_paper_trading()
@lru_cache
def is_livetrading() -> bool:
from jesse.config import config
return config['app']['trading_mode'] == 'livetrade'
@lru_cache
def is_optimizing() -> bool:
from jesse.config import config
return config['app']['trading_mode'] == 'optimize'
@lru_cache
def is_paper_trading() -> bool:
from jesse.config import config
return config['app']['trading_mode'] == 'papertrade'
def is_unit_testing() -> bool:
"""Returns True if the code is running by running pytest or PyCharm's test runner, False otherwise."""
# Check if the PYTEST_CURRENT_TEST environment variable is set.
if os.environ.get("PYTEST_CURRENT_TEST"):
return True
# Check if the code is being executed from the pytest command-line tool.
script_name = os.path.basename(sys.argv[0])
if script_name in ["pytest", "py.test"]:
return True
# Otherwise, the code is not running by running pytest or PyCharm's test runner.
return False
def is_valid_uuid(uuid_to_test: str, version: int = 4) -> bool:
try:
uuid_obj = uuid.UUID(uuid_to_test, version=version)
except ValueError:
return False
return str(uuid_obj) == uuid_to_test
def key(exchange: str, symbol: str, timeframe: str = None):
if timeframe is None:
return f'{exchange}-{symbol}'
return f'{exchange}-{symbol}-{timeframe}'
def max_timeframe(timeframes_list: list) -> str:
times = set(timeframes_list)
for tf in TIMEFRAME_PRIORITY:
if tf in times:
return tf
return timeframes.MINUTE_1
def normalize(x: float, x_min: float, x_max: float) -> float:
"""
Rescaling data to have values between 0 and 1
"""
return (x - x_min) / (x_max - x_min)
def now(force_fresh=False) -> int:
"""
Always returns the current time in milliseconds but rounds time in matter of seconds
"""
return int(now_to_timestamp(force_fresh))
def now_to_timestamp(force_fresh=False) -> int:
if not force_fresh and (not (is_live() or is_importing_candles())):
from jesse.store import store
return store.app.time
return arrow.utcnow().int_timestamp * 1000
# for use with peewee
def now_to_datetime():
return arrow.utcnow().datetime
def current_1m_candle_timestamp():
return arrow.utcnow().floor('minute').int_timestamp * 1000
def np_ffill(arr: np.ndarray, axis: int = 0) -> np.ndarray:
idx_shape = tuple([slice(None)] + [np.newaxis] * (len(arr.shape) - axis - 1))
idx = np.where(~np.isnan(arr), np.arange(arr.shape[axis])[idx_shape], 0)
np.maximum.accumulate(idx, axis=axis, out=idx)
slc = [
np.arange(k)[
tuple(
slice(None) if dim == i else np.newaxis
for dim in range(len(arr.shape))
)
]
for i, k in enumerate(arr.shape)
]
slc[axis] = idx
return arr[tuple(slc)]
def np_shift(arr: np.ndarray, num: int, fill_value=0) -> np.ndarray:
result = np.empty_like(arr)
if num > 0:
result[:num] = fill_value
result[num:] = arr[:-num]
elif num < 0:
result[num:] = fill_value
result[:num] = arr[-num:]
else:
result[:] = arr
return result
@lru_cache
def opposite_side(s: str) -> str:
from jesse.enums import sides
if s == sides.BUY:
return sides.SELL
elif s == sides.SELL:
return sides.BUY
else:
raise ValueError(f'{s} is not a valid input for side')
@lru_cache
def opposite_type(t: str) -> str:
from jesse.enums import trade_types
if t == trade_types.LONG:
return trade_types.SHORT
if t == trade_types.SHORT:
return trade_types.LONG
raise ValueError('unsupported type')
def orderbook_insertion_index_search(arr, target: int, ascending: bool = True) -> Tuple[bool, int]:
target = target[0]
lower = 0
upper = len(arr)
while lower < upper:
x = lower + (upper - lower) // 2
val = arr[x][0]
if ascending:
if target == val:
return True, x
elif target > val:
if lower == x:
return False, lower + 1
lower = x
elif target < val:
if lower == x:
return False, lower
upper = x
elif target == val:
return True, x
elif target < val:
if lower == x:
return False, lower + 1
lower = x
elif target > val:
if lower == x:
return False, lower
upper = x
def orderbook_trim_price(p: float, ascending: bool, unit: float) -> float:
if ascending:
trimmed = np.ceil(p / unit) * unit
if math.log10(unit) < 0:
trimmed = round(trimmed, abs(int(math.log10(unit))))
return p if trimmed == p + unit else trimmed
trimmed = np.ceil(p / unit) * unit - unit
if math.log10(unit) < 0:
trimmed = round(trimmed, abs(int(math.log10(unit))))
return p if trimmed == p - unit else trimmed
def prepare_qty(qty: float, side: str) -> float:
if side.lower() in ('sell', 'short'):
return -abs(qty)
elif side.lower() in ('buy', 'long'):
return abs(qty)
elif side.lower() == 'close':
return 0.0
else:
raise ValueError(f'{side} is not a valid input')
def python_version() -> tuple:
return sys.version_info[:2]
def quote_asset(symbol: str) -> str:
try:
return symbol.split('-')[1]
except IndexError:
from jesse.exceptions import InvalidRoutes
raise InvalidRoutes(f"The symbol format is incorrect. Correct example: 'BTC-USDT'. Yours is '{symbol}'")
def random_str(num_characters: int = 8) -> str:
return ''.join(random.choice(string.ascii_letters) for _ in range(num_characters))
def readable_duration(seconds: int, granularity: int = 2) -> str:
intervals = (
('weeks', 604800), # 60 * 60 * 24 * 7
('days', 86400), # 60 * 60 * 24
('hours', 3600), # 60 * 60
('minutes', 60),
('seconds', 1),
)
result = []
seconds = int(seconds)
for name, count in intervals:
value = seconds // count
if value:
seconds -= value * count
if value == 1:
name = name.rstrip('s')
result.append(f"{value} {name}")
return ', '.join(result[:granularity])
def relative_to_absolute(path: str) -> str:
return os.path.abspath(path)
def round_or_none(x: Union[float, None], digits: int = 0) -> Optional[float]:
"""
Rounds a number to a certain number of digits or returns None if the number is None
"""
if x is None:
return None
return round(x, digits)
def round_price_for_live_mode(price, precision: int) -> Union[float, np.ndarray]:
"""
Rounds price(s) based on exchange requirements
:param price: float
:param precision: int
:return: float | nd.array
"""
return np.round(price, precision)
def round_qty_for_live_mode(roundable_qty: float, precision: int) -> Union[float, np.ndarray]:
"""
Rounds qty(s) based on exchange requirements
:param roundable_qty: float | nd.array
:param precision: int
:return: float | nd.array
"""
input_type = type(roundable_qty)
# if roundable_qty is a scalar, convert to nd.array
if not isinstance(roundable_qty, np.ndarray):
roundable_qty = np.array([roundable_qty])
# for qty rounding down is important to prevent InsufficenMargin
rounded = round_decimals_down(roundable_qty, precision)
for index, q in enumerate(rounded):
# if the rounded value is 0, make it the minimum possible value
if q == 0.0:
# if the precision is bigger or equal 0, (for numbers like 2, 0.2, 0.02)
if precision >= 0:
rounded[index] = 1 / 10 ** precision
else: # for numbers like 20, 200, 2000
raise ValueError('qty is too small')
if input_type in [float, np.float64]:
return float(rounded[0])
return rounded
def round_decimals_down(number: Union[np.ndarray, float], decimals: int = 2) -> float:
"""
Returns a value rounded down to a specific number of decimal places.
"""
if not isinstance(decimals, int):
raise TypeError("decimal places must be an integer")
elif decimals == 0:
return np.floor(number)
elif decimals > 0:
factor = 10 ** decimals
return np.floor(number * factor) / factor
elif decimals < 0:
# for example, for decimals = -2, we want to round down to the nearest 100 if the number is 1234, we want to return 1200:
factor = 10 ** (decimals * -1)
return np.floor(number / factor) * factor
def is_almost_equal(a: float, b: float, tolerance: float = 1e-8) -> bool:
"""
Compares two floating point values with a small tolerance to account for floating point precision issues.
:param a: First float value to compare
:param b: Second float value to compare
:param tolerance: The tolerance level for the comparison (default: 1e-8)
:return: bool - True if the difference between a and b is less than or equal to the tolerance
"""
# Check if both are None, which means they're equal
if a is None and b is None:
return True
# Check if only one is None, which means they're not equal
if a is None or b is None:
return False
# Check for exact equality first (optimizes for common case)
if a == b:
return True
# For values very close to zero, use absolute tolerance
if abs(a) < tolerance and abs(b) < tolerance:
return abs(a - b) <= tolerance
# For non-zero values, use relative tolerance
return abs((a - b) / max(abs(a), abs(b))) <= tolerance
def same_length(bigger: np.ndarray, shorter: np.ndarray) -> np.ndarray:
return np.concatenate((np.full((bigger.shape[0] - shorter.shape[0]), np.nan), shorter))
def secure_hash(msg: str) -> str:
return hashlib.sha256(msg.encode()).hexdigest()
def should_execute_silently() -> bool:
return is_optimizing() or is_unit_testing()
@lru_cache
def side_to_type(s: str) -> str:
from jesse.enums import trade_types, sides
# make sure string is lowercase
s = s.lower()
if s == sides.BUY:
return trade_types.LONG
if s == sides.SELL:
return trade_types.SHORT
raise ValueError
def string_after_character(s: str, character: str) -> str:
try:
return s.split(character, 1)[1]
except IndexError:
return None
def slice_candles(candles: np.ndarray, sequential: bool) -> np.ndarray:
warmup_candles_num = get_config('env.data.warmup_candles_num', 240)
if not sequential and candles.shape[0] > warmup_candles_num:
candles = candles[-warmup_candles_num:]
return candles
def style(msg_text: str, msg_style: str) -> str:
if msg_style is None:
return msg_text
if msg_style.lower() in ['bold', 'b']:
return click.style(msg_text, bold=True)
if msg_style.lower() in ['underline', 'u']:
return click.style(msg_text, underline=True)
raise ValueError('unsupported style')
def terminate_app() -> None:
# close the database
from jesse.services.db import database
database.close_connection()
# disconnect python from the OS
os._exit(1)
def error(msg: str, force_print: bool = False) -> None:
# send notifications if it's a live session
if is_live():
from jesse.services import logger
logger.error(msg)
if force_print:
_print_error(msg)
else:
_print_error(msg)
def _print_error(msg: str) -> None:
print('\n')
print(color('========== critical error =========='.upper(), 'red'))
print(color(msg, 'red'))
print(color('====================================', 'red'))
def timestamp_to_arrow(timestamp: int) -> arrow.arrow.Arrow:
return arrow.get(timestamp / 1000)
def timestamp_to_date(timestamp: int) -> str:
return str(arrow.get(timestamp / 1000))[:10]
def timestamp_to_time(timestamp: int) -> str:
return str(arrow.get(timestamp / 1000))
def timestamp_to_iso8601(timestamp: int) -> str:
# example: 1609804800000 => '2021-01-05T00:00:00.000Z'
return arrow.get(timestamp / 1000).isoformat()
def iso8601_to_timestamp(iso8601: str) -> int:
# example: '2021-01-05T00:00:00.000Z' -> 1609740800000
return int(arrow.get(iso8601, 'YYYY-MM-DDTHH:mm:ss.SSSZ').datetime.timestamp()) * 1000
def today_to_timestamp() -> int:
"""
returns today's (beginning) timestamp
:return: int
"""
return arrow.utcnow().floor('day').int_timestamp * 1000
@lru_cache
def type_to_side(t: str) -> str:
from jesse.enums import trade_types, sides
if t == trade_types.LONG:
return sides.BUY
if t == trade_types.SHORT:
return sides.SELL
raise ValueError(f'unsupported type: "{t}". Only "long" and "short" are supported.')
def unique_list(arr) -> list:
"""
returns a unique version of the list while keeping its order
:param arr: list | tuple
:return: list
"""
seen = set()
seen_add = seen.add
return [x for x in arr if not (x in seen or seen_add(x))]
def closing_side(position_type: str) -> str:
if position_type.lower() == 'long':
return 'sell'
elif position_type.lower() == 'short':
return 'buy'
else:
raise ValueError(f'Value entered for position_type ({position_type}) is not valid')
def merge_dicts(d1: dict, d2: dict) -> dict:
"""
Merges nested dictionaries
:param d1: dict
:param d2: dict
:return: dict
"""
def inner(dict1, dict2):
for k in set(dict1.keys()).union(dict2.keys()):
if k in dict1 and k in dict2:
if isinstance(dict1[k], dict) and isinstance(dict2[k], dict):
yield k, dict(merge_dicts(dict1[k], dict2[k]))
else:
yield k, dict2[k]
elif k in dict1:
yield k, dict1[k]
else:
yield k, dict2[k]
return dict(inner(d1, d2))
def computer_name():
import platform
return platform.node()
def validate_response(response):
if response.status_code != 200:
err_msg = f"[{response.status_code}]: {response.json()['message']}\nPlease contact us at support@jesse.trade if this is unexpected."
if response.status_code not in [401, 403]:
raise ConnectionError(err_msg)
error(err_msg, force_print=True)
terminate_app()
def get_session_id():
from jesse.store import store
if store.app.session_id == '':
store.app.session_id = generate_unique_id()
return store.app.session_id
def get_pid():
return os.getpid()
def is_jesse_project():
ls = os.listdir('.')
return 'strategies' in ls and 'storage' in ls
def dd(item):
"""
Dump and Die but pretty: used for debugging when developing Jesse
"""
dump(item)
terminate_app()
def dump(*item):
"""
Dump object in pretty format: used for debugging when developing Jesse
"""
if len(item) == 1:
item = item[0]
print(
color('\n========= Debugging Value =========='.upper(), 'yellow')
)
pprint(item)
print(
color('====================================\n', 'yellow')
)
def debug(*item):
"""
Used for debugging when developing Jesse. Prints the item in pretty format in both
the terminal and the log file.
"""
if len(item) == 1:
dump(f"==> {item[0]}")
else:
dump(f"==> {', '.join(str(x) for x in item)}")
from jesse.services import logger
if len(item) == 1:
logger.info(f"==> {item[0]}")
else:
logger.info(f"==> {', '.join(str(x) for x in item)}")
def terminal_debug(*item):
"""
Used for debugging when developing Jesse. Prints the item with timestamp in the
terminal only (not logged to file). Uses local timezone.
"""
timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
if len(item) == 1:
dump(f"[{timestamp}] ==> {item[0]}")
else:
dump(f"[{timestamp}] ==> {', '.join(str(x) for x in item)}")
def float_or_none(item):
"""
Return the float of the value if it's not None
"""
if item is None or item == '':
return None
else:
return float(item)
def str_or_none(item, encoding='utf-8'):
"""
Return the str of the value if it's not None
"""
if item is None:
return None
else:
# return item if it's str, if not, decode it using encoding
if isinstance(item, str):
return item
if isinstance(item, np.float64):
return str(item)
try:
return str(item, encoding)
except TypeError:
return str(item)
def cpu_cores_count():
from multiprocessing import cpu_count
return cpu_count()
# a function that converts name to env_name. Example: 'Testnet Binance Futures' into 'TESTNET_BINANCE_FUTURES'
def convert_to_env_name(name: str) -> str:
return name.replace(' ', '_').upper()
def is_notebook():
try:
shell = get_ipython().__class__.__name__
# Jupyter notebook or qtconsole
if shell == 'ZMQInteractiveShell':
return True
elif shell == 'TerminalInteractiveShell':
# Terminal running IPython
return False
else:
# Other type (?)
return False
except NameError:
# Probably standard Python interpreter
return False
def get_os() -> str:
import platform
if platform.system() == 'Darwin':
return 'mac'
elif platform.system() == 'Linux':
return 'linux'
elif platform.system() == 'Windows':
return 'windows'
else:
raise NotImplementedError(f'Unsupported OS: "{platform.system()}"')
# a function that returns boolean whether or not the code is being executed inside a docker container
def is_docker() -> bool:
import os
return os.path.exists('/.dockerenv')
def clear_output():
if is_notebook():
from IPython.display import clear_output
clear_output(wait=True)
else:
click.clear()
def clean_nan_values(obj):
"""
Recursively clean NaN values from data structures by replacing them with None.
:param obj: The object to clean (can be dict, list, or primitive)
:return: The cleaned object with NaN values replaced
"""
import math
import numpy as np
if isinstance(obj, dict):
return {k: clean_nan_values(v) for k, v in obj.items()}
elif isinstance(obj, list):
return [clean_nan_values(item) for item in obj]
elif isinstance(obj, bool):
# bool is a subclass of int in Python; keep it as boolean
return obj
elif isinstance(obj, (float, np.floating)):
# Replace NaN with None
if math.isnan(float(obj)):
return None
return float(obj)
elif isinstance(obj, (int, np.integer)):
# Keep integers as-is (cast NumPy integers to native int)
return int(obj)
else:
return obj
def clean_infinite_values(obj):
"""
Recursively clean infinite values (inf, -inf) from data structures
by replacing them with None or 0
:param obj: The object to clean (can be dict, list, or primitive)
:return: The cleaned object with infinite values replaced
"""
import math
if isinstance(obj, dict):
return {k: clean_infinite_values(v) for k, v in obj.items()}
elif isinstance(obj, list):
return [clean_infinite_values(item) for item in obj]
elif isinstance(obj, float):
if math.isinf(obj):
return None
return obj
else:
return obj
def get_class_name(cls):
# if it's a string, return it
if isinstance(cls, str):
return cls
# else, return the class name
return cls.__name__
def next_candle_timestamp(candle: np.ndarray, timeframe: str) -> int:
return candle[0] + timeframe_to_one_minutes(timeframe) * 60_000
def get_candle_start_timestamp_based_on_timeframe(timeframe: str, num_candles_to_fetch: int) -> int:
one_min_count = timeframe_to_one_minutes(timeframe)
finish_date = now(force_fresh=True)
return finish_date - (num_candles_to_fetch * one_min_count * 60_000)
def is_price_near(order_price, price_to_compare, percentage_threshold=0.00015):
"""
Check if the given order price is near the specified price.
Default percentage_threshold is 0.015% (0.00015)
We calculate percentage difference between the two prices rounded to 4 decimal places,
so low-priced orders can be properly compared within 0.015% range.
"""
return abs(1 - (order_price / price_to_compare)) <= percentage_threshold
def gzip_compress(data):
"""Compress data using gzip."""
json_data = json.dumps(data).encode('utf-8')
# Compress the JSON string
return gzip.compress(json_data)
def timeframe_to_one_minutes(timeframe: str) -> int:
from jesse.utils import timeframe_to_one_minutes
return timeframe_to_one_minutes(timeframe)
def compressed_response(content: str) -> dict:
"""
Helper function to handle compression for HTTP responses.
Returns a dict with compression info and content.
:param content: string content to potentially compress
:return: dict with is_compressed flag and content
"""
# check if content is large enough to warrant compression
compressed = gzip_compress(content)
# encode as base64 string for safe transmission
return {
'is_compressed': True,
'data': base64.b64encode(compressed).decode('utf-8')
}
def validate_cwd() -> None:
"""
make sure we're in a Jesse project
"""
if not is_jesse_project():
print(
color(
'Current directory is not a Jesse project. You must run commands from the root of a Jesse project. Read this page for more info: https://docs.jesse.trade/docs/getting-started/#create-a-new-jesse-project',
'red'
)
)
os._exit(1)
def has_live_trade_plugin() -> bool:
try:
import jesse_live
except ModuleNotFoundError:
return False
return True
def normalize_bool(v: Any) -> bool:
if isinstance(v, bool):
return v
if isinstance(v, int):
return v == 1
if isinstance(v, str):
s = v.strip().lower()
if s in ['1', 'true']:
return True
if s in ['0', 'false']:
return False
return bool(v)
================================================
FILE: jesse/indicators/__init__.py
================================================
from .acosc import acosc
from .ad import ad
from .adosc import adosc
from .adx import adx
from .adxr import adxr
from .alligator import alligator
from .alma import alma
from .ao import ao
from .apo import apo
from .aroon import aroon
from .aroonosc import aroonosc
from .atr import atr
from .avgprice import avgprice
from .bandpass import bandpass
from .beta import beta
from .bollinger_bands import bollinger_bands
from .bollinger_bands_width import bollinger_bands_width
from .bop import bop
from .cc import cc
from .cci import cci
from .cfo import cfo
from .cg import cg
from .chande import chande
from .chop import chop
from .cksp import cksp
from .cmo import cmo
from .correl import correl
from .correlation_cycle import correlation_cycle
from .cvi import cvi
from .cwma import cwma
from .damiani_volatmeter import damiani_volatmeter
from .dec_osc import dec_osc
from .decycler import decycler
from .dema import dema
from .devstop import devstop
from .di import di
from .dm import dm
from .donchian import donchian
from .dpo import dpo
from .dti import dti
from .dx import dx
from .edcf import edcf
from .efi import efi
from .ema import ema
from .emd import emd
from .emv import emv
from .epma import epma
from .er import er
from .eri import eri
from .fisher import fisher
from .fosc import fosc
from .frama import frama
from .fwma import fwma
from .gatorosc import gatorosc
from .gauss import gauss
from .heikin_ashi_candles import heikin_ashi_candles
from .high_pass import high_pass
from .high_pass_2_pole import high_pass_2_pole
from .hma import hma
from .hurst_exponent import hurst_exponent
from .hwma import hwma
from .ichimoku_cloud import ichimoku_cloud
from .ichimoku_cloud_seq import ichimoku_cloud_seq
from .ift_rsi import ift_rsi
from .itrend import itrend
from .jma import jma
from .jsa import jsa
from .kama import kama
from .kaufmanstop import kaufmanstop
from .kdj import kdj
from .keltner import keltner
from .kst import kst
from .kurtosis import kurtosis
from .kvo import kvo
from .linearreg import linearreg
from .linearreg_angle import linearreg_angle
from .linearreg_intercept import linearreg_intercept
from .linearreg_slope import linearreg_slope
from .lrsi import lrsi
from .ma import ma
from .maaq import maaq
from .mab import mab
from .macd import macd
from .mama import mama
from .marketfi import marketfi
from .mass import mass
from .mcginley_dynamic import mcginley_dynamic
from .mean_ad import mean_ad
from .median_ad import median_ad
from .medprice import medprice
from .mfi import mfi
from .midpoint import midpoint
from .midprice import midprice
from .minmax import minmax
from .mom import mom
from .mwdx import mwdx
from .natr import natr
from .nma import nma
from .nvi import nvi
from .obv import obv
from .pfe import pfe
from .pivot import pivot
from .pma import pma
from .ppo import ppo
from .pvi import pvi
from .pwma import pwma
from .qstick import qstick
from .reflex import reflex
from .rma import rma
from .roc import roc
from .rocp import rocp
from .rocr import rocr
from .rocr100 import rocr100
from .roofing import roofing
from .rsi import rsi
from .rsmk import rsmk
from .rsx import rsx
from .rvi import rvi
from .safezonestop import safezonestop
from .sar import sar
from .sinwma import sinwma
from .skew import skew
from .sma import sma
from .smma import smma
from .sqwma import sqwma
from .srsi import srsi
from .srwma import srwma
from .stc import stc
from .stddev import stddev
from .stochastic import stoch
from .stochf import stochf
from .supersmoother import supersmoother
from .supersmoother_3_pole import supersmoother_3_pole
from .supertrend import supertrend
from .swma import swma
from .t3 import t3
from .tema import tema
from .trange import trange
from .trendflex import trendflex
from .trima import trima
from .trix import trix
from .tsf import tsf
from .tsi import tsi
from .ttm_trend import ttm_trend
from .typprice import typprice
from .ui import ui
from .ultosc import ultosc
from .var import var
from .vi import vi
from .vidya import vidya
from .vlma import vlma
from .vosc import vosc
from .voss import voss
from .vpci import vpci
from .vpt import vpt
from .vpwma import vpwma
from .vwap import vwap
from .vwma import vwma
from .vwmacd import vwmacd
from .wad import wad
from .wclprice import wclprice
from .wilders import wilders
from .willr import willr
from .wma import wma
from .wt import wt
from .zlema import zlema
from .zscore import zscore
from .waddah_attr_explosion import waddah_attar_explosion
from .stiffness import stiffness
from .ttm_squeeze import ttm_squeeze
from .support_resistance_with_break import support_resistance_with_breaks
from .squeeze_momentum import squeeze_momentum
from .hull_suit import hull_suit
from .volume import volume
================================================
FILE: jesse/indicators/acosc.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
AC = namedtuple('AC', ['osc', 'change'])
def sma(arr: np.ndarray, period: int) -> np.ndarray:
if len(arr) < period:
return np.full_like(arr, np.nan, dtype=float)
conv = np.convolve(arr, np.ones(period, dtype=float)/period, mode='valid')
return np.concatenate((np.full(period-1, np.nan), conv))
def mom(arr: np.ndarray, period: int = 1) -> np.ndarray:
return np.concatenate(([np.nan], np.diff(arr)))
def acosc(candles: np.ndarray, sequential: bool = False) -> AC:
"""
Acceleration / Deceleration Oscillator (AC)
:param candles: np.ndarray
:param sequential: bool - default: False
:return: AC(osc, change)
"""
candles = slice_candles(candles, sequential)
med = (candles[:, 3] + candles[:, 4]) / 2
sma5_med = sma(med, 5)
sma34_med = sma(med, 34)
ao = sma5_med - sma34_med
sma5_ao = sma(ao, 5)
res = ao - sma5_ao
mom_value = mom(res, 1)
if sequential:
return AC(res, mom_value)
else:
return AC(res[-1], mom_value[-1])
================================================
FILE: jesse/indicators/ad.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def ad(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
AD - Chaikin A/D Line
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3].astype(np.float64)
low = candles[:, 4].astype(np.float64)
close = candles[:, 2].astype(np.float64)
volume = candles[:, 5].astype(np.float64)
# Calculate Money Flow Multiplier. Safeguard division by zero in case high equals low.
mfm = np.where(high != low, ((close - low) - (high - close)) / (high - low), 0.0)
# Calculate Money Flow Volume
mfv = mfm * volume
# Compute the Accumulation/Distribution line as the cumulative sum of Money Flow Volume
ad_line = np.cumsum(mfv)
return ad_line if sequential else ad_line[-1]
================================================
FILE: jesse/indicators/adosc.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from jesse_rust import adosc as adosc_rust
def adosc(candles: np.ndarray, fast_period: int = 3, slow_period: int = 10, sequential: bool = False) -> Union[float, np.ndarray]:
"""
ADOSC - Chaikin A/D Oscillator (Rust accelerated version)
:param candles: np.ndarray of candles
:param fast_period: int - default: 3
:param slow_period: int - default: 10
:param sequential: bool - default: False
:return: float or np.ndarray
"""
candles = slice_candles(candles, sequential)
# Convert to float64 for Rust compatibility
candles_f64 = np.asarray(candles, dtype=np.float64)
# Call the Rust implementation
result = adosc_rust(candles_f64, fast_period, slow_period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/adx.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from jesse_rust import adx as adx_rust
def adx(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
ADX - Average Directional Movement Index
:param candles: np.ndarray, expected 2D array with OHLCV data where index 3 is high, index 4 is low, and index 2 is close
:param period: int - default: 14
:param sequential: bool - if True, return full series, else return last value
:return: float | np.ndarray
"""
if len(candles.shape) < 2:
raise ValueError("adx indicator requires a 2D array of candles")
candles = slice_candles(candles, sequential)
# Ensure there's enough data
if len(candles) <= 2 * period:
return np.nan if not sequential else np.full(len(candles), np.nan)
result = adx_rust(candles, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/adxr.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from numba import njit
@njit(cache=True)
def _adxr(high, low, close, period):
n = len(high)
TR = np.zeros(n)
DMP = np.zeros(n)
DMM = np.zeros(n)
# First value
TR[0] = high[0] - low[0]
# Calculate TR, DMP, DMM
for i in range(1, n):
hl = high[i] - low[i]
hc = abs(high[i] - close[i-1])
lc = abs(low[i] - close[i-1])
TR[i] = max(hl, hc, lc)
up_move = high[i] - high[i-1]
down_move = low[i-1] - low[i]
if up_move > down_move and up_move > 0:
DMP[i] = up_move
else:
DMP[i] = 0
if down_move > up_move and down_move > 0:
DMM[i] = down_move
else:
DMM[i] = 0
# Smoothed TR, DMP, DMM
STR = np.zeros(n)
S_DMP = np.zeros(n)
S_DMM = np.zeros(n)
# Initialize first value
STR[0] = TR[0]
S_DMP[0] = DMP[0]
S_DMM[0] = DMM[0]
# Calculate smoothed values
for i in range(1, n):
STR[i] = STR[i-1] - (STR[i-1] / period) + TR[i]
S_DMP[i] = S_DMP[i-1] - (S_DMP[i-1] / period) + DMP[i]
S_DMM[i] = S_DMM[i-1] - (S_DMM[i-1] / period) + DMM[i]
# Calculate DI+ and DI-
DI_plus = np.zeros(n)
DI_minus = np.zeros(n)
for i in range(n):
if STR[i] != 0:
DI_plus[i] = (S_DMP[i] / STR[i]) * 100
DI_minus[i] = (S_DMM[i] / STR[i]) * 100
# Calculate DX
DX = np.zeros(n)
for i in range(n):
denom = DI_plus[i] + DI_minus[i]
if denom != 0:
DX[i] = (abs(DI_plus[i] - DI_minus[i]) / denom) * 100
# Calculate ADX
ADX = np.full(n, np.nan)
if n >= period:
for i in range(period-1, n):
sum_dx = 0
for j in range(period):
sum_dx += DX[i-j]
ADX[i] = sum_dx / period
# Calculate ADXR
ADXR = np.full(n, np.nan)
if n > period:
for i in range(period, n):
ADXR[i] = (ADX[i] + ADX[i-period]) / 2
return ADXR
def adxr(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
@author KivancOzbilgic
credits: https://www.tradingview.com/v/9f5zDi3r/
ADXR - Average Directional Movement Index Rating
:param candles: np.ndarray with at least 5 columns where index 3 is high, index 4 is low and index 2 is close
:param period: int - period for smoothing and moving average (default: 14)
:param sequential: bool - returns full series if True, else only the last computed value
:return: ADXR as float or np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
close = candles[:, 2]
ADXR = _adxr(high, low, close, period)
return ADXR if sequential else ADXR[-1]
================================================
FILE: jesse/indicators/alligator.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import smma, shift, alligator as alligator_rust
AG = namedtuple('AG', ['jaw', 'teeth', 'lips'])
def alligator(candles: np.ndarray, source_type: str = "hl2", sequential: bool = False) -> AG:
"""
Alligator indicator by Bill Williams
:param candles: np.ndarray
:param source_type: str - default: "hl2"
:param sequential: bool - default: False
:return: AG(jaw, teeth, lips)
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Use Rust implementation for calculating the alligator
jaw, teeth, lips = alligator_rust(source)
if sequential:
return AG(jaw, teeth, lips)
else:
return AG(jaw[-1], teeth[-1], lips[-1])
================================================
FILE: jesse/indicators/alma.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def alma(candles: np.ndarray, period: int = 9, sigma: float = 6.0, distribution_offset: float = 0.85,
source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
ALMA - Arnaud Legoux Moving Average
:param candles: np.ndarray
:param period: int - default: 9
:param sigma: float - default: 6.0
:param distribution_offset: float - default: 0.85
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
asize = period - 1
m = distribution_offset * asize
s = period / sigma
dss = 2 * s * s
wtds = np.exp(-(np.arange(period) - m) ** 2 / dss)
pnp_array3D = strided_axis0(source, len(wtds))
res = np.zeros(source.shape)
res[period - 1:] = np.tensordot(pnp_array3D, wtds, axes=(1, 0))[:]
res /= wtds.sum()
res[res == 0] = np.nan
return res if sequential else res[-1]
def strided_axis0(a, L):
# Store the shape and strides info
shp = a.shape
s = a.strides
# Compute length of output array along the first axis
nd0 = shp[0] - L + 1
# Setup shape and strides for use with np.lib.stride_tricks.as_strided
# and get (n+1) dim output array
shp_in = (nd0, L) + shp[1:]
strd_in = (s[0],) + s
return np.lib.stride_tricks.as_strided(a, shape=shp_in, strides=strd_in)
================================================
FILE: jesse/indicators/ao.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
from .sma import sma
AO = namedtuple('AO', ['osc', 'change'])
def momentum(arr):
ret = np.full(arr.shape, np.nan)
if len(arr) > 1:
ret[1:] = arr[1:] - arr[:-1]
return ret
def ao(candles: np.ndarray, sequential: bool = False) -> AO:
"""
Awesome Oscillator
:param candles: np.ndarray
:param sequential: bool - default: False
:return: AO(osc, change)
"""
candles = slice_candles(candles, sequential)
# Calculate hl2 as (high+low)/2
hl2 = (candles[:, 3] + candles[:, 4]) / 2
# Calculate simple moving averages on hl2 for periods 5 and 34
sma5 = sma(hl2, 5, sequential=True)
sma34 = sma(hl2, 34, sequential=True)
ao = sma5 - sma34
# Calculate momentum as the difference between consecutive values
mom = momentum(ao)
if sequential:
return AO(ao, mom)
else:
return AO(ao[-1], mom[-1])
================================================
FILE: jesse/indicators/apo.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse.indicators.ma import ma
def apo(candles: np.ndarray, fast_period: int = 12, slow_period: int = 26, matype: int = 0, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
APO - Absolute Price Oscillator
:param candles: np.ndarray
:param fast_period: int - default: 12
:param slow_period: int - default: 26
:param matype: int - default: 0
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if matype == 24 or matype == 29:
res = ma(candles, period=fast_period, matype=matype, source_type=source_type, sequential=True) - ma(candles, period=slow_period, matype=matype, source_type=source_type, sequential=True)
else:
res = ma(source, period=fast_period, matype=matype, sequential=True) - ma(source, period=slow_period, matype=matype, sequential=True)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/aroon.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
AROON = namedtuple('AROON', ['down', 'up'])
def aroon(candles: np.ndarray, period: int = 14, sequential: bool = False) -> AROON:
"""
AROON indicator
:param candles: np.ndarray, expected to have at least 5 columns, with high at index 3 and low at index 4.
:param period: int - period for the indicator (default: 14)
:param sequential: bool - whether to return the whole series (default: False)
:return: AROON(down, up) where each value is computed as above.
"""
candles = slice_candles(candles, sequential)
highs = candles[:, 3]
lows = candles[:, 4]
if sequential:
aroon_up = np.full(highs.shape, np.nan, dtype=float)
aroon_down = np.full(lows.shape, np.nan, dtype=float)
if len(highs) >= period + 1:
# Create sliding window view of period+1 elements for highs and lows
windows_high = np.lib.stride_tricks.sliding_window_view(highs, window_shape=period+1)
windows_low = np.lib.stride_tricks.sliding_window_view(lows, window_shape=period+1)
aroon_up[period:] = 100 * (np.argmax(windows_high, axis=1) / period)
aroon_down[period:] = 100 * (np.argmin(windows_low, axis=1) / period)
return AROON(down=aroon_down, up=aroon_up)
else:
if len(highs) < period + 1:
up_val = float('nan')
down_val = float('nan')
else:
window_high = highs[-(period + 1):]
window_low = lows[-(period + 1):]
up_val = 100 * (np.argmax(window_high) / period)
down_val = 100 * (np.argmin(window_low) / period)
return AROON(down=down_val, up=up_val)
================================================
FILE: jesse/indicators/aroonosc.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import slice_candles
@njit(cache=True)
def _compute_aroonosc_nb(high: np.ndarray, low: np.ndarray, period: int) -> np.ndarray:
n = high.shape[0]
result = np.empty(n, dtype=np.float64)
if n < period:
for i in range(n):
result[i] = np.nan
return result
for i in range(period - 1):
result[i] = np.nan
for i in range(period - 1, n):
start = i - period + 1
best_val = high[start]
best_idx = 0
worst_val = low[start]
worst_idx = 0
for j in range(period):
cur_high = high[start + j]
cur_low = low[start + j]
if cur_high > best_val:
best_val = cur_high
best_idx = j
if cur_low < worst_val:
worst_val = cur_low
worst_idx = j
result[i] = 100.0 * (best_idx - worst_idx) / period
return result
def aroonosc(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
AROONOSC - Aroon Oscillator
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
result = _compute_aroonosc_nb(high, low, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/atr.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from jesse_rust import atr as rust_atr
def atr(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
ATR - Average True Range using optimized Rust implementation
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
result = rust_atr(candles, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/avgprice.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def avgprice(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
AVGPRICE - Average Price
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
res = (candles[:, 1] + candles[:, 3] + candles[:, 4] + candles[:, 2]) / 4
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/bandpass.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
from .high_pass import high_pass_fast
BandPass = namedtuple('BandPass', ['bp', 'bp_normalized', 'signal', 'trigger'])
def bandpass(candles: np.ndarray, period: int = 20, bandwidth: float = 0.3, source_type: str = "close", sequential: bool = False) -> BandPass:
"""
BandPass Filter
:param candles: np.ndarray
:param period: int - default: 20
:param bandwidth: float - default: 0.3
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: BandPass(bp, bp_normalized, signal, trigger)
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
hp = high_pass_fast(source, 4 * period / bandwidth)
beta = np.cos(2 * np.pi / period)
gamma = np.cos(2 * np.pi * bandwidth / period)
alpha = 1 / gamma - np.sqrt(1 / gamma ** 2 - 1)
bp, peak = bp_fast(source, hp, alpha, beta)
bp_normalized = bp / peak
trigger = high_pass_fast(bp_normalized, period / bandwidth / 1.5)
signal = (bp_normalized < trigger) * 1 - (trigger < bp_normalized) * 1
if sequential:
return BandPass(bp, bp_normalized, signal, trigger)
else:
return BandPass(bp[-1], bp_normalized[-1], signal[-1], trigger[-1])
@njit(cache=True)
def bp_fast(source, hp, alpha, beta): # Function is compiled to machine code when called the first time
bp = np.copy(hp)
for i in range(2, source.shape[0]):
bp[i] = 0.5 * (1 - alpha) * hp[i] - (1 - alpha) * 0.5 * hp[i - 2] + beta * (1 + alpha) * bp[i - 1] - alpha * bp[i - 2]
# fast attack-slow decay AGC
K = 0.991
peak = np.copy(bp)
for i in range(source.shape[0]):
if i > 0:
peak[i] = peak[i - 1] * K
if np.abs(bp[i]) > peak[i]:
peak[i] = np.abs(bp[i])
return bp, peak
================================================
FILE: jesse/indicators/beta.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import slice_candles
def beta(candles: np.ndarray, benchmark_candles: np.ndarray, period: int = 5, sequential: bool = False) -> Union[float, np.ndarray]:
"""
BETA - compares the given candles close price to its benchmark (should be in the same time frame)
:param candles: np.ndarray
:param benchmark_candles: np.ndarray
:param period: int - default: 5
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
benchmark_candles = slice_candles(benchmark_candles, sequential)
x = candles[:, 2]
y = benchmark_candles[:, 2]
if len(x) < period:
out = np.full_like(x, fill_value=np.nan, dtype=float)
return out if sequential else np.nan
windows_x = sliding_window_view(x, window_shape=period)
windows_y = sliding_window_view(y, window_shape=period)
mean_x = windows_x.mean(axis=1)
mean_y = windows_y.mean(axis=1)
diff_x = windows_x - mean_x[:, None]
diff_y = windows_y - mean_y[:, None]
numerator = (diff_x * diff_y).sum(axis=1)
denominator = (diff_y ** 2).sum(axis=1)
with np.errstate(divide='ignore', invalid='ignore'):
beta_vals = numerator / denominator
out = np.full_like(x, fill_value=np.nan, dtype=float)
out[period - 1:] = beta_vals
return out if sequential else out[-1]
================================================
FILE: jesse/indicators/bollinger_bands.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse.indicators.ma import ma
from jesse.indicators.mean_ad import mean_ad
from jesse.indicators.median_ad import median_ad
# Try to import the high-performance Rust implementation
try:
from jesse_rust import bollinger_bands as bb_rust # type: ignore
from jesse_rust import moving_std
except ImportError: # pragma: no cover
bb_rust = None # type: ignore
from jesse_rust import moving_std
BollingerBands = namedtuple('BollingerBands', ['upperband', 'middleband', 'lowerband'])
def _bollinger_bands_fallback(source: np.ndarray, period: int, devup: float, devdn: float, matype: int, devtype: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
"""Fallback implementation for non-SMA cases or when Rust is unavailable."""
if devtype == 0:
dev = moving_std(source, period)
elif devtype == 1:
dev = mean_ad(source, period, sequential=True)
elif devtype == 2:
dev = median_ad(source, period, sequential=True)
else:
raise ValueError("devtype not in (0, 1, 2)")
middlebands = ma(source, period=period, matype=matype, sequential=True)
upperbands = middlebands + devup * dev
lowerbands = middlebands - devdn * dev
return upperbands, middlebands, lowerbands
def bollinger_bands(
candles: np.ndarray,
period: int = 20,
devup: float = 2,
devdn: float = 2,
matype: int = 0,
devtype: int = 0,
source_type: str = "close",
sequential: bool = False
) -> BollingerBands:
"""
BBANDS - Bollinger Bands
:param candles: np.ndarray
:param period: int - default: 20
:param devup: float - default: 2
:param devdn: float - default: 2
:param matype: int - default: 0
:param devtype: int - default: 0
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: BollingerBands(upperband, middleband, lowerband)
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Use optimized Rust implementation for standard case (SMA + standard deviation)
if bb_rust is not None and matype == 0 and devtype == 0:
upperbands, middlebands, lowerbands = bb_rust(source.astype(np.float64), period, devup, devdn)
else:
# Handle special cases or fallback
if matype == 24 or matype == 29:
# VWMA or VWAP need the full candles array
upperbands, middlebands, lowerbands = _bollinger_bands_fallback(candles, period, devup, devdn, matype, devtype)
else:
upperbands, middlebands, lowerbands = _bollinger_bands_fallback(source, period, devup, devdn, matype, devtype)
if sequential:
return BollingerBands(upperbands, middlebands, lowerbands)
else:
return BollingerBands(upperbands[-1], middlebands[-1], lowerbands[-1])
================================================
FILE: jesse/indicators/bollinger_bands_width.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import bollinger_bands_width as bollinger_bands_width_rust
def bollinger_bands_width(candles: np.ndarray, period: int = 20, mult: float = 2.0, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
BBW - Bollinger Bands Width
:param candles: np.ndarray
:param period: int - default: 20
:param mult: float - default: 2
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
result = bollinger_bands_width_rust(source, period, float(mult))
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/bop.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def bop(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
BOP - Balance Of Power
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
open_prices = candles[:, 1]
high_prices = candles[:, 3]
low_prices = candles[:, 4]
close_prices = candles[:, 2]
denominator = high_prices - low_prices
bop_values = np.where(denominator != 0, (close_prices - open_prices) / denominator, 0)
return bop_values if sequential else bop_values[-1]
================================================
FILE: jesse/indicators/cc.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from .roc import roc
from .wma import wma
def cc(candles: np.ndarray, wma_period: int = 10, roc_short_period: int = 11, roc_long_period: int = 14,
source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
CC - Coppock Curve
:param candles: np.ndarray
:param wma_period: int - default: 10
:param roc_short_period: int - default: 11
:param roc_long_period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
roc_long = roc(source, roc_long_period, sequential=True)
roc_short = roc(source, roc_short_period, sequential=True)
roc_sum = roc_long + roc_short
res = wma(roc_sum, wma_period, sequential=True)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/cci.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import slice_candles
@njit(cache=True)
def calculate_cci_loop(tp, period):
n = tp.shape[0]
result = np.empty(n)
# initialize result with NaNs
for i in range(n):
result[i] = np.nan
if n < period:
return result
for i in range(period - 1, n):
sum_tp = 0.0
for j in range(i - period + 1, i + 1):
sum_tp += tp[j]
sma = sum_tp / period
sum_diff = 0.0
for j in range(i - period + 1, i + 1):
# Calculate absolute deviation
if tp[j] >= sma:
sum_diff += tp[j] - sma
else:
sum_diff += sma - tp[j]
md = sum_diff / period
if md == 0.0:
result[i] = 0.0
else:
result[i] = (tp[i] - sma) / (0.015 * md)
return result
def cci(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
CCI - Commodity Channel Index
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
close = candles[:, 2]
tp = (high + low + close) / 3.0
result = calculate_cci_loop(tp, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/cfo.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
@njit(cache=True)
def _compute_cfo(source: np.ndarray, period: int, scalar: float) -> np.ndarray:
n = source.shape[0]
res = np.empty(n, dtype=np.float64)
# fill initial values with nan for indices where a full period is not available
for i in range(period - 1):
res[i] = np.nan
# Precompute constants for x = 0, 1, ..., period-1
Sx = 0.0
Sxx = 0.0
for j in range(period):
Sx += j
Sxx += j * j
denom = period * Sxx - Sx * Sx
# For each valid window, compute the linear regression and forecast value
for i in range(period - 1, n):
sum_y = 0.0
sum_xy = 0.0
for j in range(period):
y_val = source[i - period + 1 + j]
sum_y += y_val
sum_xy += y_val * j
slope = (period * sum_xy - Sx * sum_y) / denom
intercept = (sum_y - slope * Sx) / period
reg_val = intercept + slope * (period - 1)
# Avoid division by zero
if source[i] != 0.0:
res[i] = scalar * (source[i] - reg_val) / source[i]
else:
res[i] = np.nan
return res
def cfo(candles: np.ndarray, period: int = 14, scalar: float = 100, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
CFO - Chande Forcast Oscillator
:param candles: np.ndarray
:param period: int - default: 14
:param scalar: float - default: 100
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = _compute_cfo(source, period, scalar)
if sequential:
return res
else:
return None if np.isnan(res[-1]) else res[-1]
================================================
FILE: jesse/indicators/cg.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
def cg(candles: np.ndarray, period: int = 10, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Center of Gravity (CG)
:param candles: np.ndarray
:param period: int - default: 10
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = go_fast(source, period)
return same_length(candles, res) if sequential else res[-1]
@njit(cache=True)
def go_fast(source, period): # Function is compiled to machine code when called the first time
res = np.full_like(source, fill_value=np.nan)
for i in range(source.size):
if i > period:
num = 0
denom = 0
for count in range(period - 1):
close = source[i - count]
if not np.isnan(close):
num += (1 + count) * close
denom += close
result = -num / denom if denom != 0 else 0
res[i] = result
return res
================================================
FILE: jesse/indicators/chande.py
================================================
from typing import Union
import numpy as np
from jesse_rust import chande as rust_chande
from jesse.helpers import slice_candles
def chande(candles: np.ndarray, period: int = 22, mult: float = 3.0, direction: str = "long",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
Chandelier Exits
:param candles: np.ndarray
:param period: int - default: 22
:param mult: float - default: 3.0
:param direction: str - default: "long"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
if direction not in ['long', 'short']:
raise ValueError('The direction parameter must be \'short\' or \'long\'')
result = rust_chande(candles, period, mult, direction)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/chop.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from jesse_rust import chop as chop_rust
def chop(candles: np.ndarray, period: int = 14, scalar: float = 100, drift: int = 1, sequential: bool = False) -> Union[float, np.ndarray]:
"""
Choppiness Index (CHOP)
:param candles: np.ndarray
:param period: int - default: 14
:param scalar: float - default: 100
:param drift: int - default: 1
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Preprocess candles using original slicing
candles = slice_candles(candles, sequential)
# Use Rust implementation
res = chop_rust(candles, period, scalar, drift)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/cksp.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
CKSP = namedtuple('CKSP', ['long', 'short'])
def atr(high: np.ndarray, low: np.ndarray, close: np.ndarray, timeperiod: int = 10) -> np.ndarray:
tr = np.empty_like(close)
tr[0] = high[0] - low[0]
tr[1:] = np.maximum.reduce([
high[1:] - low[1:],
np.abs(high[1:] - close[:-1]),
np.abs(low[1:] - close[:-1])
])
atr_vals = np.empty_like(close)
if len(close) < timeperiod:
return np.full_like(close, np.nan)
atr_vals[:timeperiod-1] = np.nan
atr_vals[timeperiod-1] = np.mean(tr[:timeperiod])
for t in range(timeperiod, len(close)):
atr_vals[t] = (atr_vals[t-1]*(timeperiod-1) + tr[t]) / timeperiod
return atr_vals
def rolling_max(arr: np.ndarray, window: int) -> np.ndarray:
n = len(arr)
if n == 0:
return arr
result = np.empty(n)
if window > 1:
result[:window-1] = np.maximum.accumulate(arr[:window-1])
if n >= window:
shape = (n - window + 1, window)
strides = (arr.strides[0], arr.strides[0])
windows = np.lib.stride_tricks.as_strided(arr, shape=shape, strides=strides)
result[window-1:] = np.max(windows, axis=1)
else:
result = arr.copy()
return result
def rolling_min(arr: np.ndarray, window: int) -> np.ndarray:
n = len(arr)
if n == 0:
return arr
result = np.empty(n)
if window > 1:
result[:window-1] = np.minimum.accumulate(arr[:window-1])
if n >= window:
shape = (n - window + 1, window)
strides = (arr.strides[0], arr.strides[0])
windows = np.lib.stride_tricks.as_strided(arr, shape=shape, strides=strides)
result[window-1:] = np.min(windows, axis=1)
else:
result = arr.copy()
return result
def cksp(candles: np.ndarray, p: int = 10, x: float = 1.0, q: int = 9, sequential: bool = False) -> CKSP:
"""
Chande Kroll Stop (CKSP)
:param candles: np.ndarray
:param p: int - default: 10 (ATR period)
:param x: float - default: 1.0 (ATR multiplier)
:param q: int - default: 9 (rolling window period)
:param sequential: bool - default: False
:return: CKSP namedtuple containing long and short values
"""
candles = slice_candles(candles, sequential)
candles_close = candles[:, 2]
candles_high = candles[:, 3]
candles_low = candles[:, 4]
atr_vals = atr(candles_high, candles_low, candles_close, timeperiod=p)
LS0 = rolling_max(candles_high, window=q) - x * atr_vals
LS = rolling_max(LS0, window=q)
SS0 = rolling_min(candles_low, window=q) + x * atr_vals
SS = rolling_min(SS0, window=q)
if sequential:
return CKSP(LS, SS)
else:
return CKSP(LS[-1], SS[-1])
================================================
FILE: jesse/indicators/cmo.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
@njit(cache=True)
def _cmo_numba(source: np.ndarray, period: int) -> np.ndarray:
n = source.shape[0]
result = np.empty(n, dtype=np.float64)
# Initialize result with NaN values
for i in range(n):
result[i] = np.nan
if n <= 1:
return result
# Compute the differences manually
diff = np.empty(n - 1, dtype=np.float64)
for i in range(n - 1):
diff[i] = source[i + 1] - source[i]
# Only compute CMO if we have enough diff values
if diff.shape[0] >= period:
for i in range(period, n):
pos_sum = 0.0
neg_sum = 0.0
# Calculate sums over the window diff[i-period:i]
for j in range(i - period, i):
d = diff[j]
if d > 0:
pos_sum += d
elif d < 0:
neg_sum += -d
denom = pos_sum + neg_sum
if denom == 0.0:
result[i] = 0.0
else:
result[i] = 100.0 * (pos_sum - neg_sum) / denom
return result
def cmo(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
CMO - Chande Momentum Oscillator
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
result = _cmo_numba(source, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/correl.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def correl(candles: np.ndarray, period: int = 5, sequential: bool = False) -> Union[float, np.ndarray]:
"""
CORREL - Pearson's Correlation Coefficient (r)
:param candles: np.ndarray
:param period: int - default: 5
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
x = candles[:, 3]
y = candles[:, 4]
n = len(x)
# If not enough data, return an array of NaNs
if n < period:
res = np.empty(n)
res[:] = np.nan
return res if sequential else res[-1]
# Use numpy's sliding_window_view for vectorized rolling window computation
windows_x = np.lib.stride_tricks.sliding_window_view(x, window_shape=period)
windows_y = np.lib.stride_tricks.sliding_window_view(y, window_shape=period)
mean_x = np.mean(windows_x, axis=1)
mean_y = np.mean(windows_y, axis=1)
# Calculate numerator and denominator for Pearson correlation coefficient
numerator = np.sum((windows_x - mean_x[:, None]) * (windows_y - mean_y[:, None]), axis=1)
denominator = np.sqrt(np.sum((windows_x - mean_x[:, None])**2, axis=1) * np.sum((windows_y - mean_y[:, None])**2, axis=1))
with np.errstate(divide='ignore', invalid='ignore'):
corr_vals = numerator / denominator
# Prepare full result array with initial NaNs for indices with insufficient data
res_full = np.empty(n)
res_full[:period-1] = np.nan
res_full[period-1:] = corr_vals
return res_full if sequential else res_full[-1]
================================================
FILE: jesse/indicators/correlation_cycle.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, np_shift, slice_candles
CC = namedtuple('CC', ['real', 'imag', 'angle', 'state'])
def correlation_cycle(candles: np.ndarray, period: int = 20, threshold: int = 9, source_type: str = "close",
sequential: bool = False) -> CC:
"""
"Correlation Cycle, Correlation Angle, Market State - John Ehlers
:param candles: np.ndarray
:param period: int - default: 20
:param threshold: int - default: 9
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: CC(real, imag)
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
realPart, imagPart, angle = go_fast(source, period)
priorAngle = np_shift(angle, 1, fill_value=np.nan)
angle = np.where(np.logical_and(priorAngle > angle, priorAngle - angle < 270.0), priorAngle, angle)
# Market State Function
state = np.where(np.abs(angle - priorAngle) < threshold, np.where(angle >= 0.0, 1, np.where(angle < 0.0, -1, 0)), 0)
if sequential:
return CC(realPart, imagPart, angle, state)
else:
return CC(realPart[-1], imagPart[-1], angle[-1], state[-1])
@njit(cache=True)
def go_fast(source, period): # Function is compiled to machine code when called the first time
# Correlation Cycle Function
PIx2 = 4.0 * np.arcsin(1.0)
period = max(2, period)
realPart = np.full_like(source, np.nan)
imagPart = np.full_like(source, np.nan)
for i in range(period, source.shape[0]):
Rx = 0.0
Rxx = 0.0
Rxy = 0.0
Ryy = 0.0
Ry = 0.0
Ix = 0.0
Ixx = 0.0
Ixy = 0.0
Iyy = 0.0
Iy = 0.0
for j in range(period):
jMinusOne = j + 1
X = 0 if np.isnan(source[i - jMinusOne]) else source[i - jMinusOne]
temp = PIx2 * jMinusOne / period
Yc = np.cos(temp)
Ys = -np.sin(temp)
Rx += X
Ix += X
Rxx += X * X
Ixx += X * X
Rxy += X * Yc
Ixy += X * Ys
Ryy += Yc * Yc
Iyy += Ys * Ys
Ry += Yc
Iy += Ys
temp_1 = period * Rxx - Rx**2
temp_2 = period * Ryy - Ry**2
if temp_1 > 0.0 and temp_2 > 0.0:
realPart[i] = (period * Rxy - Rx * Ry) / np.sqrt(temp_1 * temp_2)
temp_1 = period * Ixx - Ix**2
temp_2 = period * Iyy - Iy**2
if temp_1 > 0.0 and temp_2 > 0.0:
imagPart[i] = (period * Ixy - Ix * Iy) / np.sqrt(temp_1 * temp_2)
# Correlation Angle Phasor
HALF_OF_PI = np.arcsin(1.0)
angle = np.where(imagPart == 0, 0.0, np.degrees(np.arctan(realPart / imagPart) + HALF_OF_PI))
angle = np.where(imagPart > 0.0, angle - 180.0, angle)
return realPart, imagPart, angle
================================================
FILE: jesse/indicators/cvi.py
================================================
from typing import Union
import numpy as np
import jesse.helpers as jh
from jesse_rust import cvi as cvi_rust
def cvi(candles: np.ndarray, period: int = 5, sequential: bool = False) -> Union[float, np.ndarray]:
"""
CVI - Chaikins Volatility
:param candles: np.ndarray
:param period: int - default: 5
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = jh.slice_candles(candles, sequential)
# Call the Rust implementation
res = cvi_rust(candles, period)
return jh.same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/cwma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def cwma(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Cubed Weighted Moving Average
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = vpwma_fast(source, period)
return res if sequential else res[-1]
@njit(cache=True)
def vpwma_fast(source, period):
newseries = np.copy(source)
for j in range(period + 1, source.shape[0]):
my_sum = 0.0
weightSum = 0.0
for i in range(period - 1):
weight = np.power(period - i, 3)
my_sum += (source[j - i] * weight)
weightSum += weight
newseries[j] = my_sum / weightSum
return newseries
================================================
FILE: jesse/indicators/damiani_volatmeter.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
DamianiVolatmeter = namedtuple('DamianiVolatmeter', ['vol', 'anti'])
def atr(high: np.ndarray, low: np.ndarray, close: np.ndarray, timeperiod: int) -> np.ndarray:
tr = np.empty_like(high, dtype=float)
tr[0] = high[0] - low[0]
if high.shape[0] > 1:
diff1 = high[1:] - low[1:]
diff2 = np.abs(high[1:] - close[:-1])
diff3 = np.abs(low[1:] - close[:-1])
tr[1:] = np.maximum(diff1, np.maximum(diff2, diff3))
atr_array = np.full(high.shape, np.nan, dtype=float)
if high.shape[0] < timeperiod:
atr_array[-1] = np.mean(tr)
return atr_array
n = high.shape[0]
m = n - timeperiod + 1
alpha = 1.0 / timeperiod
initial = np.mean(tr[:timeperiod])
ema_vector = np.empty(m)
ema_vector[0] = initial
if m > 1:
k = np.arange(m) # k = 0,..., m-1
initial_contrib = initial * (1 - alpha) ** k
# Build a lower-triangular matrix for weights for indices 1 to m-1
exp_matrix = np.tril((1 - alpha) ** (np.subtract.outer(np.arange(m - 1), np.arange(m - 1))))
# tr[timeperiod:] has length m-1
sum_vals = alpha * (exp_matrix @ tr[timeperiod:])
ema_vector[1:] = initial_contrib[1:] + sum_vals
atr_array[:timeperiod - 1] = np.nan
atr_array[timeperiod - 1:] = ema_vector
return atr_array
def damiani_volatmeter(candles: np.ndarray, vis_atr: int = 13, vis_std: int = 20, sed_atr: int = 40, sed_std: int = 100,
threshold: float = 1.4, source_type: str = "close",
sequential: bool = False) -> DamianiVolatmeter:
"""
Damiani Volatmeter
:param candles: np.ndarray
:param vis_atr: int - default: 13
:param vis_std: int - default: 20
:param sed_atr: int - default: 40
:param sed_std: int - default: 100
:param threshold: float - default: 1.4
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
atrvis = atr(candles[:, 3], candles[:, 4], candles[:, 2], vis_atr)
atrsed = atr(candles[:, 3], candles[:, 4], candles[:, 2], sed_atr)
vol, t = damiani_volatmeter_fast(source, sed_std, atrvis, atrsed, vis_std, threshold)
if sequential:
return DamianiVolatmeter(vol, t)
else:
return DamianiVolatmeter(vol[-1], t[-1])
def damiani_volatmeter_fast(source, sed_std, atrvis, atrsed, vis_std, threshold):
from scipy.signal import lfilter
from numpy.lib.stride_tricks import sliding_window_view
lag_s = 0.5
n = source.shape[0]
# Compute vol using a linear filter to solve the recurrence:
# vol[i] - lag_s*vol[i-1] + lag_s*vol[i-3] = atrvis[i]/atrsed[i]
u = np.zeros(n)
u[sed_std:] = atrvis[sed_std:] / atrsed[sed_std:]
b = [1.0]
a = [1.0, -lag_s, 0.0, lag_s]
vol = lfilter(b, a, u)
# Compute t vectorized by calculating moving standard deviations without loops
t = np.zeros(n)
if n >= sed_std:
std_vis = np.std(sliding_window_view(source, vis_std), axis=-1)
std_sed = np.std(sliding_window_view(source, sed_std), axis=-1)
idx = np.arange(sed_std, n)
t[idx] = threshold - (std_vis[idx - vis_std] / std_sed[idx - sed_std])
return vol, t
================================================
FILE: jesse/indicators/dec_osc.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from .high_pass_2_pole import high_pass_2_pole_fast
def dec_osc(candles: np.ndarray, hp_period: int = 125, k: float = 1, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
Ehlers Decycler Oscillator
:param candles: np.ndarray
:param hp_period: int - default: 125
:param k: float - default: 1
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
hp = high_pass_2_pole_fast(source, hp_period)
dec = source - hp
decosc = high_pass_2_pole_fast(dec, 0.5 * hp_period)
res = 100 * k * decosc / source
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/decycler.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from .high_pass_2_pole import high_pass_2_pole_fast
def decycler(candles: np.ndarray, hp_period: int = 125, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Ehlers Simple Decycler
:param candles: np.ndarray
:param hp_period: int - default: 125
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
hp = high_pass_2_pole_fast(source, hp_period)
res = source - hp
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/dema.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
# Try to import the high-performance Rust implementation
try:
from jesse_rust import dema as dema_rust # type: ignore
except ImportError: # pragma: no cover
dema_rust = None # type: ignore
@njit(cache=True)
def _ema(x: np.ndarray, period: int) -> np.ndarray:
alpha = 2.0 / (period + 1)
n = len(x)
ema = np.empty(n, dtype=x.dtype)
ema[0] = x[0]
for i in range(1, n):
ema[i] = alpha * x[i] + (1 - alpha) * ema[i - 1]
return ema
def dema(candles: np.ndarray, period: int = 30, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
DEMA - Double Exponential Moving Average
:param candles: np.ndarray
:param period: int - default: 30
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Use Rust implementation if available
if dema_rust is not None:
# Convert to float64 for Rust compatibility
source_f64 = np.asarray(source, dtype=np.float64)
# Call the Rust implementation
result = dema_rust(source_f64, period)
return result if sequential else result[-1]
else:
# Fallback to Python implementation
return _dema_python(source, period, sequential)
def _dema_python(source: np.ndarray, period: int, sequential: bool) -> Union[float, np.ndarray]:
"""Python fallback implementation."""
ema = _ema(source, period)
ema_of_ema = _ema(ema, period)
res = 2 * ema - ema_of_ema
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/devstop.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import slice_candles
from jesse.indicators.mean_ad import mean_ad
from jesse.indicators.median_ad import median_ad
def devstop(candles: np.ndarray, period: int = 20, mult: float = 0, devtype: int = 0, direction: str = "long",
sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Kase Dev Stops
:param candles: np.ndarray
:param period: int - default: 20
:param mult: float - default: 0
:param devtype: int - default: 0
:param direction: str - default: long
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
AVTR = rolling_mean(rolling_max(high, 2) - rolling_min(low, 2), period)
if devtype == 0:
SD = rolling_std(rolling_max(high, 2) - rolling_min(low, 2), period)
elif devtype == 1:
SD = mean_ad(rolling_max(high, 2) - rolling_min(low, 2), period, sequential=True)
elif devtype == 2:
SD = median_ad(rolling_max(high, 2) - rolling_min(low, 2), period, sequential=True)
if direction == "long":
res = rolling_max(high - AVTR - mult * SD, period)
else:
res = rolling_min(low + AVTR + mult * SD, period)
return res if sequential else res[-1]
def rolling_max(arr, window):
if len(arr) < window:
return np.full(arr.shape, np.nan)
windows = sliding_window_view(arr, window)
res = np.empty(len(arr))
res[:window-1] = np.nan
res[window-1:] = np.max(windows, axis=1)
return res
def rolling_min(arr, window):
if len(arr) < window:
return np.full(arr.shape, np.nan)
windows = sliding_window_view(arr, window)
res = np.empty(len(arr))
res[:window-1] = np.nan
res[window-1:] = np.min(windows, axis=1)
return res
def rolling_mean(arr, window):
if len(arr) < window:
return np.full(arr.shape, np.nan)
windows = sliding_window_view(arr, window)
res = np.empty(len(arr))
res[:window-1] = np.nan
res[window-1:] = np.mean(windows, axis=1)
return res
def rolling_std(arr, window):
if len(arr) < window:
return np.full(arr.shape, np.nan)
windows = sliding_window_view(arr, window)
res = np.empty(len(arr))
res[:window-1] = np.nan
res[window-1:] = np.std(windows, axis=1, ddof=0)
return res
================================================
FILE: jesse/indicators/di.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
from jesse_rust import di as di_rust
DI = namedtuple('DI', ['plus', 'minus'])
def di(candles: np.ndarray, period: int = 14, sequential: bool = False) -> DI:
"""
DI - Directional Indicator
:param candles: np.ndarray, where columns are expected to be: index 2: close, index 3: high, index 4: low.
:param period: int - default: 14
:param sequential: bool - default: False
:return: DI(plus, minus)
"""
candles = slice_candles(candles, sequential)
n = len(candles)
if n < 2:
if sequential:
return DI(np.full(n, np.nan), np.full(n, np.nan))
else:
return DI(np.nan, np.nan)
# Use Rust implementation
plus_DI_arr, minus_DI_arr = di_rust(candles, period)
if sequential:
return DI(plus_DI_arr, minus_DI_arr)
else:
return DI(plus_DI_arr[-1], minus_DI_arr[-1])
================================================
FILE: jesse/indicators/dm.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
# Import the high-performance Rust implementation
from jesse_rust import dm as dm_rust # type: ignore
DM = namedtuple('DM', ['plus', 'minus'])
def dm(candles: np.ndarray, period: int = 14, sequential: bool = False) -> DM:
"""
DM - Directional Movement
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: DM(plus, minus)
"""
candles = slice_candles(candles, sequential)
# Convert to float64 for Rust compatibility
candles_f64 = np.asarray(candles, dtype=np.float64)
# Call the Rust implementation
plus, minus = dm_rust(candles_f64, period)
if sequential:
return DM(plus, minus)
else:
return DM(plus[-1], minus[-1])
================================================
FILE: jesse/indicators/donchian.py
================================================
from collections import namedtuple
import numpy as np
from jesse_rust import donchian as rust_donchian
from jesse.helpers import slice_candles
DonchianChannel = namedtuple('DonchianChannel', ['upperband', 'middleband', 'lowerband'])
def donchian(candles: np.ndarray, period: int = 20, sequential: bool = False) -> DonchianChannel:
"""
Donchian Channels
:param candles: np.ndarray
:param period: int - default: 20
:param sequential: bool - default: False
:return: DonchianChannel(upperband, middleband, lowerband)
"""
candles = slice_candles(candles, sequential)
if sequential:
# Use optimized Rust implementation
rust_result = rust_donchian(candles, period)
return DonchianChannel(
rust_result['upperband'],
rust_result['middleband'],
rust_result['lowerband']
)
else:
# Non-sequential mode only needs the very last value of the channel.
# Instead of calling the Rust implementation (which processes the
# entire candle history and incurs extra FFI overhead), we can obtain
# the same result in pure NumPy by looking at just the last `period`
# candles.
if candles.shape[0] < period:
# Not enough candles yet → behave exactly like the Rust variant
# which would return NaNs for the incomplete window.
return DonchianChannel(np.nan, np.nan, np.nan)
# Slice only the window we need.
window = candles[-period:]
# Candle columns: 0 -> timestamp, 1 -> open, 2 -> close, 3 -> high, 4 -> low
highs = window[:, 3]
lows = window[:, 4]
upper = highs.max()
lower = lows.min()
middle = (upper + lower) / 2
return DonchianChannel(upper, middle, lower)
================================================
FILE: jesse/indicators/dpo.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
from jesse.indicators.sma import sma
@njit
def _dpo(source, period, sma):
# Calculate the X/2 + 1 shift
shift = period // 2 + 1
# Shift the price series and subtract SMA
shifted_source = np.roll(source, shift)
dpo = shifted_source - sma
# First (period-1 + shift) elements will be invalid due to the rolling calculations
dpo[:period-1+shift] = np.nan
return dpo
def dpo(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
DPO - Detrended Price Oscillator
Formula: Price {X/2 + 1} periods ago less the X-period simple moving average
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
t_sma = sma(candles, period, source_type=source_type, sequential=True)
res = _dpo(source, period, t_sma)
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/dti.py
================================================
from typing import Union
import numpy as np
from numba import njit
import jesse.helpers as jh
from jesse.helpers import slice_candles
import jesse_rust as jr
@njit(cache=True)
def _ema(arr: np.ndarray, period: int) -> np.ndarray:
"""
Compute the exponential moving average (EMA) using a simple for loop, accelerated with numba.
The formula is: EMA[i] = sum_{j=0}^{i} (alpha * (1-alpha)**(i - j) * arr[j]) where alpha = 2/(period+1).
This is computed iteratively:
EMA[0] = alpha * arr[0]
EMA[i] = alpha * arr[i] + (1 - alpha) * EMA[i-1] for i >= 1
"""
alpha = 2.0 / (period + 1)
n = arr.shape[0]
result = np.empty(n, dtype=arr.dtype)
result[0] = alpha * arr[0]
for i in range(1, n):
result[i] = alpha * arr[i] + (1 - alpha) * result[i - 1]
return result
def dti(candles: np.ndarray, r: int = 14, s: int = 10, u: int = 5, sequential: bool = False) -> Union[float, np.ndarray]:
"""
DTI by William Blau calculated using Rust implementation for better performance.
:param candles: np.ndarray of candles data
:param r: period for the first EMA smoothing (default 14)
:param s: period for the second EMA smoothing (default 10)
:param u: period for the third EMA smoothing (default 5)
:param sequential: if True, returns the full sequence, otherwise only the last value
:return: float or np.ndarray of DTI values
"""
candles = slice_candles(candles, sequential)
# Use the Rust implementation
res = jr.dti(candles, r, s, u)
if sequential:
return res
else:
return None if np.isnan(res[-1]) else res[-1]
================================================
FILE: jesse/indicators/dx.py
================================================
from collections import namedtuple
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from jesse.indicators.rma import rma
from numba import njit
DX = namedtuple('DX', ['adx', 'plusDI', 'minusDI'])
@njit(cache=True)
def _fast_dm_tr(high: np.ndarray, low: np.ndarray, close: np.ndarray) -> tuple:
n = len(high)
up = np.zeros(n)
down = np.zeros(n)
plusDM = np.zeros(n)
minusDM = np.zeros(n)
true_range = np.zeros(n)
for i in range(n):
if i == 0:
up[i] = 0
down[i] = 0
plusDM[i] = 0
minusDM[i] = 0
true_range[i] = high[i] - low[i]
else:
up[i] = high[i] - high[i - 1]
down[i] = low[i - 1] - low[i]
plusDM[i] = up[i] if (up[i] > down[i] and up[i] > 0) else 0
minusDM[i] = down[i] if (down[i] > up[i] and down[i] > 0) else 0
a = high[i] - low[i]
b = abs(high[i] - close[i - 1])
c = abs(low[i] - close[i - 1])
true_range[i] = max(a, b, c)
return plusDM, minusDM, true_range
def dx(candles: np.ndarray, di_length: int = 14, adx_smoothing: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
DX - Directional Movement Index
:param candles: np.ndarray
:param di_length: int - default: 14
:param adx_smoothing: int - default: 14
:param sequential: bool - default: False
:return: DX(adx, plusDI, minusDI)
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
close = candles[:, 2]
plusDM, minusDM, true_range = _fast_dm_tr(high, low, close)
tr_rma = rma(true_range, di_length, sequential=True)
plus_rma = rma(plusDM, di_length, sequential=True)
minus_rma = rma(minusDM, di_length, sequential=True)
# Compute +DI and -DI, avoiding division by zero
plusDI = np.where(tr_rma == 0, 0, 100 * plus_rma / tr_rma)
minusDI = np.where(tr_rma == 0, 0, 100 * minus_rma / tr_rma)
di_sum = plusDI + minusDI
di_diff = np.abs(plusDI - minusDI)
directional_index = di_diff / np.where(di_sum == 0, 1, di_sum)
adx = 100 * rma(directional_index, adx_smoothing, sequential=True)
if sequential:
return DX(adx, plusDI, minusDI)
else:
return DX(adx[-1], plusDI[-1], minusDI[-1])
================================================
FILE: jesse/indicators/edcf.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def edcf(candles: np.ndarray, period: int = 15, source_type: str = "hl2", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Ehlers Distance Coefficient Filter
:param candles: np.ndarray
:param period: int - default: 15
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = edcf_fast(source, period)
return res if sequential else res[-1]
@njit(cache=True)
def edcf_fast(source, period):
newseries = np.full_like(source, np.nan)
for j in range(2 * period, source.shape[0]):
num = 0.0
coefSum = 0.0
for i in range(period):
distance = 0.0
for lb in range(1, period):
distance += np.power(source[j - i] - source[j - i - lb], 2)
num += distance * source[j - i]
coefSum += distance
newseries[j] = num / coefSum if coefSum != 0 else 0
return newseries
================================================
FILE: jesse/indicators/efi.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
def efi(candles: np.ndarray, period: int = 13, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
EFI - Elders Force Index
:param candles: np.ndarray
:param period: int - default: 13
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
dif = efi_fast(source, candles[:, 5])
res = ema(dif, period)
res_with_nan = same_length(candles, res)
return res_with_nan if sequential else res_with_nan[-1]
@njit(cache=True)
def efi_fast(source, volume):
dif = np.zeros(source.size - 1)
for i in range(1, source.size):
dif[i - 1] = (source[i] - source[i - 1]) * volume[i]
return dif
@njit(cache=True)
def ema(data: np.ndarray, period: int) -> np.ndarray:
n = data.shape[0]
# Initialize output array and fill with NaN
out = np.empty(n)
for i in range(n):
out[i] = np.nan
if n < period:
return out
alpha = 2.0 / (period + 1)
# Compute seed as the simple average of the first 'period' values
sum_value = 0.0
for i in range(period):
sum_value += data[i]
ema_val = sum_value / period
out[period - 1] = ema_val
# Recursively compute EMA for the rest of the data
for i in range(period, n):
ema_val = alpha * data[i] + (1 - alpha) * ema_val
out[i] = ema_val
return out
================================================
FILE: jesse/indicators/ema.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import ema as ema_rust
def ema(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
EMA - Exponential Moving Average using Numba for optimization
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
result = ema_rust(source, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/emd.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.indicators.sma import sma
from jesse.helpers import slice_candles
EMD = namedtuple('EMD', ['upperband', 'middleband', 'lowerband'])
def emd(candles: np.ndarray, period: int = 20, delta=0.5, fraction=0.1, sequential: bool = False) -> EMD:
"""
Empirical Mode Decomposition by John F. Ehlers and Ric Way
:param candles: np.ndarray
:param period: int - default: 20
:param delta: float - default: 0.5
:param fraction: float - default: 0.1
:param sequential: bool - default: False
:return: EMD(upperband, middleband, lowerband)
"""
candles = slice_candles(candles, sequential)
price = (candles[:, 3] + candles[:, 4]) / 2
bp = bp_fast(price, period, delta)
mean = sma(bp, 2 * period, sequential=True)
peak, valley = peak_valley_fast(bp, price)
avg_peak = fraction * sma(peak, 50, sequential=True)
avg_valley = fraction * sma(valley, 50, sequential=True)
if sequential:
return EMD(avg_peak, mean, avg_valley)
else:
return EMD(avg_peak[-1], mean[-1], avg_valley[-1])
@njit(cache=True)
def bp_fast(price, period, delta):
# bandpass filter
beta = np.cos(2 * np.pi / period)
gamma = 1 / np.cos(4 * np.pi * delta / period)
alpha = gamma - np.sqrt(gamma * gamma - 1)
bp = np.zeros_like(price)
for i in range(price.shape[0]):
if i > 2:
bp[i] = 0.5 * (1 - alpha) * (price[i] - price[i - 2]) + beta * (1 + alpha) * bp[i - 1] - alpha * bp[i - 2]
else:
bp[i] = 0.5 * (1 - alpha) * (price[i] - price[i - 2])
return bp
@njit(cache=True)
def peak_valley_fast(bp, price):
peak = np.copy(bp)
valley = np.copy(bp)
for i in range(price.shape[0]):
peak[i] = peak[i - 1]
valley[i] = valley[i - 1]
if i > 2:
if bp[i - 1] > bp[i] and bp[i - 1] > bp[i - 2]:
peak[i] = bp[i - 1]
if bp[i - 1] < bp[i] and bp[i - 1] < bp[i - 2]:
valley[i] = bp[i - 1]
return peak, valley
================================================
FILE: jesse/indicators/emv.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import same_length, slice_candles
from jesse.indicators import sma
@njit
def _emv(high: np.ndarray, low: np.ndarray, volume: np.ndarray, length, div) -> np.ndarray:
hl2 = (high + low) / 2
hl2_change = np.zeros_like(hl2)
hl2_change[1:] = hl2[1:] - hl2[:-1]
# Calculate EMV
emv_raw = div * hl2_change * (high - low) / volume
# Calculate SMA of EMV
result = np.zeros_like(emv_raw)
for i in range(length - 1, len(emv_raw)):
result[i] = np.mean(emv_raw[i - length + 1:i + 1])
return result
def emv(candles: np.ndarray, length: int = 14, div: int = 10000, sequential: bool = False) -> Union[float, np.ndarray]:
"""
EMV - Ease of Movement
:param candles: np.ndarray
:param length: int - default: 14
:param div: int - default: 10000
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
volume = candles[:, 5]
res = _emv(high, low, volume, length, div)
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/epma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def epma(candles: np.ndarray, period: int = 11, offset: int = 4, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
End Point Moving Average
:param candles: np.ndarray
:param period: int - default: 14
:param offset: int - default: 4
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = epma_fast(source, period, offset)
return res if sequential else res[-1]
@njit(cache=True)
def epma_fast(source, period, offset):
newseries = np.copy(source)
for j in range(period + offset + 1 , source.shape[0]):
my_sum = 0.0
weightSum = 0.0
for i in range(period - 1):
weight = period - i - offset
my_sum += (source[j - i] * weight)
weightSum += weight
newseries[j] = 1 / weightSum * my_sum
return newseries
================================================
FILE: jesse/indicators/er.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import get_candle_source, same_length, slice_candles
def er(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
ER - The Kaufman Efficiency indicator
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
change = np.abs(np.diff(source, period))
abs_dif = np.abs(np.diff(source))
swv = sliding_window_view(abs_dif, window_shape=period)
volatility = swv.sum()
res = change / volatility
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/eri.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse.indicators.ma import ma
ERI = namedtuple('ERI', ['bull', 'bear'])
def eri(candles: np.ndarray, period: int = 13, matype: int = 1, source_type: str = "close",
sequential: bool = False) -> ERI:
"""
Elder Ray Index (ERI)
:param candles: np.ndarray
:param period: int - default: 13
:param matype: int - default: 1
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if matype == 24 or matype == 29:
ema = ma(candles, period=period, matype=matype, source_type=source_type, sequential=True)
else:
ema = ma(source, period=period, matype=matype, sequential=True)
bull = candles[:, 3] - ema
bear = candles[:, 4] - ema
if sequential:
return ERI(bull, bear)
else:
return ERI(bull[-1], bear[-1])
================================================
FILE: jesse/indicators/fisher.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import same_length, slice_candles
FisherTransform = namedtuple('FisherTransform', ['fisher', 'signal'])
@njit
def _fisher_transform(high: np.ndarray, low: np.ndarray, period: int) -> tuple:
"""
Numba-optimized implementation of Fisher Transform
"""
length = len(high)
mid_price = (high + low) / 2
fisher = np.zeros(length)
fisher_signal = np.zeros(length)
# Initialize first value
value1 = 0.0
for i in range(period, length):
# Find the highest high and lowest low in the period
max_h = np.max(mid_price[i-period+1:i+1])
min_l = np.min(mid_price[i-period+1:i+1])
# Avoid division by zero
if max_h - min_l == 0:
value0 = 0
else:
value0 = 0.33 * 2 * ((mid_price[i] - min_l) / (max_h - min_l) - 0.5) + 0.67 * value1
if value0 > 0.99:
value0 = 0.999
elif value0 < -0.99:
value0 = -0.999
fisher[i] = 0.5 * np.log((1 + value0) / (1 - value0)) + 0.5 * fisher[i-1]
fisher_signal[i] = fisher[i-1]
value1 = value0
return fisher, fisher_signal
def fisher(candles: np.ndarray, period: int = 9, sequential: bool = False) -> FisherTransform:
"""
The Fisher Transform helps identify price reversals.
:param candles: np.ndarray
:param period: int - default: 9
:param sequential: bool - default: False
:return: FisherTransform(fisher, signal)
"""
candles = slice_candles(candles, sequential)
fisher_val, fisher_signal = _fisher_transform(
np.ascontiguousarray(candles[:, 3]),
np.ascontiguousarray(candles[:, 4]),
period
)
if sequential:
return FisherTransform(same_length(candles, fisher_val), same_length(candles, fisher_signal))
else:
return FisherTransform(fisher_val[-1], fisher_signal[-1])
================================================
FILE: jesse/indicators/fosc.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, same_length, slice_candles
from numba import njit
@njit
def linear_regression_line(x, y):
n = len(x)
sum_x = np.sum(x)
sum_y = np.sum(y)
sum_xy = np.sum(x * y)
sum_xx = np.sum(x * x)
slope = (n * sum_xy - sum_x * sum_y) / (n * sum_xx - sum_x * sum_x)
intercept = (sum_y - slope * sum_x) / n
return slope * x + intercept
def fosc(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
FOSC - Forecast Oscillator
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Prepare the result array
res = np.zeros_like(source)
# Calculate FOSC for each window
for i in range(period - 1, len(source)):
window = source[i - period + 1:i + 1]
x = np.arange(period)
predicted = linear_regression_line(x, window)
res[i] = 100 * (window[-1] - predicted[-1]) / window[-1]
# Replace initial NaN values with 0
res[:period - 1] = 0
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/frama.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import slice_candles
def frama(candles: np.ndarray, window: int = 10, FC: int = 1, SC: int = 300, sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Fractal Adaptive Moving Average (FRAMA)
:param candles: np.ndarray
:param window: int - default: 10
:param FC: int - default: 1
:param SC: int - default: 300
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
n = window
# n must be even
if n % 2 == 1:
print("FRAMA n must be even. Adding one")
n += 1
res = frame_fast(candles, n, SC, FC)
if sequential:
return res
else:
return res[-1]
@njit(cache=True)
def frame_fast(candles, n, SC, FC):
w = np.log(2.0 / (SC + 1))
D = np.zeros(candles.size)
D[:n] = np.NaN
alphas = np.zeros(candles.size)
alphas[:n] = np.NaN
for i in range(n, candles.shape[0]):
per = candles[i - n:i]
v1 = per[per.shape[0] // 2:]
v2 = per[:per.shape[0] // 2]
N1 = (max(v1[:, 3]) - min(v1[:, 4])) / (n / 2)
N2 = (max(v2[:, 3]) - min(v2[:, 4])) / (n / 2)
N3 = (max(per[:, 3]) - min(per[:, 4])) / n
if N1 > 0 and N2 > 0 and N3 > 0:
D[i] = (np.log(N1 + N2) - np.log(N3)) / np.log(2)
else:
D[i] = D[i - 1]
oldalpha = np.exp(w * (D[i] - 1))
# keep btwn 1 & 0.01
oldalpha = max([oldalpha, 0.1])
oldalpha = min([oldalpha, 1])
oldN = (2 - oldalpha) / oldalpha
N = ((SC - FC) * ((oldN - 1) / (SC - 1))) + FC
alpha_ = 2 / (N + 1)
if alpha_ < 2 / (SC + 1):
alphas[i] = 2 / (SC + 1)
elif alpha_ > 1:
alphas[i] = 1
else:
alphas[i] = alpha_
frama_val = np.zeros(candles.shape[0])
frama_val[n - 1] = np.mean(candles[:, 2][:n])
frama_val[:n - 1] = np.NaN
for i in range(n, frama_val.shape[0]):
frama_val[i] = (alphas[i] * candles[:, 2][i]) + (1 - alphas[i]) * frama_val[i - 1]
return frama_val
================================================
FILE: jesse/indicators/fwma.py
================================================
from math import fabs
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import get_candle_source, same_length, slice_candles
def fwma(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Fibonacci's Weighted Moving Average (FWMA)
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
fibs = fibonacci(n=period)
swv = sliding_window_view(source, window_shape=period)
res = np.average(swv, weights=fibs, axis=-1)
return same_length(candles, res) if sequential else res[-1]
def fibonacci(n: int = 2) -> np.ndarray:
"""Fibonacci Sequence as a numpy array"""
n = int(fabs(n)) if n >= 0 else 2
n -= 1
a, b = 1, 1
result = np.array([a])
for _ in range(n):
a, b = b, a + b
result = np.append(result, a)
fib_sum = np.sum(result)
if fib_sum > 0:
return result / fib_sum
else:
return result
================================================
FILE: jesse/indicators/gatorosc.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import get_candle_source, np_shift, slice_candles
GATOR = namedtuple('GATOR', ['upper', 'lower', 'upper_change', 'lower_change'])
def gatorosc(candles: np.ndarray, source_type: str = "close", sequential: bool = False) -> GATOR:
"""
Gator Oscillator by Bill M. Williams
:param candles: np.ndarray
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: GATOR(upper, lower, upper_change, lower_change)
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
jaw = np_shift(numpy_ewma(source, 13), 8, fill_value=np.nan)
teeth = np_shift(numpy_ewma(source, 8), 5, fill_value=np.nan)
lips = np_shift(numpy_ewma(source, 5), 3, fill_value=np.nan)
upper = np.abs(jaw - teeth)
lower = -np.abs(teeth - lips)
# Calculate momentum for upper: difference from previous value, first element is np.nan
upper_change = np.empty_like(upper)
upper_change[0] = np.nan
upper_change[1:] = np.diff(upper)
# Calculate momentum for lower: negative difference from previous value, first element is np.nan
lower_change = np.empty_like(lower)
lower_change[0] = np.nan
lower_change[1:] = -np.diff(lower)
if sequential:
return GATOR(upper, lower, upper_change, lower_change)
else:
return GATOR(upper[-1], lower[-1], upper_change[-1], lower_change[-1])
def numpy_ewma(data, window):
"""
:param data:
:param window:
:return:
"""
alpha = 1 / window
# scale = 1 / (1 - alpha)
n = data.shape[0]
scale_arr = (1 - alpha) ** (-1 * np.arange(n))
weights = (1 - alpha) ** np.arange(n)
pw0 = (1 - alpha) ** (n - 1)
mult = data * pw0 * scale_arr
cumsums = mult.cumsum()
return cumsums * scale_arr[::-1] / weights.cumsum()
================================================
FILE: jesse/indicators/gauss.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def gauss(candles: np.ndarray, period: int = 14, poles: int = 4, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
Gaussian Filter
:param candles: np.ndarray
:param period: int - default: 14
:param poles: int - default: 4
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
fil, to_fill = gauss_fast(source, period, poles)
if to_fill != 0:
res = np.insert(fil[poles:], 0, np.repeat(np.nan, to_fill))
else:
res = fil[poles:]
return res if sequential else res[-1]
@njit(cache=True)
def gauss_fast(source, period, poles):
N = source.size
source = source[~np.isnan(source)]
to_fill = N - source.size
PI = np.pi
beta = (1 - np.cos(2 * PI / period)) / (np.power(2, 1 / poles) - 1)
alpha = -beta + np.sqrt(np.power(beta, 2) + 2 * beta)
fil = np.zeros(poles + source.size)
if poles == 1:
coeff = np.array([alpha, (1 - alpha)])
elif poles == 2:
coeff = np.array([alpha ** 2, 2 * (1 - alpha), -(1 - alpha) ** 2])
elif poles == 3:
coeff = np.array([alpha ** 3, 3 * (1 - alpha), -3 * (1 - alpha) ** 2, (1 - alpha) ** 3])
elif poles == 4:
coeff = np.array([alpha ** 4, 4 * (1 - alpha), -6 * (1 - alpha) ** 2, 4 * (1 - alpha) ** 3, -(1 - alpha) ** 4])
for i in range(source.size):
if poles == 1:
val = np.array([source[i].item(), fil[i]])
elif poles == 2:
val = np.array([source[i].item(), fil[1 + i], fil[i]])
elif poles == 3:
val = np.array([source[i].item(), fil[2 + i], fil[1 + i], fil[i]])
elif poles == 4:
val = np.array([source[i].item(), fil[3 + i], fil[2 + i], fil[1 + i], fil[i]])
fil[poles + i] = np.dot(coeff, val)
return fil, to_fill
================================================
FILE: jesse/indicators/heikin_ashi_candles.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import slice_candles
HA = namedtuple('HA', ['open', 'close', 'high', 'low'])
def heikin_ashi_candles(candles: np.ndarray, sequential: bool = False) -> HA:
"""
Heikin Ashi Candles
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
source = slice_candles(candles, sequential)
# Just pick the OPEN,CLOSE,HIGH,LOW Columns from the candles
open, close, high, low = ha_fast(source[:,[1,2,3,4]])
if sequential:
return HA(open, close, high, low)
else:
return HA(open[-1], close[-1], high[-1], low[-1])
@njit(cache=True)
def ha_fast(source):
# index consts to facilitate reading the code
OPEN = 0
CLOSE = 1
HIGH = 2
LOW = 3
# init array
ha_candles = np.full_like(source, np.nan)
for i in range(1,ha_candles.shape[0]):
# https://www.investopedia.com/trading/heikin-ashi-better-candlestick/
#
ha_candles[i][OPEN] = (source[i-1][OPEN]+source[i-1][CLOSE])/2
ha_candles[i][CLOSE] = (source[i][OPEN]+source[i][CLOSE]+source[i][HIGH]+source[i][LOW])/4
# Using builtins Python min,max and not numpy one since we get this Error:
# No implementation of function Function() found for signature:
# Still fast since numba supports it
ha_candles[i][HIGH] = max([source[i][HIGH], ha_candles[i][OPEN], ha_candles[i][CLOSE]])
ha_candles[i][LOW] = min([source[i][LOW], ha_candles[i][OPEN], ha_candles[i][CLOSE]])
return ha_candles[:,OPEN], ha_candles[:,CLOSE], ha_candles[:,HIGH], ha_candles[:,LOW]
================================================
FILE: jesse/indicators/high_pass.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def high_pass(candles: np.ndarray, period: int = 48, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
(1 pole) high-pass filter indicator by John F. Ehlers
:param candles: np.ndarray
:param period: int - default: 48
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
hpf = high_pass_fast(source, period)
if sequential:
return hpf
else:
return None if np.isnan(hpf[-1]) else hpf[-1]
@njit(cache=True)
def high_pass_fast(source, period): # Function is compiled to machine code when called the first time
k = 1
alpha = 1 + (np.sin(2 * np.pi * k / period) - 1) / np.cos(2 * np.pi * k / period)
newseries = np.copy(source)
for i in range(1, source.shape[0]):
newseries[i] = (1 - alpha / 2) * source[i] - (1 - alpha / 2) * source[i - 1] \
+ (1 - alpha) * newseries[i - 1]
return newseries
================================================
FILE: jesse/indicators/high_pass_2_pole.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def high_pass_2_pole(candles: np.ndarray, period: int = 48, source_type: str = "close", sequential: bool = False) -> \
Union[
float, np.ndarray]:
"""
(2 pole) high-pass filter indicator by John F. Ehlers
:param candles: np.ndarray
:param period: int - default: 48
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
hpf = high_pass_2_pole_fast(source, period)
if sequential:
return hpf
else:
return None if np.isnan(hpf[-1]) else hpf[-1]
@njit(cache=True)
def high_pass_2_pole_fast(source, period, K=0.707): # Function is compiled to machine code when called the first time
alpha = 1 + (np.sin(2 * np.pi * K / period) - 1) / np.cos(2 * np.pi * K / period)
newseries = np.copy(source)
for i in range(2, source.shape[0]):
newseries[i] = (1 - alpha / 2) ** 2 * source[i] \
- 2 * (1 - alpha / 2) ** 2 * source[i - 1] \
+ (1 - alpha / 2) ** 2 * source[i - 2] \
+ 2 * (1 - alpha) * newseries[i - 1] - (1 - alpha) ** 2 * newseries[i - 2]
return newseries
================================================
FILE: jesse/indicators/hma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
@njit
def _wma(arr: np.ndarray, period: int) -> np.ndarray:
"""
Weighted Moving Average - optimized with Numba
"""
weights = np.arange(1, period + 1)
wma = np.zeros_like(arr)
for i in range(period - 1, len(arr)):
wma[i] = np.sum(arr[i - period + 1:i + 1] * weights) / np.sum(weights)
return wma
def hma(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
Hull Moving Average
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Calculate components for HMA
half_length = int(period / 2)
sqrt_length = int(np.sqrt(period))
# Calculate WMAs
wma_half = _wma(source, half_length)
wma_full = _wma(source, period)
# Calculate 2 * WMA(n/2) - WMA(n)
raw_hma = 2 * wma_half - wma_full
# Calculate final HMA
hma = _wma(raw_hma, sqrt_length)
return same_length(candles, hma) if sequential else hma[-1]
================================================
FILE: jesse/indicators/hull_suit.py
================================================
from collections import namedtuple
from .wma import wma
from .ema import ema
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
HullSuit = namedtuple('HullSuit', ['s_hull', 'm_hull', 'signal'])
def hull_suit(candles: np.ndarray, mode_switch: str = 'Hma', length: int = 55, length_mult: float = 1.0, source_type: str = 'close', sequential: bool = False) -> HullSuit:
"""
@author InSilico
credits: https://www.tradingview.com/script/hg92pFwS-Hull-Suite/
HullSuit - Hull Suit
:param candles: np.ndarray
:param mode_switch: str - default: 'Hma'
:param length: int - default: 55
:param length_mult: float - default: 1.0
:param source_type: str - default: "closes"
:param sequential: bool - default=False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
mode_len = int(length * length_mult)
if mode_switch == 'Hma':
mode = wma(2*wma(source, int(mode_len / 2), sequential=True) - wma(source, mode_len, sequential=True), round(mode_len ** 0.5), sequential=True)
elif mode_switch == 'Ehma':
mode = ema(2*ema(source, int(mode_len / 2), sequential=True) - ema(source,
mode_len, sequential=True), round(mode_len ** 0.5), sequential=True)
elif mode_switch == 'Thma':
mode = wma(3*wma(source, int(mode_len / 6), sequential=True) - wma(source, int(mode_len / 4), sequential=True) -
wma(source, int(mode_len / 2), sequential=True), int(mode_len / 2), sequential=True)
# Vectorized computation for s_hull, m_hull, and signal
n = len(mode)
s_hull = np.full(n, None, dtype=object)
m_hull = np.full(n, None, dtype=object)
signal = np.full(n, None, dtype=object)
if n > 2:
s_hull[2:] = mode[:-2]
m_hull[2:] = mode[2:]
signal[2:] = np.where(mode[:-2] < mode[2:], 'buy', 'sell')
if sequential:
return HullSuit(s_hull, m_hull, signal)
else:
return HullSuit(s_hull[-1], m_hull[-1], signal[-1])
================================================
FILE: jesse/indicators/hurst_exponent.py
================================================
import numpy as np
from numba import njit
from scipy import signal
from jesse.helpers import get_candle_source, slice_candles
def hurst_exponent(candles: np.ndarray, min_chunksize: int = 8, max_chunksize: int = 200, num_chunksize:int=5, method:int=1, source_type: str = "close") -> float:
"""
Hurst Exponent
:param candles: np.ndarray
:param min_chunksize: int - default: 8
:param max_chunksize: int - default: 200
:param num_chunksize: int - default: 5
:param method: int - default: 1 - 0: RS | 1: DMA | 2: DSOD
:param source_type: str - default: "close"
:return: float
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, False)
source = get_candle_source(candles, source_type=source_type)
if method == 0:
h = hurst_rs(np.diff(source), min_chunksize, max_chunksize, num_chunksize)
elif method == 1:
h = hurst_dma(source, min_chunksize, max_chunksize, num_chunksize)
elif method == 2:
h = hurst_dsod(source)
else:
raise NotImplementedError('The method choose is not implemented.')
return None if np.isnan(h) else h
@njit(cache=True)
def hurst_rs(x, min_chunksize, max_chunksize, num_chunksize):
"""Estimate the Hurst exponent using R/S method.
Estimates the Hurst (H) exponent using the R/S method from the time series.
The R/S method consists of dividing the series into pieces of equal size
`series_len` and calculating the rescaled range. This repeats the process
for several `series_len` values and adjusts data regression to obtain the H.
`series_len` will take values between `min_chunksize` and `max_chunksize`,
the step size from `min_chunksize` to `max_chunksize` can be controlled
through the parameter `step_chunksize`.
Parameters
----------
x : 1D-array
A time series to calculate hurst exponent, must have more elements
than `min_chunksize` and `max_chunksize`.
min_chunksize : int
This parameter allow you control the minimum window size.
max_chunksize : int
This parameter allow you control the maximum window size.
num_chunksize : int
This parameter allow you control the size of the step from minimum to
maximum window size. Bigger step means fewer calculations.
out : 1-element-array, optional
one element array to store the output.
Returns
-------
H : float
A estimation of Hurst exponent.
References
----------
Hurst, H. E. (1951). Long term storage capacity of reservoirs. ASCE
Transactions, 116(776), 770-808.
Alessio, E., Carbone, A., Castelli, G. et al. Eur. Phys. J. B (2002) 27:
197. http://dx.doi.org/10.1140/epjb/e20020150
"""
N = len(x)
max_chunksize += 1
rs_tmp = np.empty(N, dtype=np.float64)
chunk_size_list = np.linspace(min_chunksize, max_chunksize, num_chunksize) \
.astype(np.int64)
rs_values_list = np.empty(num_chunksize, dtype=np.float64)
# 1. The series is divided into chunks of chunk_size_list size
for i in range(num_chunksize):
chunk_size = chunk_size_list[i]
# 2. it iterates on the indices of the first observation of each chunk
number_of_chunks = int(len(x) / chunk_size)
for idx in range(number_of_chunks):
# next means no overlapping
# convert index to index selection of each chunk
ini = idx * chunk_size
end = ini + chunk_size
chunk = x[ini:end]
# 2.1 Calculate the RS (chunk_size)
z = np.cumsum(chunk - np.mean(chunk))
rs_tmp[idx] = np.divide(
np.max(z) - np.min(z), # range
np.nanstd(chunk) # standar deviation
)
# 3. Average of RS(chunk_size)
rs_values_list[i] = np.nanmean(rs_tmp[:idx + 1])
# 4. calculate the Hurst exponent.
H, c = np.linalg.lstsq(
a=np.vstack((np.log(chunk_size_list), np.ones(num_chunksize))).T,
b=np.log(rs_values_list)
)[0]
return H
def hurst_dma(prices, min_chunksize=8, max_chunksize=200, num_chunksize=5):
"""Estimate the Hurst exponent using R/S method.
Estimates the Hurst (H) exponent using the DMA method from the time series.
The DMA method consists on calculate the moving average of size `series_len`
and subtract it to the original series and calculating the standard
deviation of that result. This repeats the process for several `series_len`
values and adjusts data regression to obtain the H. `series_len` will take
values between `min_chunksize` and `max_chunksize`, the step size from
`min_chunksize` to `max_chunksize` can be controlled through the parameter
`step_chunksize`.
Parameters
----------
prices
min_chunksize
max_chunksize
num_chunksize
Returns
-------
hurst_exponent : float
Estimation of hurst exponent.
References
----------
Alessio, E., Carbone, A., Castelli, G. et al. Eur. Phys. J. B (2002) 27:
197. https://dx.doi.org/10.1140/epjb/e20020150
"""
max_chunksize += 1
N = len(prices)
n_list = np.arange(min_chunksize, max_chunksize, num_chunksize, dtype=np.int64)
dma_list = np.empty(len(n_list))
factor = 1 / (N - max_chunksize)
# sweeping n_list
for i, n in enumerate(n_list):
b = np.divide([n - 1] + (n - 1) * [-1], n) # do the same as: y - y_ma_n
noise = np.power(signal.lfilter(b, 1, prices)[max_chunksize:], 2)
dma_list[i] = np.sqrt(factor * np.sum(noise))
H, const = np.linalg.lstsq(
a=np.vstack([np.log10(n_list), np.ones(len(n_list))]).T,
b=np.log10(dma_list), rcond=None
)[0]
return H
def hurst_dsod(x):
"""Estimate Hurst exponent on data timeseries.
The estimation is based on the discrete second order derivative. Consists on
get two different noise of the original series and calculate the standard
deviation and calculate the slope of two point with that values.
source: https://gist.github.com/wmvanvliet/d883c3fe1402c7ced6fc
Parameters
----------
x : numpy array
time series to estimate the Hurst exponent for.
Returns
-------
h : float
The estimation of the Hurst exponent for the given time series.
References
----------
Istas, J.; G. Lang (1994), “Quadratic variations and estimation of the local
Hölder index of data Gaussian process,” Ann. Inst. Poincaré, 33, pp. 407–436.
Notes
-----
This hurst_ets is data literal traduction of wfbmesti.m of waveleet toolbox
from matlab.
"""
y = np.cumsum(np.diff(x, axis=0), axis=0)
# second order derivative
b1 = [1, -2, 1]
y1 = signal.lfilter(b1, 1, y, axis=0)
y1 = y1[len(b1) - 1:] # first values contain filter artifacts
# wider second order derivative
b2 = [1, 0, -2, 0, 1]
y2 = signal.lfilter(b2, 1, y, axis=0)
y2 = y2[len(b2) - 1:] # first values contain filter artifacts
s1 = np.mean(y1 ** 2, axis=0)
s2 = np.mean(y2 ** 2, axis=0)
return 0.5 * np.log2(s2 / s1)
================================================
FILE: jesse/indicators/hwma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
def hwma(candles: np.ndarray, na: float = 0.2, nb: float = 0.1, nc: float = 0.1, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Holt-Winter Moving Average
:param candles: np.ndarray
:param na: float - default: 0.2
:param nb: float - default: 0.1
:param nc: float - default: 0.1
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if not ((0 < na < 1) or (0 < nb < 1) or (0 < nc < 1)):
raise ValueError("Bad parameters. They have to be: 0 < na nb nc < 1")
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
source_without_nan = source[~np.isnan(source)]
res = hwma_fast(source_without_nan, na, nb, nc)
res = same_length(candles, res)
return res if sequential else res[-1]
@njit(cache=True)
def hwma_fast(source, na, nb, nc):
last_a = last_v = 0
last_f = source[0]
newseries = np.copy(source)
for i in range(source.size):
F = (1.0 - na) * (last_f + last_v + 0.5 * last_a) + na * source[i]
V = (1.0 - nb) * (last_v + last_a) + nb * (F - last_f)
A = (1.0 - nc) * last_a + nc * (V - last_v)
newseries[i] = F + V + 0.5 * A
last_a, last_f, last_v = A, F, V # update values
return newseries
================================================
FILE: jesse/indicators/ichimoku_cloud.py
================================================
from collections import namedtuple
import numpy as np
from jesse_rust import ichimoku_cloud as ichimoku_cloud_rust
IchimokuCloud = namedtuple('IchimokuCloud', ['conversion_line', 'base_line', 'span_a', 'span_b'])
def ichimoku_cloud(candles: np.ndarray, conversion_line_period: int = 9, base_line_period: int = 26,
lagging_line_period: int = 52, displacement: int = 26) -> IchimokuCloud:
"""
Ichimoku Cloud
:param candles: np.ndarray
:param conversion_line_period: int - default: 9
:param base_line_period: int - default: 26
:param lagging_line_period: int - default: 52
:param displacement: - default: 26
:return: IchimokuCloud(conversion_line, base_line, span_a, span_b)
"""
if candles.shape[0] < 80:
return IchimokuCloud(np.nan, np.nan, np.nan, np.nan)
if candles.shape[0] > 80:
candles = candles[-80:]
conversion_line, base_line, span_a, span_b = ichimoku_cloud_rust(
candles, conversion_line_period, base_line_period,
lagging_line_period, displacement
)
return IchimokuCloud(conversion_line, base_line, span_a, span_b)
================================================
FILE: jesse/indicators/ichimoku_cloud_seq.py
================================================
from collections import namedtuple
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import np_shift, slice_candles
IchimokuCloud = namedtuple('IchimokuCloud',
['conversion_line', 'base_line', 'span_a', 'span_b', 'lagging_line', 'future_span_a',
'future_span_b'])
def ichimoku_cloud_seq(candles: np.ndarray, conversion_line_period: int = 9, base_line_period: int = 26,
lagging_line_period: int = 52, displacement: int = 26,
sequential: bool = False) -> IchimokuCloud:
"""
Ichimoku Cloud
:param candles: np.ndarray
:param conversion_line_period: int - default: 9
:param base_line_period: int - default: 26
:param lagging_line_period: int - default: 52
:param displacement: - default: 26
:param sequential: bool - default: False
:return: IchimokuCloud
"""
if candles.shape[0] < lagging_line_period + displacement:
raise ValueError("Too few candles available for lagging_line_period + displacement.")
candles = slice_candles(candles, sequential)
conversion_line = _line_helper(candles, conversion_line_period)
base_line = _line_helper(candles, base_line_period)
span_b_pre = _line_helper(candles, lagging_line_period)
span_b = np_shift(span_b_pre, displacement, fill_value=np.nan)
span_a_pre = (conversion_line + base_line) / 2
span_a = np_shift(span_a_pre, displacement, fill_value=np.nan)
lagging_line = np_shift(candles[:, 2], displacement - 1, fill_value=np.nan)
if sequential:
return IchimokuCloud(conversion_line, base_line, span_a, span_b, lagging_line, span_a_pre, span_b_pre)
else:
return IchimokuCloud(conversion_line[-1], base_line[-1], span_a[-1], span_b[-1], lagging_line[-1],
span_a_pre[-1], span_b_pre[-1])
def _line_helper(candles, period):
small_ph = _rolling_max(candles[:, 3], period)
small_pl = _rolling_min(candles[:, 4], period)
return (small_ph + small_pl) / 2
def _rolling_max(a, period):
n = len(a)
if n < period:
return np.full(n, np.nan)
windows = sliding_window_view(a, window_shape=period)
r = np.empty(n, dtype=a.dtype)
r[:period-1] = np.nan
r[period-1:] = np.max(windows, axis=-1)
return r
def _rolling_min(a, period):
n = len(a)
if n < period:
return np.full(n, np.nan)
windows = sliding_window_view(a, window_shape=period)
r = np.empty(n, dtype=a.dtype)
r[:period-1] = np.nan
r[period-1:] = np.min(windows, axis=-1)
return r
================================================
FILE: jesse/indicators/ift_rsi.py
================================================
from typing import Union
from jesse.indicators.wma import wma
from jesse.indicators.rsi import rsi
import numpy as np
from jesse.helpers import get_candle_source, same_length, slice_candles
def ift_rsi(candles: np.ndarray, rsi_period: int = 5, wma_period: int =9, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Modified Inverse Fisher Transform applied on RSI
:param candles: np.ndarray
:param rsi_period: int - default: 5
:param wma_period: int - default: 9
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
v1 = 0.1 * (rsi(source, rsi_period, sequential=True) - 50)
v2 = wma(v1, wma_period, sequential=True)
res = (((2*v2) ** 2 - 1) / ((2*v2) ** 2 + 1))
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/itrend.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
ITREND = namedtuple('ITREND', ['signal', 'it', 'trigger'])
def itrend(candles: np.ndarray, alpha: float = 0.07, source_type: str = "hl2", sequential: bool = False) -> ITREND:
"""
Instantaneous Trendline
:param candles: np.ndarray
:param alpha: float - default: 0.07
:param source_type: str - default: "hl2"
:param sequential: bool - default: False
:return: ITREND(signal, it, trigger)
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
signal, it, trigger = itrend_fast(source, alpha)
if sequential:
return ITREND(signal, it, trigger)
else:
return ITREND(signal[-1], it[-1], trigger[-1])
@njit(cache=True)
def itrend_fast(source, alpha):
it = np.copy(source)
for i in range(2, 7):
it[i] = (source[i] + 2 * source[i - 1] + source[i - 2]) / 4
for i in range(7, source.shape[0]):
it[i] = (alpha - alpha ** 2 / 4) * source[i] \
+ alpha ** 2 / 2 * source[i - 1] \
- (alpha - alpha ** 2 * 3 / 4) * source[i - 2] \
+ 2 * (1 - alpha) * it[i - 1] - (1 - alpha) ** 2 * it[i - 2]
# compute lead 2 trigger & signal
lag2 = np.roll(it, 20)
lag2[:20] = it[:20]
trigger = 2 * it - lag2
signal = (trigger > it) * 1 - (trigger < it) * 1
return signal, it, trigger
================================================
FILE: jesse/indicators/jma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def jma(candles: np.ndarray, period:int=7, phase:float=50, power:int=2, source_type:str='close', sequential:bool=False) -> Union[
float, np.ndarray]:
"""
Jurik Moving Average
Port of: https://tradingview.com/script/nZuBWW9j-Jurik-Moving-Average/
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
phaseRatio = 0.5 if phase < -100 else (2.5 if phase > 100 else phase / 100 + 1.5)
beta = 0.45 * (period - 1) / (0.45 * (period - 1) + 2)
alpha = pow(beta, power)
res = jma_helper(source, phaseRatio, beta, alpha)
return res if sequential else res[-1]
@njit(cache=True)
def jma_helper(src, phaseRatio, beta, alpha):
jma_val = np.copy(src)
e0 = np.full_like(src, 0)
e1 = np.full_like(src, 0)
e2 = np.full_like(src, 0)
for i in range(1, src.shape[0]):
e0[i] = (1 - alpha) * src[i] + alpha * e0[i-1]
e1[i] = (src[i] - e0[i]) * (1 - beta) + beta * e1[i-1]
e2[i] = (e0[i] + phaseRatio * e1[i] - jma_val[i - 1]) * pow(1 - alpha, 2) + pow(alpha, 2) * e2[i - 1]
jma_val[i] = e2[i] + jma_val[i - 1]
return jma_val
================================================
FILE: jesse/indicators/jsa.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, np_shift, slice_candles
def jsa(candles: np.ndarray, period: int = 30, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Jsa Moving Average
:param candles: np.ndarray
:param period: int - default: 30
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = (source + np_shift(source, period, np.nan)) / 2
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/kama.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import kama as kama_rust
def kama(candles: np.ndarray, period: int = 14, fast_length: int = 2, slow_length: int = 30,
source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
KAMA - Kaufman Adaptive Moving Average
:param candles: np.ndarray
:param period: int - default: 14, lookback period for the calculation
:param fast_length: int - default: 2, fast EMA length for smoothing factor
:param slow_length: int - default: 30, slow EMA length for smoothing factor
:param source_type: str - default: "close", specifies the candle field
:param sequential: bool - default: False, if True returns the full array, otherwise only the last value
:return: float | np.ndarray
"""
if candles.ndim == 1:
src = candles
else:
candles = slice_candles(candles, sequential)
src = get_candle_source(candles, source_type=source_type)
src = np.asarray(src, dtype=np.float64)
result = kama_rust(src, period, fast_length, slow_length)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/kaufmanstop.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from jesse.indicators.ma import ma
def kaufmanstop(candles: np.ndarray, period: int = 22, mult: float = 2, direction: str = "long", matype: int = 0,
sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Perry Kaufman's Stops
:param candles: np.ndarray
:param period: int - default: 22
:param mult: float - default: 2
:param direction: str - default: long
:param matype: int - default: 0
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if matype == 24 or matype == 29:
raise ValueError("VWMA (matype 24) and VWAP (matype 29) cannot be used in kaufmanstop indicator.")
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
hl_diff = ma(high - low, period=period, matype=matype, sequential=True)
res = low - hl_diff * mult if direction == "long" else high + hl_diff * mult
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/kdj.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
from jesse.indicators.ma import ma
KDJ = namedtuple('KDJ', ['k', 'd', 'j'])
def _rolling_max(a, window):
from numpy.lib.stride_tricks import sliding_window_view
a = np.asarray(a)
if len(a) < window:
return np.maximum.accumulate(a)
result = np.empty_like(a)
# Use vectorized cumulative maximum for the first window-1 elements
result[:window-1] = np.maximum.accumulate(a)[:window-1]
windows = sliding_window_view(a, window_shape=window)
result[window-1:] = np.max(windows, axis=1)
return result
def _rolling_min(a, window):
from numpy.lib.stride_tricks import sliding_window_view
a = np.asarray(a)
if len(a) < window:
return np.minimum.accumulate(a)
result = np.empty_like(a)
# Use vectorized cumulative minimum for the first window-1 elements
result[:window-1] = np.minimum.accumulate(a)[:window-1]
windows = sliding_window_view(a, window_shape=window)
result[window-1:] = np.min(windows, axis=1)
return result
def kdj(candles: np.ndarray, fastk_period: int = 9, slowk_period: int = 3, slowk_matype: int = 0,
slowd_period: int = 3, slowd_matype: int = 0, sequential: bool = False) -> KDJ:
"""
The KDJ Oscillator
:param candles: np.ndarray
:param fastk_period: int - default: 9
:param slowk_period: int - default: 3
:param slowk_matype: int - default: 0
:param slowd_period: int - default: 3
:param slowd_matype: int - default: 0
:param sequential: bool - default: False
:return: KDJ(k, d, j)
"""
if any(matype in (24, 29) for matype in (slowk_matype, slowd_matype)):
raise ValueError("VWMA (matype 24) and VWAP (matype 29) cannot be used in kdj indicator.")
candles = slice_candles(candles, sequential)
candles_close = candles[:, 2]
candles_high = candles[:, 3]
candles_low = candles[:, 4]
hh = _rolling_max(candles_high, fastk_period)
ll = _rolling_min(candles_low, fastk_period)
stoch = 100 * (candles_close - ll) / (hh - ll)
k = ma(stoch, period=slowk_period, matype=slowk_matype, sequential=True)
d = ma(k, period=slowd_period, matype=slowd_matype, sequential=True)
j = 3 * k - 2 * d
if sequential:
return KDJ(k, d, j)
else:
return KDJ(k[-1], d[-1], j[-1])
================================================
FILE: jesse/indicators/keltner.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
from jesse.indicators.ma import ma
KeltnerChannel = namedtuple('KeltnerChannel', ['upperband', 'middleband', 'lowerband'])
@njit
def _atr(high: np.ndarray, low: np.ndarray, close: np.ndarray, period: int) -> np.ndarray:
"""
Calculate ATR using Numba
"""
n = len(close)
tr = np.empty(n)
atr_vals = np.full(n, np.nan)
# Calculate True Range
tr[0] = high[0] - low[0]
for i in range(1, n):
hl = high[i] - low[i]
hc = abs(high[i] - close[i-1])
lc = abs(low[i] - close[i-1])
tr[i] = max(max(hl, hc), lc)
if n < period:
return atr_vals
# First ATR value is the simple average of the first 'period' true ranges
atr_vals[period-1] = np.mean(tr[:period])
# Calculate subsequent ATR values using Wilder's smoothing
for i in range(period, n):
atr_vals[i] = (atr_vals[i-1] * (period - 1) + tr[i]) / period
return atr_vals
@njit
def _calculate_keltner(source: np.ndarray, high: np.ndarray, low: np.ndarray, close: np.ndarray,
ma_values: np.ndarray, period: int, multiplier: float) -> tuple:
"""
Core Keltner Channel calculation using Numba
"""
atr_vals = _atr(high, low, close, period)
up = ma_values + atr_vals * multiplier
low = ma_values - atr_vals * multiplier
return up, ma_values, low
def keltner(candles: np.ndarray, period: int = 20, multiplier: float = 2, matype: int = 1,
source_type: str = "close", sequential: bool = False) -> KeltnerChannel:
"""
Keltner Channels using Numba for optimization
:param candles: np.ndarray
:param period: int - default: 20
:param multiplier: float - default: 2
:param matype: int - default: 1
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: KeltnerChannel(upperband, middleband, lowerband)
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if matype == 24 or matype == 29:
ma_values = ma(candles, period=period, matype=matype, source_type=source_type, sequential=True)
else:
ma_values = ma(source, period=period, matype=matype, sequential=True)
up, mid, low = _calculate_keltner(
source,
candles[:, 3], # high
candles[:, 4], # low
candles[:, 2], # close
ma_values,
period,
multiplier
)
if sequential:
return KeltnerChannel(up, mid, low)
else:
return KeltnerChannel(up[-1], mid[-1], low[-1])
================================================
FILE: jesse/indicators/kst.py
================================================
from collections import namedtuple
from jesse.indicators.roc import roc as _roc
from jesse.indicators.sma import sma as _sma
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
KST = namedtuple('KST', ['line', 'signal'])
def kst(candles: np.ndarray, sma_period1: int = 10, sma_period2: int = 10, sma_period3: int = 10, sma_period4: int = 15,
roc_period1: int = 10, roc_period2: int = 15, roc_period3: int = 20, roc_period4: int = 30,
signal_period: int = 9, source_type: str = "close", sequential: bool = False) -> KST:
"""
Know Sure Thing (KST)
:param candles: np.ndarray
:param sma_period1: int - default: 10
:param sma_period2: int - default: 10
:param sma_period3: int - default: 10
:param sma_period4: int - default: 15
:param roc_period1: int - default: 10
:param roc_period2: int - default: 15
:param roc_period3: int - default: 20
:param roc_period4: int - default: 30
:param signal_period: int - default: 9
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: KST(line, signal)
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
aroc1 = _sma(_roc(source, roc_period1, sequential=True), sma_period1, sequential=True)
aroc2 = _sma(_roc(source, roc_period2, sequential=True), sma_period2, sequential=True)
aroc3 = _sma(_roc(source, roc_period3, sequential=True), sma_period3, sequential=True)
aroc4 = _sma(_roc(source, roc_period4, sequential=True), sma_period4, sequential=True)
# Align arrays so that all have the same length as aroc4
aligned_len = aroc4.size
aroc1_aligned = aroc1[aroc1.size - aligned_len:]
aroc2_aligned = aroc2[aroc2.size - aligned_len:]
aroc3_aligned = aroc3[aroc3.size - aligned_len:]
line = aroc1_aligned + 2 * aroc2_aligned + 3 * aroc3_aligned + 4 * aroc4
signal = _sma(line, signal_period, sequential=True)
if sequential:
return KST(line, signal)
else:
return KST(line[-1], signal[-1])
================================================
FILE: jesse/indicators/kurtosis.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from scipy import stats
from jesse.helpers import get_candle_source, same_length, slice_candles
def kurtosis(candles: np.ndarray, period: int = 5, source_type: str = "hl2", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Skewness
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "hl2"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
swv = sliding_window_view(source, window_shape=period)
kurtosis_val = stats.kurtosis(swv, axis=-1)
res = same_length(source, kurtosis_val)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/kvo.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from jesse.indicators import ema
def kvo(candles: np.ndarray, short_period: int = 34, long_period: int = 55, sequential: bool = False) -> Union[float, np.ndarray]:
"""
KVO - Klinger Volume Oscillator
:param candles: np.ndarray
:param short_period: int - default: 34
:param long_period: int - default: 55
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
# Calculate HLC3
hlc3 = (candles[:, 3] + candles[:, 4] + candles[:, 2]) / 3
# Calculate momentum (change in HLC3)
mom = np.diff(hlc3, prepend=hlc3[0])
# Calculate trend
trend = np.zeros_like(mom)
trend[1:] = np.where(mom[1:] > 0, 1, np.where(mom[1:] < 0, -1, trend[:-1]))
# Daily Measurement (High - Low)
dm = candles[:, 3] - candles[:, 4]
# Cumulative Measurement
cm = np.zeros_like(dm)
for i in range(1, len(trend)):
if trend[i] == trend[i-1]:
cm[i] = cm[i-1] + dm[i]
else:
cm[i] = dm[i] + dm[i-1]
# Volume Force
volume = candles[:, 5]
with np.errstate(divide='ignore', invalid='ignore'):
expr = np.abs(np.divide(2 * dm, cm, out=np.zeros_like(dm, dtype=float), where=cm != 0) - 1)
vf = 100 * volume * trend * expr
vf[cm == 0] = 0
# Calculate EMAs
fast_ema = ema(vf, period=short_period, sequential=True)
slow_ema = ema(vf, period=long_period, sequential=True)
res = fast_ema - slow_ema
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/linearreg.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
@njit(cache=True)
def _fast_linearreg(source: np.ndarray, period: int) -> np.ndarray:
n = len(source)
result = np.full(n, np.nan)
x = np.arange(period)
mean_x = (period - 1) / 2.0
S_xx = np.sum((x - mean_x) ** 2)
for i in range(n - period + 1):
window = source[i:i+period]
mean_y = np.mean(window)
S_xy = np.sum((window - mean_y) * (x - mean_x))
result[i + period - 1] = mean_y + ((period - 1) / 2.0) * (S_xy / S_xx)
return result
def linearreg(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
LINEARREG - Linear Regression
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
n = len(source)
if n >= period:
try:
from numpy.lib.stride_tricks import sliding_window_view
windows = sliding_window_view(source, window_shape=period) # shape (n - period + 1, period)
mean_y = np.mean(windows, axis=1)
x = np.arange(period)
mean_x = (period - 1) / 2.0
S_xx = np.sum((x - mean_x) ** 2)
S_xy = np.sum((windows - mean_y[:, None]) * (x - mean_x), axis=1)
result = np.full(n, np.nan)
result[period-1:] = mean_y + ((period - 1) / 2.0) * (S_xy / S_xx)
except ImportError:
result = _fast_linearreg(source, period)
else:
result = np.full(n, np.nan)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/linearreg_angle.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def linearreg_angle(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> \
Union[float, np.ndarray]:
"""
LINEARREG_ANGLE - Linear Regression Angle
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
N = len(source)
res = np.full(N, np.nan)
if N >= period:
# Create rolling windows of length 'period'
windows = np.lib.stride_tricks.sliding_window_view(source, window_shape=period)
x = np.arange(period)
sum_x = x.sum()
sum_x2 = (x * x).sum()
common_den = period * sum_x2 - sum_x ** 2
sum_y = np.sum(windows, axis=1)
sum_xy = windows.dot(x)
slopes = (period * sum_xy - sum_x * sum_y) / common_den
angles = np.degrees(np.arctan(slopes))
res[period - 1:] = angles
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/linearreg_intercept.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def linearreg_intercept(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> \
Union[float, np.ndarray]:
"""
LINEARREG_INTERCEPT - Linear Regression Intercept
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Compute linear regression intercept using vectorized operations
if len(source) < period:
if sequential:
return np.full_like(source, np.nan, dtype=float)
else:
return np.nan
x = np.arange(period, dtype=float)
x_mean = x.mean()
sxx = ((x - x_mean) ** 2).sum()
if sequential:
# Compute rolling windows using a vectorized approach
windows = np.lib.stride_tricks.sliding_window_view(source, window_shape=period)
means = windows.mean(axis=1)
slopes = np.dot(windows - means[:, None], (x - x_mean)) / sxx
intercepts = means - slopes * x_mean
result = np.concatenate((np.full(period - 1, np.nan), intercepts))
return result
else:
window = source[-period:]
mean_val = window.mean()
slope = np.dot(window - mean_val, (x - x_mean)) / sxx
intercept = mean_val - slope * x_mean
return intercept
================================================
FILE: jesse/indicators/linearreg_slope.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def linearreg_slope(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> \
Union[float, np.ndarray]:
"""
LINEARREG_SLOPE - Linear Regression Slope
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
n = len(source)
result = np.full(n, np.nan, dtype=float)
if n < period:
return result if sequential else result[-1]
# Create a constant x-axis for the regression
X = np.arange(period, dtype=float)
sumX = X.sum()
sumX2 = (X**2).sum()
denom = period * sumX2 - sumX**2
# Compute the rolling window slopes using vectorized operations
windows = np.lib.stride_tricks.sliding_window_view(source, window_shape=period)
sum_y = windows.sum(axis=1)
sum_xy = (windows * X).sum(axis=1)
slopes = (period * sum_xy - sumX * sum_y) / denom
result[period-1:] = slopes
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/lrsi.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import slice_candles
def lrsi(candles: np.ndarray, alpha: float = 0.2, sequential: bool = False) -> Union[float, np.ndarray]:
"""
RSI Laguerre Filter
:param candles: np.ndarray
:param alpha: float - default: 0.2
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
rsi = lrsi_fast(alpha, candles)
if sequential:
return rsi
else:
return None if np.isnan(rsi[-1]) else rsi[-1]
@njit(cache=True)
def lrsi_fast(alpha, candles):
price = (candles[:, 3] + candles[:, 4]) / 2
l0 = np.copy(price)
l1 = np.copy(price)
l2 = np.copy(price)
l3 = np.copy(price)
for i in range(l0.shape[0]):
gamma = 1 - alpha
l0[i] = alpha * price[i] + gamma * l0[i - 1]
l1[i] = -gamma * l0[i] + l0[i - 1] + gamma * l1[i - 1]
l2[i] = -gamma * l1[i] + l1[i - 1] + gamma * l2[i - 1]
l3[i] = -gamma * l2[i] + l2[i - 1] + gamma * l3[i - 1]
rsi = np.zeros_like(price)
for i in range(candles[:, 2].shape[0]):
cu = 0
cd = 0
if l0[i] >= l1[i]:
cu = l0[i] - l1[i]
else:
cd = l1[i] - l0[i]
if l1[i] >= l2[i]:
cu = cu + l1[i] - l2[i]
else:
cd = cd + l2[i] - l1[i]
if l2[i] >= l3[i]:
cu = cu + l2[i] - l3[i]
else:
cd = cd + l3[i] - l2[i]
rsi[i] = 0 if cu + cd == 0 else cu / (cu + cd)
return rsi
================================================
FILE: jesse/indicators/ma.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def ma(candles: np.ndarray, period: int = 30, matype: int = 0, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
MA - (nearly) All Moving Averages of Jesse
:param candles: np.ndarray
:param period: int - default: 30
:param matype: int - default: 0
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
0: sma (simple)
1: ema (exponential)
2: wma (weighted)
3: dema (double exponential)
4: tema (triple exponential)
5: trima (triangular)
6: kama (Kaufman adaptive)
9: fwma (Fibonacci's Weighted Moving Average)
10: hma (Hull Moving Average)
11: linearreg (Linear Regression)
12: wilders (Wilders Smoothing)
13: sinwma (Sine Weighted Moving Average)
14: supersmoother (Super Smoother Filter 2pole Butterworth)
15: supersmoother\_3\_pole(Super Smoother Filter 3pole Butterworth)
16: gauss (Gaussian Filter)
17: high\_pass (1-pole High Pass Filter by John F. Ehlers)
18: high\_pass\_2\_pole (2-pole High Pass Filter by John F. Ehlers)
19: ht\_trendline (Hilbert Transform - Instantaneous Trendline)
20: jma (Jurik Moving Average)
21: reflex (Reflex indicator by John F. Ehlers)
22: trendflex (Trendflex indicator by John F. Ehlers)
23: smma (Smoothed Moving Average)
24: vwma (Volume Weighted Moving Average)
25: pwma (Pascals Weighted Moving Average)
26: swma (Symmetric Weighted Moving Average)
27: alma (Arnaud Legoux Moving Average)
28: hwma (Holt-Winter Moving Average)
29: vwap (Volume weighted average price)
30: nma (Natural Moving Average)
31: edcf (Ehlers Distance Coefficient Filter)
32: mwdx (MWDX Average)
33: maaq (Moving Average Adaptive Q)
34: srwma (Square Root Weighted Moving Average)
35: sqwma (Square Weighted Moving Average)
36: vpwma (Variable Power Weighted Moving Average)
37: cwma (Cubed Weighted Moving Average)
38: jsa (Jsa Moving Average)
39: epma (End Point Moving Average)
"""
candles = slice_candles(candles, sequential)
if matype == 0:
from . import sma
res = sma(candles, period, source_type=source_type, sequential=True)
elif matype == 1:
from . import ema
res = ema(candles, period, source_type=source_type, sequential=True)
elif matype == 2:
from . import wma
res = wma(candles, period, source_type=source_type, sequential=True)
elif matype == 3:
from . import dema
res = dema(candles, period, source_type=source_type, sequential=True)
elif matype == 4:
from . import tema
res = tema(candles, period, source_type=source_type, sequential=True)
elif matype == 5:
from . import trima
res = trima(candles, period, source_type=source_type, sequential=True)
elif matype == 6:
from . import kama
res = kama(candles, period, source_type=source_type, sequential=True)
elif matype == 9:
from . import fwma
res = fwma(candles, period, source_type=source_type, sequential=True)
elif matype == 10:
from . import hma
res = hma(candles, period, source_type=source_type, sequential=True)
elif matype == 11:
from . import linearreg
res = linearreg(candles, period, source_type=source_type, sequential=True)
elif matype == 12:
from . import wilders
res = wilders(candles, period, source_type=source_type, sequential=True)
elif matype == 13:
from . import sinwma
res = sinwma(candles, period, source_type=source_type, sequential=True)
elif matype == 14:
from . import supersmoother
res = supersmoother(candles, period, source_type=source_type, sequential=True)
elif matype == 15:
from . import supersmoother_3_pole
res = supersmoother_3_pole(candles, period, source_type=source_type, sequential=True)
elif matype == 16:
from . import gauss
res = gauss(candles, period, source_type=source_type, sequential=True)
elif matype == 17:
from . import high_pass
res = high_pass(candles, period, source_type=source_type, sequential=True)
elif matype == 18:
from . import high_pass_2_pole
res = high_pass_2_pole(candles, period, source_type=source_type, sequential=True)
elif matype == 20:
from . import jma
res = jma(candles, period, source_type=source_type, sequential=True)
elif matype == 21:
from . import reflex
res = reflex(candles, period, source_type=source_type, sequential=True)
elif matype == 22:
from . import trendflex
res = trendflex(candles, period, source_type=source_type, sequential=True)
elif matype == 23:
from . import smma
res = smma(candles, period, source_type=source_type, sequential=True)
elif matype == 24:
if len(candles.shape) == 1:
raise ValueError("vwma only works with normal candles.")
from . import vwma
res = vwma(candles, period, source_type=source_type, sequential=True)
elif matype == 25:
from . import pwma
res = pwma(candles, period, source_type=source_type, sequential=True)
elif matype == 26:
from . import swma
res = swma(candles, period, source_type=source_type, sequential=True)
elif matype == 27:
from . import alma
res = alma(candles, period, source_type=source_type, sequential=True)
elif matype == 28:
from . import hwma
res = hwma(candles, source_type=source_type, sequential=True)
elif matype == 29:
from . import vwap
if len(candles.shape) == 1:
raise ValueError("vwap only works with normal candles.")
res = vwap(candles, source_type=source_type, sequential=True)
elif matype == 30:
from . import nma
res = nma(candles, period, source_type=source_type, sequential=True)
elif matype == 31:
from . import edcf
res = edcf(candles, period, source_type=source_type, sequential=True)
elif matype == 32:
from . import mwdx
res = mwdx(candles, source_type=source_type, sequential=True)
elif matype == 33:
from . import maaq
res = maaq(candles, period, source_type=source_type, sequential=True)
elif matype == 34:
from . import srwma
res = srwma(candles, period, source_type=source_type, sequential=True)
elif matype == 35:
from . import sqwma
res = sqwma(candles, period, source_type=source_type, sequential=True)
elif matype == 36:
from . import vpwma
res = vpwma(candles, period, source_type=source_type, sequential=True)
elif matype == 37:
from . import cwma
res = cwma(candles, period, source_type=source_type, sequential=True)
elif matype == 38:
from . import jsa
res = jsa(candles, period, source_type=source_type, sequential=True)
elif matype == 39:
from . import epma
res = epma(candles, period, source_type=source_type, sequential=True)
elif matype == 7 or matype == 8 or matype == 19:
raise ValueError("Invalid matype value.")
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/maaq.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import (get_candle_source, np_shift, same_length,
slice_candles)
def maaq(candles: np.ndarray, period: int = 11, fast_period: int = 2, slow_period: int = 30, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
Moving Average Adaptive Q
:param candles: np.ndarray
:param period: int - default: 11
:param fast_period: int - default: 2
:param slow_period: int - default: 30
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
source = source[~np.isnan(source)]
diff = np.abs(source - np_shift(source, 1, np.nan))
signal = np.abs(source - np_shift(source, period, np.nan))
noise = np.concatenate((np.full(period - 1, np.nan, dtype=source.dtype), np.convolve(diff, np.ones(period, dtype=source.dtype), mode='valid')))
# Safely divide signal by noise
ratio = np.divide(signal, noise, out=np.zeros_like(signal), where=(noise != 0))
fastSc = 2 / (fast_period + 1)
slowSc = 2 / (slow_period + 1)
temp = np.power((ratio * fastSc) + slowSc, 2)
res = maaq_fast(source, temp, period)
res = same_length(candles, res)
return res if sequential else res[-1]
@njit(cache=True)
def maaq_fast(source, temp, period):
newseries = np.copy(source)
for i in range(period, source.shape[0]):
newseries[i] = newseries[i - 1] + (temp[i] * (source[i] - newseries[i - 1]))
return newseries
================================================
FILE: jesse/indicators/mab.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse.indicators.ma import ma
MAB = namedtuple('MAB', ['upperband', 'middleband', 'lowerband'])
def mab(candles: np.ndarray, fast_period: int = 10, slow_period: int = 50, devup: float = 1, devdn: float = 1, fast_matype: int = 0, slow_matype: int = 0,
source_type: str = "close",
sequential: bool = False) -> MAB:
"""
Moving Average Bands
:param candles: np.ndarray
:param fast_period: int - default: 10
:param slow_period: int - default: 50
:param devup: float - default: 1
:param devdn: float - default: 1
:param fast_matype: int - default: 0
:param slow_matype: int - default: 0
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: MAB(upperband, middleband, lowerband)
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if any(matype in (24, 29) for matype in (fast_matype, slow_matype)):
fastEma = ma(candles, period=fast_period, matype=fast_matype, source_type=source_type, sequential=True)
slowEma = ma(candles, period=slow_period, matype=slow_matype, source_type=source_type, sequential=True)
else:
fastEma = ma(source, period=fast_period, matype=fast_matype, source_type=source_type, sequential=True)
slowEma = ma(source, period=slow_period, matype=slow_matype, source_type=source_type, sequential=True)
sqAvg = np.sum(np.power(fastEma - slowEma, 2)[-fast_period:]) / fast_period
dev = np.sqrt(sqAvg)
middlebands = fastEma
upperbands = slowEma + devup * dev
lowerbands = slowEma - devdn * dev
if sequential:
return MAB(upperbands, middlebands, lowerbands)
else:
return MAB(upperbands[-1], middlebands[-1], lowerbands[-1])
================================================
FILE: jesse/indicators/macd.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import macd as macd_rust
MACD = namedtuple('MACD', ['macd', 'signal', 'hist'])
def macd(candles: np.ndarray, fast_period: int = 12, slow_period: int = 26, signal_period: int = 9,
source_type: str = "close",
sequential: bool = False) -> MACD:
"""
MACD - Moving Average Convergence/Divergence
:param candles: np.ndarray
:param fast_period: int - default: 12
:param slow_period: int - default: 26
:param signal_period: int - default: 9
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: MACD(macd, signal, hist)
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if source.size == 0:
return MACD(np.nan, np.nan, np.nan) if not sequential else MACD(np.array([]), np.array([]), np.array([]))
macd_line, signal_line, hist = macd_rust(source, fast_period, slow_period, signal_period)
if sequential:
return MACD(macd_line, signal_line, hist)
else:
return MACD(macd_line[-1], signal_line[-1], hist[-1])
================================================
FILE: jesse/indicators/mama.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
MAMA = namedtuple('MAMA', ['mama', 'fama'])
def mama(candles: np.ndarray, fastlimit: float = 0.5, slowlimit: float = 0.05, source_type: str = "close",
sequential: bool = False) -> MAMA:
"""
MAMA - MESA Adaptive Moving Average (custom implementation)
:param candles: np.ndarray of candle data or price series
:param fastlimit: float - default: 0.5
:param slowlimit: float - default: 0.05
:param source_type: str - default: "close"
:param sequential: bool - if True, returns full arrays; else returns only the last value
:return: MAMA(mama, fama)
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
n = len(source)
mama_arr = np.zeros(n)
fama_arr = np.zeros(n)
# Initialize first element
mama_arr[0] = source[0]
fama_arr[0] = source[0]
mama_arr, fama_arr = fast_mama(source, fastlimit, slowlimit)
# Iterate over the series to compute the indicator recursively
if sequential:
return MAMA(mama_arr, fama_arr)
else:
return MAMA(mama_arr[-1], fama_arr[-1])
@njit(cache=True)
def fast_mama(source, fastlimit, slowlimit):
n = len(source)
sp = np.zeros(n)
dt = np.zeros(n)
q1 = np.zeros(n)
i1_arr = np.zeros(n)
jI = np.zeros(n)
jq = np.zeros(n)
i2_arr = np.zeros(n)
q2_arr = np.zeros(n)
re_arr = np.zeros(n)
im_arr = np.zeros(n)
p1_arr = np.zeros(n)
p2_arr = np.zeros(n)
p3_arr = np.zeros(n)
p_arr = np.zeros(n)
spp = np.zeros(n)
phase = np.zeros(n)
dphase = np.zeros(n)
alpha_arr = np.zeros(n)
mama_arr = np.zeros(n)
fama_arr = np.zeros(n)
pi = 3.1415926
for i in range(1, n):
# sp: weighted average of the source over 4 bars
sp[i] = (4 * source[i] +
3 * (source[i-1] if i-1 >= 0 else 0) +
2 * (source[i-2] if i-2 >= 0 else 0) +
(source[i-3] if i-3 >= 0 else 0)) / 10.0
dt[i] = (0.0962 * sp[i] +
0.5769 * (sp[i-2] if i-2 >= 0 else 0) -
0.5769 * (sp[i-4] if i-4 >= 0 else 0) -
0.0962 * (sp[i-6] if i-6 >= 0 else 0)) * (0.075 * (p_arr[i-1] if i-1 >= 0 else 0) + 0.54)
q1[i] = (0.0962 * dt[i] +
0.5769 * (dt[i-2] if i-2 >= 0 else 0) -
0.5769 * (dt[i-4] if i-4 >= 0 else 0) -
0.0962 * (dt[i-6] if i-6 >= 0 else 0)) * (0.075 * (p_arr[i-1] if i-1 >= 0 else 0) + 0.54)
i1_arr[i] = dt[i-3] if i-3 >= 0 else 0
jI[i] = (0.0962 * i1_arr[i] +
0.5769 * (i1_arr[i-2] if i-2 >= 0 else 0) -
0.5769 * (i1_arr[i-4] if i-4 >= 0 else 0) -
0.0962 * (i1_arr[i-6] if i-6 >= 0 else 0)) * (0.075 * (p_arr[i-1] if i-1 >= 0 else 0) + 0.54)
jq[i] = (0.0962 * q1[i] +
0.5769 * (q1[i-2] if i-2 >= 0 else 0) -
0.5769 * (q1[i-4] if i-4 >= 0 else 0) -
0.0962 * (q1[i-6] if i-6 >= 0 else 0)) * (0.075 * (p_arr[i-1] if i-1 >= 0 else 0) + 0.54)
i2_temp = i1_arr[i] - jq[i]
q2_temp = q1[i] + jI[i]
i2_arr[i] = 0.2 * i2_temp + 0.8 * (i2_arr[i-1] if i-1 >= 0 else 0)
q2_arr[i] = 0.2 * q2_temp + 0.8 * (q2_arr[i-1] if i-1 >= 0 else 0)
re_temp = i2_arr[i] * (i2_arr[i-1] if i-1 >= 0 else 0) + q2_arr[i] * (q2_arr[i-1] if i-1 >= 0 else 0)
im_temp = i2_arr[i] * (q2_arr[i-1] if i-1 >= 0 else 0) - q2_arr[i] * (i2_arr[i-1] if i-1 >= 0 else 0)
re_arr[i] = 0.2 * re_temp + 0.8 * (re_arr[i-1] if i-1 >= 0 else 0)
im_arr[i] = 0.2 * im_temp + 0.8 * (im_arr[i-1] if i-1 >= 0 else 0)
if im_arr[i] != 0 and re_arr[i] != 0:
p1_arr[i] = 2 * pi / np.arctan(im_arr[i] / re_arr[i])
else:
p1_arr[i] = p_arr[i-1] if i-1 >= 0 else 0
if p1_arr[i] > 1.5 * (p_arr[i-1] if i-1 >= 0 else 0):
p2 = 1.5 * (p_arr[i-1] if i-1 >= 0 else 0)
elif p1_arr[i] < 0.67 * (p_arr[i-1] if i-1 >= 0 else 0):
p2 = 0.67 * (p_arr[i-1] if i-1 >= 0 else 0)
else:
p2 = p1_arr[i]
p2_arr[i] = p2
p3_arr[i] = 6 if p2_arr[i] < 6 else (50 if p2_arr[i] > 50 else p2_arr[i])
p_arr[i] = 0.2 * p3_arr[i] + 0.8 * (p_arr[i-1] if i-1 >= 0 else 0)
spp[i] = 0.33 * p_arr[i] + 0.67 * (spp[i-1] if i-1 >= 0 else 0)
phase[i] = (180 / pi) * np.arctan(q1[i] / i1_arr[i]) if i1_arr[i] != 0 else 0
dphase_val = (phase[i-1] if i-1 >= 0 else 0) - phase[i]
dphase_val = dphase_val if dphase_val >= 1 else 1
dphase[i] = dphase_val
alpha_temp = fastlimit / dphase[i]
if alpha_temp < slowlimit:
alpha_arr[i] = slowlimit
elif alpha_temp > fastlimit:
alpha_arr[i] = fastlimit
else:
alpha_arr[i] = alpha_temp
mama_arr[i] = alpha_arr[i] * source[i] + (1 - alpha_arr[i]) * (mama_arr[i-1] if i-1 >= 0 else source[i])
fama_arr[i] = 0.5 * alpha_arr[i] * mama_arr[i] + (1 - 0.5 * alpha_arr[i]) * (fama_arr[i-1] if i-1 >= 0 else source[i])
return mama_arr, fama_arr
================================================
FILE: jesse/indicators/marketfi.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import same_length, slice_candles
def marketfi(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
MARKETFI - Market Facilitation Index
Formula: (High - Low) / Volume
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
# high is at index 3, low at index 4, volume at index 5
res = (candles[:, 3] - candles[:, 4]) / candles[:, 5]
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/mass.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import same_length, slice_candles
def mass(candles: np.ndarray, period: int = 5, sequential: bool = False) -> Union[float, np.ndarray]:
"""
MASS - Mass Index
The Mass Index uses the high-low range to identify trend reversals based on range expansions.
It suggests that a reversal of the current trend may be imminent when the range widens beyond
a certain point and then contracts.
:param candles: np.ndarray
:param period: int - default: 5
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
# Calculate high-low range
high_low_range = candles[:, 3] - candles[:, 4] # high - low
# Calculate 9-period EMA of high-low range
ema1 = calc_ema(high_low_range, 9)
# Calculate 9-period EMA of the first EMA
ema2 = calc_ema(ema1, 9)
# Calculate EMA ratio
ratio = np.divide(ema1, ema2, out=np.zeros_like(ema1), where=ema2 != 0)
# Calculate period-sum of ratio using Numba for optimization
res = mass_sum(ratio, period)
return same_length(candles, res) if sequential else res[-1]
@njit(cache=True)
def mass_sum(ratio: np.ndarray, period: int) -> np.ndarray:
"""Calculate the sum of the ratio over the specified period"""
result = np.zeros_like(ratio)
for i in range(period - 1, len(ratio)):
result[i] = np.sum(ratio[i-period+1:i+1])
return result
@njit(cache=True)
def calc_ema(data, n):
alpha = 2.0 / (n + 1)
result = np.empty(data.shape[0])
result[0] = data[0]
for i in range(1, data.shape[0]):
result[i] = alpha * data[i] + (1 - alpha) * result[i-1]
return result
================================================
FILE: jesse/indicators/mcginley_dynamic.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def mcginley_dynamic(candles: np.ndarray, period: int = 10, k: float = 0.6, source_type: str = "close",
sequential: bool = False) -> Union[
float, np.ndarray]:
"""
McGinley Dynamic
:param candles: np.ndarray
:param period: int - default: 10
:param k: float - default: 0.6
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
mg = md_fast(source, k, period)
return mg if sequential else mg[-1]
@njit(cache=True)
def md_fast(source, k, period):
mg = np.full_like(source, np.nan)
for i in range(source.size):
if i == 0:
mg[i] = source[i]
else:
mg[i] = mg[i - 1] + ((source[i] - mg[i - 1]) / max([(k * period * ((source[i] / mg[i - 1]) ** 4)), 1]))
return mg
================================================
FILE: jesse/indicators/mean_ad.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import get_candle_source, same_length, slice_candles
def mean_ad(candles: np.ndarray, period: int = 5, source_type: str = "hl2", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Mean Absolute Deviation
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "hl2"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
swv = sliding_window_view(source, window_shape=period)
abs_diff = np.absolute(source - same_length(source, np.mean(swv, -1)))
smv_abs_diff = sliding_window_view(abs_diff, window_shape=period)
mean_abs_deviation = np.nanmean(smv_abs_diff, -1)
res = same_length(source, mean_abs_deviation)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/median_ad.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from scipy import stats
from jesse.helpers import get_candle_source, same_length, slice_candles
def median_ad(candles: np.ndarray, period: int = 5, source_type: str = "hl2", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Median Absolute Deviation
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "hl2"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
swv = sliding_window_view(source, window_shape=period)
median_abs_deviation = stats.median_abs_deviation(swv, axis=-1)
res = same_length(source, median_abs_deviation)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/medprice.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def medprice(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
MEDPRICE - Median Price
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
res = (candles[:, 3] + candles[:, 4]) / 2
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/mfi.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def mfi(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
MFI - Money Flow Index
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
# Extract high, low, close and volume from candles array
high = candles[:, 3]
low = candles[:, 4]
close = candles[:, 2]
volume = candles[:, 5]
# Compute Typical Price for each candle
typical_prices = (high + low + close) / 3.0
# Compute Raw Money Flow = Typical Price * Volume
raw_mf = typical_prices * volume
# Initialize positive and negative flows
pos_flow = np.zeros_like(typical_prices)
neg_flow = np.zeros_like(typical_prices)
# For each candle (starting from 1) decide if it's positive or negative money flow
pos_flow[1:] = np.where(typical_prices[1:] > typical_prices[:-1], raw_mf[1:], 0)
neg_flow[1:] = np.where(typical_prices[1:] < typical_prices[:-1], raw_mf[1:], 0)
# Compute rolling sums over the specified period using convolution
roll_pos = np.convolve(pos_flow, np.ones(period), mode='valid')
roll_neg = np.convolve(neg_flow, np.ones(period), mode='valid')
# Compute Money Flow Ratio; handle division by zero by treating as infinity
with np.errstate(divide='ignore', invalid='ignore'):
ratio = np.divide(roll_pos, roll_neg, out=np.full_like(roll_pos, np.inf, dtype=float), where=roll_neg != 0)
# Compute MFI
mfi_values = 100 - (100 / (1 + ratio))
# Prepend NaNs for indices that couldn't compute a full period
pad = np.full(period - 1, np.nan)
mfi_values = np.concatenate((pad, mfi_values))
return mfi_values if sequential else mfi_values[-1]
================================================
FILE: jesse/indicators/midpoint.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def midpoint(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
MIDPOINT - MidPoint over period
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# If there is not enough data, return nan values
if len(source) < period:
if sequential:
return np.full_like(source, np.nan)
else:
return np.nan
# Use a sliding window to compute the midpoint: (max + min) / 2 over each rolling window
windows = np.lib.stride_tricks.sliding_window_view(source, period)
midpoints = (np.max(windows, axis=1) + np.min(windows, axis=1)) / 2.0
# Pad the beginning with nans to match the input length if sequential is True
if sequential:
result = np.empty_like(source, dtype=float)
result[:period - 1] = np.nan
result[period - 1:] = midpoints
return result
else:
return midpoints[-1]
================================================
FILE: jesse/indicators/midprice.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from numpy.lib.stride_tricks import sliding_window_view
def midprice(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
MIDPRICE - Midpoint Price over period
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
if sequential:
n = len(candles)
if n < period:
return np.full(n, np.nan)
# Create sliding windows for high and low prices
windows_high = sliding_window_view(high, window_shape=period)
windows_low = sliding_window_view(low, window_shape=period)
# Calculate midprice for each window
midprices = (np.max(windows_high, axis=1) + np.min(windows_low, axis=1)) / 2
# Prepend NaN for the initial period-1 values to match the typical TA-Lib output length
result = np.concatenate((np.full(period - 1, np.nan), midprices))
return result
else:
if len(candles) < period:
return np.nan
return (np.max(high[-period:]) + np.min(low[-period:])) / 2
================================================
FILE: jesse/indicators/minmax.py
================================================
from collections import namedtuple
import numpy as np
from scipy.signal import argrelextrema
from jesse.helpers import np_ffill, slice_candles
EXTREMA = namedtuple('EXTREMA', ['is_min', 'is_max', 'last_min', 'last_max'])
def minmax(candles: np.ndarray, order: int = 3, sequential: bool = False) -> EXTREMA:
"""
minmax - Get extrema
:param candles: np.ndarray
:param order: int - default = 3
:param sequential: bool - default: False
:return: EXTREMA(min, max, last_min, last_max)
"""
candles = slice_candles(candles, sequential)
low = candles[:, 4]
high = candles[:, 3]
minimaIdxs = argrelextrema(low, np.less, order=order, axis=0)
maximaIdxs = argrelextrema(high, np.greater, order=order, axis=0)
is_min = np.full_like(low, np.nan)
is_max = np.full_like(high, np.nan)
# set the extremas with the matching price
is_min[minimaIdxs] = low[minimaIdxs]
is_max[maximaIdxs] = high[maximaIdxs]
# forward fill Nan values to get the last extrema
last_min = np_ffill(is_min)
last_max = np_ffill(is_max)
if sequential:
return EXTREMA(is_min, is_max, last_min, last_max)
else:
return EXTREMA(is_min[-(order+1)], is_max[-(order+1)], last_min[-1], last_max[-1])
================================================
FILE: jesse/indicators/mom.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def mom(candles: np.ndarray, period: int = 10, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
MOM - Momentum
:param candles: np.ndarray
:param period: int - default: 10
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = np.empty_like(source, dtype=float)
if len(source) >= period:
res[:period] = np.nan
res[period:] = source[period:] - source[:-period]
else:
res[:] = np.nan
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/mwdx.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def mwdx(candles: np.ndarray, factor: float = 0.2, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
MWDX Average
:param candles: np.ndarray
:param factor: float - default: 0.2
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
val2 = (2 / factor) - 1
fac = 2 / (val2 + 1)
res = mwdx_fast(source, fac)
return res if sequential else res[-1]
@njit(cache=True)
def mwdx_fast(source, fac):
newseries = np.copy(source)
for i in range(1, source.shape[0]):
newseries[i] = (fac * source[i]) + ((1 - fac) * newseries[i - 1])
return newseries
================================================
FILE: jesse/indicators/natr.py
================================================
import numpy as np
from typing import Union
from jesse.helpers import slice_candles
def natr(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
NATR - Normalized Average True Range
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
close = candles[:, 2]
# Compute True Range (TR)
n = len(candles)
tr = np.empty(n, dtype=float)
tr[0] = high[0] - low[0]
if n > 1:
diff1 = high[1:] - low[1:]
diff2 = np.abs(high[1:] - close[:-1])
diff3 = np.abs(low[1:] - close[:-1])
tr[1:] = np.maximum(np.maximum(diff1, diff2), diff3)
# Initialize ATR array
atr = np.empty(n, dtype=float)
atr[:period-1] = np.nan # not enough data for smoothing
base = np.mean(tr[:period])
atr[period-1] = base
# If there's no additional data after the initial period, return the current NATR
if n == period:
result = (base / close[period-1]) * 100
return result if not sequential else np.concatenate((np.full(period-1, np.nan), [result]))
# Wilder's smoothing is equivalent to an exponential moving average with alpha = 1/period
alpha = 1.0 / period
beta = 1 - alpha
# For indices from period to end, we compute the recursive ATR as:
# ATR[t] = beta^(t - (period-1)) * base + sum_{i=period}^{t} (alpha * beta^(t-i) * tr[i])
# We vectorize the summation using convolution.
x = tr[period:]
m = len(x)
weights = alpha * beta ** np.arange(m)
conv = np.convolve(x, weights, mode='full')[:m]
base_adjustment = beta ** (np.arange(1, m + 1)) * base
atr[period:] = base_adjustment + conv
natr_arr = (atr / close) * 100
return natr_arr if sequential else natr_arr[-1]
================================================
FILE: jesse/indicators/nma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def nma(candles: np.ndarray, period: int = 40, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
Natural Moving Average
:param candles: np.ndarray
:param period: int - default: 40
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = nma_fast(source, period)
return res if sequential else res[-1]
@njit(cache=True)
def nma_fast(source, period):
# Ensure source values are positive before taking log
source = np.clip(source, a_min=1e-10, a_max=None)
ln = np.log(source) * 1000
newseries = np.full_like(source, np.nan)
for j in range(period + 1, source.shape[0]):
num = 0.0
denom = 0.0
for i in range(period):
oi = np.abs(ln[j - i] - ln[j - i - 1])
num += oi * (np.sqrt(i + 1) - np.sqrt(i))
denom += oi
ratio = num / denom if denom != 0 else 0
newseries[j] = (source[j - i] * ratio) + (source[j - i - 1] * (1 - ratio))
return newseries
================================================
FILE: jesse/indicators/nvi.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
@njit
def _nvi_fast(source: np.ndarray, volume: np.ndarray) -> np.ndarray:
res = np.ones_like(source)
res[0] = 1000 # Starting value (conventional)
for i in range(1, len(source)):
if volume[i] < volume[i-1]:
res[i] = res[i-1] * (1 + ((source[i] - source[i-1]) / source[i-1]))
else:
res[i] = res[i-1]
return res
def nvi(candles: np.ndarray, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
NVI - Negative Volume Index
The Negative Volume Index (NVI) is a cumulative indicator that uses the change in volume to decide when to track the price of an asset.
It suggests that smart money is at work when volume decreases and vice versa.
:param candles: np.ndarray
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = _nvi_fast(source, candles[:, 5])
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/obv.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def obv(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
OBV - On Balance Volume
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
close = candles[:, 2]
volume = candles[:, 5]
# Compute the change in OBV: add volume if price increases, subtract if decreases, else 0
delta = np.where(close[1:] > close[:-1], volume[1:], np.where(close[1:] < close[:-1], -volume[1:], 0))
obv_arr = np.empty_like(volume, dtype=np.float64)
obv_arr[0] = volume[0]
if len(volume) > 1:
obv_arr[1:] = volume[0] + np.cumsum(delta)
return obv_arr if sequential else obv_arr[-1]
================================================
FILE: jesse/indicators/pfe.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
@njit(cache=True)
def numpy_ema(data: np.ndarray, period: int) -> np.ndarray:
alpha = 2 / (period + 1)
# Initialize the EMA with the first value
ema = np.zeros_like(data)
ema[0] = data[0]
# Calculate EMA using vectorized operations
for i in range(1, len(data)):
ema[i] = data[i] * alpha + ema[i-1] * (1 - alpha)
return ema
def rolling_sum(arr: np.ndarray, window: int) -> np.ndarray:
# Create a rolling window sum using convolution
window_ones = np.ones(window)
sum_result = np.convolve(arr, window_ones, mode='valid')
# Pad the beginning to maintain array length
padding = np.array([np.nan] * (len(arr) - len(sum_result)))
return np.concatenate((padding, sum_result))
def pfe(candles: np.ndarray, period: int = 10, smoothing: int = 5, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Polarized Fractal Efficiency (PFE)
:param candles: np.ndarray
:param period: int - default: 10
:param smoothing: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
ln = period - 1
diff = np.diff(source, ln)
a = np.sqrt(np.power(diff, 2) + np.power(period, 2))
# Calculate rolling sum of sqrt(1 + diff^2)
diff_1 = np.diff(source, 1)
sqrt_term = np.sqrt(1 + np.power(diff_1, 2))
b = rolling_sum(sqrt_term, ln)
pfetmp = 100 * same_length(source, a) / same_length(source, b)
# Replace NaN values with 0 to avoid issues in calculations
pfetmp = np.nan_to_num(pfetmp, 0)
# Calculate the sign based on diff
sign = np.where(same_length(source, diff) > 0, 1, -1)
res = numpy_ema(sign * pfetmp, smoothing)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/pivot.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
PIVOT = namedtuple('PIVOT', ['r4', 'r3', 'r2', 'r1', 'pp', 's1', 's2', 's3', 's4'])
def pivot(candles: np.ndarray, mode: int = 0, sequential: bool = False) -> PIVOT:
"""
Pivot Points
:param candles: np.ndarray
:param mode: int - default = 0
:param sequential: bool - default: False
:return: PIVOT(r4, r3, r2, r1, pp, s1, s2, s3, s4)
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
close = candles[:, 2]
open = candles[:, 1]
s1 = np.full_like(close, np.nan)
s2 = np.copy(s1)
s3 = np.copy(s1)
s4 = np.copy(s1)
p = np.copy(s1)
r1 = np.copy(s1)
r2 = np.copy(s1)
r3 = np.copy(s1)
r4 = np.copy(s1)
# Standard Pivot Points / Floor Pivot Points
if mode == 0:
p = (high + low + close) / 3
s1 = (2 * p) - high
s2 = p - (high - low)
r1 = (2 * p) - low
r2 = p + (high - low)
# Fibonacci Pivot Points
elif mode == 1:
p = (high + low + close) / 3
s1 = p - 0.382 * (high - low)
s2 = p - 0.618 * (high - low)
s3 = p - 1 * (high - low)
r1 = p + 0.382 * (high - low)
r2 = p + 0.618 * (high - low)
r3 = p + 1 * (high - low)
# Demark Pivot Points
elif mode == 2:
p = np.where(close < open, (high + 2 * low + close) / 4, np.where(close > open, (2 * high + low + close) / 4,
np.where(close == open,
(high + low + 2 * close) / 4,
np.nan)))
s1 = np.where(close < open, (high + 2 * low + close) / 2 - high,
np.where(close > open, (2 * high + low + close) / 2 - high,
np.where(close == open, (high + low + 2 * close) / 2 - high, np.nan)))
r1 = np.where(close < open, (high + 2 * low + close) / 2 - low,
np.where(close > open, (2 * high + low + close) / 2 - low,
np.where(close == open, (high + low + 2 * close) / 2 - low, np.nan)))
elif mode == 3:
# Camarilla Pivot Points
p = (high + low + close) / 3
r4 = (0.55 * (high - low)) + close
r3 = (0.275 * (high - low)) + close
r2 = (0.183 * (high - low)) + close
r1 = (0.0916 * (high - low)) + close
s1 = close - (0.0916 * (high - low))
s2 = close - (0.183 * (high - low))
s3 = close - (0.275 * (high - low))
s4 = close - (0.55 * (high - low))
# Woodie's Pivot Points
elif mode == 4:
p = (high + low + (2 * open)) / 4
r3 = high + 2 * (p - low)
r4 = r3 + (high - low)
r2 = p + (high - low)
r1 = (2 * p) - low
s1 = (2 * p) - high
s2 = p - (high - low)
s3 = low - 2 * (high - p)
s4 = s3 - (high - low)
if sequential:
return PIVOT(r4, r3, r2, r1, p, s1, s2, s3, s4)
else:
return PIVOT(r4[-1], r3[-1], r2[-1], r1[-1], p[-1], s1[-1], s2[-1], s3[-1], s4[-1])
================================================
FILE: jesse/indicators/pma.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
PMA = namedtuple('PMA', ['predict', 'trigger'])
def pma(candles: np.ndarray, source_type: str = "hl2", sequential: bool = False) -> PMA:
"""
Ehlers Predictive Moving Average
:param candles: np.ndarray
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
predict, trigger = pma_fast(source)
if sequential:
return PMA(predict, trigger)
else:
return PMA(predict[-1], trigger[-1])
@njit(cache=True)
def pma_fast(source):
predict = np.full_like(source, np.nan)
trigger = np.full_like(source, np.nan)
wma1 = np.zeros_like(source)
for j in range(6, source.shape[0]):
wma1[j] = ((7 * source[j]) + (6 * source[j -1]) + (5 * source[j -2]) + (4 * source[j -3]) + (3 * source[j -4]) + (2 * source[j -5]) + source[j -6]) / 28
wma2 = ((7 * wma1[j]) + (6 * wma1[j-1]) + (5 * wma1[j -2]) + (4 * wma1[j -3]) + (3 * wma1[j -4]) + (2 * wma1[j -5]) + wma1[j -6]) / 28
predict[j] = (2 * wma1[j]) - wma2
trigger[j] = ((4 * predict[j]) + (3 * predict[j-1]) + (2 * predict[j -2]) + predict[j -3]) / 10
return predict, trigger
================================================
FILE: jesse/indicators/ppo.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse.indicators.ma import ma
def ppo(candles: np.ndarray, fast_period: int = 12, slow_period: int = 26, matype: int = 0, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
PPO - Percentage Price Oscillator
:param candles: np.ndarray
:param fast_period: int - default: 12
:param slow_period: int - default: 26
:param matype: int - default: 0
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if matype == 24 or matype == 29:
fast_ma = ma(candles, period=fast_period, matype=matype, source_type=source_type, sequential=True)
slow_ma = ma(candles, period=slow_period, matype=matype, source_type=source_type, sequential=True)
else:
fast_ma = ma(source, period=fast_period, matype=matype, sequential=True)
slow_ma = ma(source, period=slow_period, matype=matype, sequential=True)
res = 100 * (fast_ma - slow_ma) / slow_ma
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/pvi.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
@njit
def _pvi_fast(source: np.ndarray, volume: np.ndarray) -> np.ndarray:
"""
Numba optimized PVI calculation
"""
pvi = np.zeros_like(source)
pvi[0] = 1000 # Starting value
for i in range(1, len(source)):
if volume[i] > volume[i-1]:
pvi[i] = pvi[i-1] * (1 + (source[i] - source[i-1]) / source[i-1])
else:
pvi[i] = pvi[i-1]
return pvi
def pvi(candles: np.ndarray, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
PVI - Positive Volume Index
The Positive Volume Index (PVI) focuses on days when volume increases from the previous day.
The premise behind the PVI is that price changes accompanied by increased volume are more significant.
:param candles: np.ndarray
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = _pvi_fast(np.ascontiguousarray(source), np.ascontiguousarray(candles[:, 5]))
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/pwma.py
================================================
from functools import reduce
from operator import mul
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import get_candle_source, same_length, slice_candles
def pwma(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Pascals Weighted Moving Average (PWMA)
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
triangle = pascals_triangle(n=period - 1)
swv = sliding_window_view(source, window_shape=period)
res = np.average(swv, weights=triangle, axis=-1)
return same_length(candles, res) if sequential else res[-1]
def pascals_triangle(n: int = None) -> np.ndarray:
"""Pascal's Triangle
Returns a numpy array of the nth row of Pascal's Triangle.
n=4 => triangle: [1, 4, 6, 4, 1]
=> weighted: [0.0625, 0.25, 0.375, 0.25, 0.0625]
"""
n = int(np.fabs(n)) if n is not None else 0
# Calculation
triangle = np.array([combination(n=n, r=i) for i in range(n + 1)])
triangle_sum = np.sum(triangle)
return triangle / triangle_sum
def combination(n, r) -> int:
"""https://stackoverflow.com/questions/4941753/is-there-a-math-ncr-function-in-python"""
n = int(np.fabs(n))
r = int(np.fabs(r))
r = min(n, n - r)
if r == 0:
return 1
numerator = reduce(mul, range(n, n - r, -1), 1)
denominator = reduce(mul, range(1, r + 1), 1)
return numerator // denominator
================================================
FILE: jesse/indicators/qstick.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import same_length, slice_candles
@njit
def _qstick_fast(open_prices: np.ndarray, close_prices: np.ndarray, period: int) -> np.ndarray:
"""
Calculate QStick values using Numba for optimization
"""
# Pre-allocate output array
qstick_values = np.zeros_like(open_prices, dtype=np.float64)
# Calculate close-open difference
diff = close_prices - open_prices
# Calculate moving average of the difference
for i in range(period - 1, len(diff)):
qstick_values[i] = np.mean(diff[i - period + 1:i + 1])
return qstick_values
def qstick(candles: np.ndarray, period: int = 5, sequential: bool = False) -> Union[float, np.ndarray]:
"""
QStick - Moving average of the difference between closing and opening prices
:param candles: np.ndarray
:param period: int - default: 5
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
res = _qstick_fast(
np.ascontiguousarray(candles[:, 1]), # open
np.ascontiguousarray(candles[:, 2]), # close
period
)
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/reflex.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
from .supersmoother import supersmoother_fast
def reflex(candles: np.ndarray, period: int = 20, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Reflex indicator by John F. Ehlers
:param candles: np.ndarray
:param period: int - default: 20
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
ssf = supersmoother_fast(source, period / 2)
rf = reflex_fast(ssf, period)
if sequential:
return rf
else:
return None if np.isnan(rf[-1]) else rf[-1]
@njit(cache=True)
def reflex_fast(ssf, period):
rf = np.full_like(ssf, 0)
ms = np.full_like(ssf, 0)
sums = np.full_like(ssf, 0)
for i in range(ssf.shape[0]):
if i >= period:
slope = (ssf[i - period] - ssf[i]) / period
my_sum = 0
for t in range(1, period + 1):
my_sum = my_sum + (ssf[i] + t * slope) - ssf[i - t]
my_sum /= period
sums[i] = my_sum
ms[i] = 0.04 * sums[i] * sums[i] + 0.96 * ms[i - 1]
if ms[i] > 0:
rf[i] = sums[i] / np.sqrt(ms[i])
return rf
================================================
FILE: jesse/indicators/rma.py
================================================
from typing import Union
import numpy as np
from numba import guvectorize, njit
from jesse.helpers import get_candle_source, slice_candles
def rma(candles: np.ndarray, length: int = 14, source_type="close", sequential=False) -> \
Union[float, np.ndarray]:
"""
Moving average used in RSI. It is the exponentially weighted moving average with alpha = 1 / length.
RETURNS Exponential moving average of x with alpha = 1 / y.
https://www.tradingview.com/pine-script-reference/#fun_rma
:param candles: np.ndarray
:param length: int - default: 14
:param source_type: str - default: close
:param sequential: bool - default: False
:return: Union[float, np.ndarray]
"""
if length < 1:
raise ValueError('Bad parameters.')
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = rma_fast(source, length)
return res if sequential else res[-1]
@njit(cache=True)
def rma_fast(source, _length):
alpha = 1 / _length
newseries = np.copy(source)
out = np.full_like(source, np.nan)
for i in range(source.size):
if np.isnan(newseries[i - 1]):
# Sma in Numba
asum = 0.0
count = 0
for i in range(_length):
asum += source[i]
count += 1
out[i] = asum / count
for i in range(_length, len(source)):
asum += source[i] - source[i - _length]
out[i] = asum / count
newseries[i] = out[-1]
else:
prev = newseries[i - 1]
if np.isnan(prev):
prev = 0
newseries[i] = alpha * source[i] + (1 - alpha) * prev
return newseries
================================================
FILE: jesse/indicators/roc.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def roc(candles: np.ndarray, period: int = 10, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
ROC - Rate of change : ((price/prevPrice)-1)*100
:param candles: np.ndarray
:param period: int - default: 10
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
n = len(source)
res = np.full(n, np.nan, dtype=float)
if n > period:
res[period:] = (source[period:] / source[:-period] - 1) * 100
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/rocp.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def rocp(candles: np.ndarray, period: int = 10, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
ROCP - Rate of change Percentage: (price-prevPrice)/prevPrice
:param candles: np.ndarray
:param period: int - default: 10
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = np.full(source.shape, np.nan, dtype=float)
if len(source) > period:
res[period:] = (source[period:] - source[:-period]) / source[:-period]
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/rocr.py
================================================
import numpy as np
from typing import Union
from jesse.helpers import get_candle_source, slice_candles
def rocr(candles: np.ndarray, period: int = 10, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
ROCR - Rate of change ratio: (price / price_lagged)
:param candles: np.ndarray
:param period: int - default: 10
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Initialize an array of NaNs with the same shape as source
res = np.full(source.shape, np.nan, dtype=float)
# Only compute if there are enough data points
if source.shape[0] > period:
# Compute rate of change ratio using vectorized operation; for indices < period, remains NaN
res[period:] = source[period:] / source[:-period]
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/rocr100.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def rocr100(candles: np.ndarray, period: int = 10, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
ROCR100 - Rate of change ratio 100 scale: (price/prevPrice)*100
:param candles: np.ndarray
:param period: int - default: 10
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Vectorized calculation: for indices >= period, ROCR100 = (source[i] / source[i - period]) * 100; first period set to np.nan
res = np.full(source.shape, np.nan, dtype=float)
res[period:] = (source[period:] / source[:-period]) * 100
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/roofing.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from .high_pass_2_pole import high_pass_2_pole_fast
from .supersmoother import supersmoother_fast
def roofing(candles: np.ndarray, hp_period: int = 48, lp_period: int = 10, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
Roofing Filter indicator by John F. Ehlers
:param candles: np.ndarray
:param hp_period: int - default: 48
:param lp_period: int - default: 10
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
hpf = high_pass_2_pole_fast(source, hp_period)
res = supersmoother_fast(hpf, lp_period)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/rsi.py
================================================
import numpy as np
from typing import Union
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import rsi as rsi_rust
def rsi(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
RSI - Relative Strength Index
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
p = np.asarray(source, dtype=np.float64)
result = rsi_rust(p, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/rsmk.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import get_candle_source
RSMK = namedtuple('RSMK', ['indicator', 'signal'])
def rsmk(candles: np.ndarray, candles_compare: np.ndarray, lookback: int = 90, period: int = 3, signal_period: int = 20,
source_type: str = "close", sequential: bool = False) -> RSMK:
"""
RSMK - Relative Strength
:param candles: np.ndarray
:param candles_compare: np.ndarray
:param lookback: int - default: 90
:param period: int - default: 3
:param signal_period: int - default: 20
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if not sequential and candles.shape[0] > 240:
candles = candles[-240:]
candles_compare = candles_compare[-240:]
source = get_candle_source(candles, source_type=source_type)
source_compare = get_candle_source(candles_compare, source_type=source_type)
# Calculate log ratio of asset to index
log_ratio = np.log(source / source_compare)
# Calculate momentum: difference between current log ratio and the one from 'lookback' periods ago using vectorized operation
mom = np.full_like(log_ratio, np.nan)
if len(log_ratio) > lookback:
mom[lookback:] = log_ratio[lookback:] - log_ratio[:-lookback]
def ema(series: np.ndarray, period_val: float) -> np.ndarray:
alpha = 2.0 / (max(1.0, period_val) + 1.0)
n = series.shape[0]
out = np.full_like(series, np.nan)
# Identify the first valid (non-NaN) index
valid_indices = np.flatnonzero(~np.isnan(series))
if valid_indices.size == 0:
return out
start_idx = valid_indices[0]
segment = series[start_idx:]
m = segment.shape[0]
# Create matrices for vectorized computation
t = np.arange(m).reshape(-1, 1) # shape (m, 1)
i = np.arange(m).reshape(1, -1) # shape (1, m)
lag = t - i
# Compute weights:
# For t >= i, if i == 0 then weight = (1 - alpha)^(t - i), else weight = alpha * (1 - alpha)^(t - i)
weights = np.where(lag < 0, 0, np.where(i == 0, (1 - alpha)**lag, alpha * (1 - alpha)**lag))
ema_segment = np.sum(weights * segment.reshape(1, -1), axis=1)
out[start_idx:] = ema_segment
return out
# Calculate RSMK indicator: EMA of the momentum scaled by 100
rsmk_indicator = ema(mom, period) * 100.0
# Calculate signal line as EMA of the RSMK indicator
rsmk_signal = ema(rsmk_indicator, signal_period)
if not sequential:
rsmk_indicator = rsmk_indicator[-1]
rsmk_signal = rsmk_signal[-1]
return RSMK(rsmk_indicator, rsmk_signal)
================================================
FILE: jesse/indicators/rsx.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def rsx(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Relative Strength Xtra (rsx)
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = rsx_fast(source, period)
return res if sequential else res[-1]
@njit(cache=True)
def rsx_fast(source, period):
# variables
f0 = 0
f8 = 0
# f10 = 0
f18 = 0
f20 = 0
f28 = 0
f30 = 0
f38 = 0
f40 = 0
f48 = 0
f50 = 0
f58 = 0
f60 = 0
f68 = 0
f70 = 0
f78 = 0
f80 = 0
f88 = 0
f90 = 0
# v4 = 0
# v8 = 0
# v10 = 0
v14 = 0
# v18 = 0
v20 = 0
# vC = 0
# v1C = 0
res = np.full_like(source, np.nan)
for i in range(period, source.size):
if f90 == 0:
f90 = 1.0
f0 = 0.0
f88 = period - 1.0 if period >= 6 else 5.0
f8 = 100.0 * source[i]
f18 = 3.0 / (period + 2.0)
f20 = 1.0 - f18
else:
f90 = f88 + 1 if f88 <= f90 else f90 + 1
f10 = f8
f8 = 100 * source[i]
v8 = f8 - f10
f28 = f20 * f28 + f18 * v8
f30 = f18 * f28 + f20 * f30
vC = f28 * 1.5 - f30 * 0.5
f38 = f20 * f38 + f18 * vC
f40 = f18 * f38 + f20 * f40
v10 = f38 * 1.5 - f40 * 0.5
f48 = f20 * f48 + f18 * v10
f50 = f18 * f48 + f20 * f50
v14 = f48 * 1.5 - f50 * 0.5
f58 = f20 * f58 + f18 * abs(v8)
f60 = f18 * f58 + f20 * f60
v18 = f58 * 1.5 - f60 * 0.5
f68 = f20 * f68 + f18 * v18
f70 = f18 * f68 + f20 * f70
v1C = f68 * 1.5 - f70 * 0.5
f78 = f20 * f78 + f18 * v1C
f80 = f18 * f78 + f20 * f80
v20 = f78 * 1.5 - f80 * 0.5
if f88 >= f90 and f8 != f10:
f0 = 1.0
if f88 == f90 and f0 == 0.0:
f90 = 0.0
if f88 < f90 and v20 > 0.0000000001:
v4 = (v14 / v20 + 1.0) * 50.0
v4 = min(v4, 100.0)
v4 = max(v4, 0.0)
else:
v4 = 50.0
res[i] = v4
return res
================================================
FILE: jesse/indicators/rvi.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import get_candle_source, same_length, slice_candles
from jesse.indicators.ma import ma
from jesse.indicators.mean_ad import mean_ad
from jesse.indicators.median_ad import median_ad
def rvi(candles: np.ndarray, period: int = 10, ma_len: int = 14, matype: int = 1, devtype: int = 0, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
RVI - Relative Volatility Index
:param candles: np.ndarray
:param period: int - default: 10
:param ma_len: int - default: 14
:param matype: int - default: 1
:param devtype: int - default: 0
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if matype == 24 or matype == 29:
raise ValueError("VWMA (matype 24) and VWAP (matype 29) cannot be used in rvi indicator.")
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if devtype == 0:
dev = _rolling_std(source, period)
elif devtype == 1:
dev = mean_ad(source, period, sequential=True)
elif devtype == 2:
dev = median_ad(source, period, sequential=True)
diff = np.diff(source)
diff = same_length(source, diff)
up = np.nan_to_num(np.where(diff <= 0, 0, dev))
down = np.nan_to_num(np.where(diff > 0, 0, dev))
up_avg = ma(up, period=ma_len, matype=matype, sequential=True)
down_avg = ma(down, period=ma_len, matype=matype, sequential=True)
# Avoid division by zero
denominator = up_avg + down_avg
with np.errstate(divide='ignore', invalid='ignore'):
result = np.where(denominator != 0, 100 * (up_avg / denominator), 50)
return result if sequential else result[-1]
def _rolling_std(arr: np.ndarray, window: int) -> np.ndarray:
if len(arr) < window:
return np.full(len(arr), np.nan)
windows = sliding_window_view(arr, window_shape=window)
stds = np.std(windows, axis=1, ddof=0)
return np.concatenate((np.full(window - 1, np.nan), stds))
================================================
FILE: jesse/indicators/safezonestop.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import np_shift, slice_candles
@njit(cache=True)
def wilder_smoothing_numba(raw: np.ndarray, period: int) -> np.ndarray:
smoothed = np.zeros_like(raw)
alpha = 1 - 1/period
smoothed[0] = raw[0]
for i in range(1, len(raw)):
smoothed[i] = alpha * smoothed[i-1] + raw[i]
return smoothed
@njit(cache=True)
def rolling_max_numba(arr: np.ndarray, window: int) -> np.ndarray:
n = len(arr)
result = np.empty_like(arr)
# Handle first window-1 elements
for i in range(window-1):
result[i] = np.max(arr[:i+1])
# Handle remaining elements with sliding window
for i in range(window-1, n):
result[i] = np.max(arr[i-window+1:i+1])
return result
@njit(cache=True)
def rolling_min_numba(arr: np.ndarray, window: int) -> np.ndarray:
n = len(arr)
result = np.empty_like(arr)
# Handle first window-1 elements
for i in range(window-1):
result[i] = np.min(arr[:i+1])
# Handle remaining elements with sliding window
for i in range(window-1, n):
result[i] = np.min(arr[i-window+1:i+1])
return result
def safezonestop(candles: np.ndarray, period: int = 22, mult: float = 2.5, max_lookback: int = 3,
direction: str = "long", sequential: bool = False) -> Union[float, np.ndarray]:
"""
Safezone Stops - Numba optimized version
:param candles: np.ndarray
:param period: int - default: 22
:param mult: float - default: 2.5
:param max_lookback: int - default: 3
:param direction: str - default: long
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
last_high = np_shift(high, 1, fill_value=np.nan)
last_low = np_shift(low, 1, fill_value=np.nan)
diff_high = high - last_high
diff_low = last_low - low
diff_high = np.where(np.isnan(diff_high), 0, diff_high)
diff_low = np.where(np.isnan(diff_low), 0, diff_low)
raw_plus_dm = np.where((diff_high > diff_low) & (diff_high > 0), diff_high, 0)
raw_minus_dm = np.where((diff_low > diff_high) & (diff_low > 0), diff_low, 0)
plus_dm = wilder_smoothing_numba(raw_plus_dm, period)
minus_dm = wilder_smoothing_numba(raw_minus_dm, period)
if direction == "long":
intermediate = last_low - mult * minus_dm
res = rolling_max_numba(intermediate, max_lookback)
else:
intermediate = last_high + mult * plus_dm
res = rolling_min_numba(intermediate, max_lookback)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/sar.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from numba import njit
def sar(candles: np.ndarray, acceleration: float = 0.02, maximum: float = 0.2, sequential: bool = False) -> Union[float, np.ndarray]:
"""
SAR - Parabolic SAR
:param candles: np.ndarray
:param acceleration: float - default: 0.02
:param maximum: float - default: 0.2
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
# Assuming candle format where index 3 is high and index 4 is low
high = candles[:, 3]
low = candles[:, 4]
n = len(candles)
if n == 0:
return np.array([])
if n < 2:
return low[-1]
# Use numba-compiled function to calculate SAR values
sar_values = _fast_sar(high, low, acceleration, maximum, n)
return sar_values if sequential else sar_values[-1]
@njit(cache=True)
def _fast_sar(high, low, acceleration, maximum, n):
sar_values = np.zeros(n)
if high[1] > high[0]:
uptrend = True
sar_values[0] = low[0]
ep = high[0] # extreme point
else:
uptrend = False
sar_values[0] = high[0]
ep = low[0]
af = acceleration # initial acceleration factor
for i in range(1, n):
prev_sar = sar_values[i - 1]
if uptrend:
sar_temp = prev_sar + af * (ep - prev_sar)
if i >= 2:
sar_temp = min(sar_temp, low[i - 1], low[i - 2])
else:
sar_temp = min(sar_temp, low[i - 1])
else:
sar_temp = prev_sar - af * (prev_sar - ep)
if i >= 2:
sar_temp = max(sar_temp, high[i - 1], high[i - 2])
else:
sar_temp = max(sar_temp, high[i - 1])
if uptrend:
if low[i] < sar_temp:
sar_temp = ep
uptrend = False
af = acceleration # reset acceleration factor
ep = low[i]
else:
if high[i] > ep:
ep = high[i]
af = af + acceleration
if af > maximum:
af = maximum
else:
if high[i] > sar_temp:
sar_temp = ep
uptrend = True
af = acceleration
ep = high[i]
else:
if low[i] < ep:
ep = low[i]
af = af + acceleration
if af > maximum:
af = maximum
sar_values[i] = sar_temp
return sar_values
================================================
FILE: jesse/indicators/settings.jsonc
================================================
{
"[python]": {
"editor.defaultFormatter": "ms-python.autopep8",
"editor.formatOnSave": true,
"editor.formatOnType": true,
"editor.rulers": [160],
"editor.codeActionsOnSave": {
"source.organizeImports": "explicit"
}
},
"autopep8.args": [
"--max-line-length=160",
"--aggressive",
"--aggressive"
],
"python.formatting.provider": "autopep8",
"python.linting.enabled": true,
"python.linting.lintOnSave": true,
"python.linting.pylintEnabled": true
}
================================================
FILE: jesse/indicators/sinwma.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import get_candle_source, same_length, slice_candles
def sinwma(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Sine Weighted Moving Average (SINWMA)
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
sines = np.array(
[np.sin((i + 1) * np.pi / (period + 1)) for i in range(period)]
)
w = sines / sines.sum()
swv = sliding_window_view(source, window_shape=period)
res = np.average(swv, weights=w, axis=-1)
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/skew.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from scipy import stats
from jesse.helpers import get_candle_source, same_length, slice_candles
def skew(candles: np.ndarray, period: int = 5, source_type: str = "hl2", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Skewness
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "hl2"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
swv = sliding_window_view(source, window_shape=period)
skewness = stats.skew(swv, axis=-1)
res = same_length(source, skewness)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/sma.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import sma as sma_rust
def sma(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
SMA - Simple Moving Average
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = sma_rust(source, period)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/smma.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def smma(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
SMMA - Smoothed Moving Average
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = numpy_ewma(source, period)
return res if sequential else res[-1]
def numpy_ewma(data, window):
"""
:param data:
:param window:
:return:
"""
alpha = 1 / window
# scale = 1 / (1 - alpha)
n = data.shape[0]
scale_arr = (1 - alpha) ** (-1 * np.arange(n))
weights = (1 - alpha) ** np.arange(n)
pw0 = (1 - alpha) ** (n - 1)
mult = data * pw0 * scale_arr
cumsums = mult.cumsum()
return cumsums * scale_arr[::-1] / weights.cumsum()
================================================
FILE: jesse/indicators/squeeze_momentum.py
================================================
from collections import namedtuple
from .bollinger_bands import bollinger_bands
from .sma import sma
from .trange import trange
from .linearreg import linearreg
from .stddev import stddev
import numpy as np
SqueezeMomentum = namedtuple('SqueezeMomentum', ['squeeze', 'momentum', 'momentum_signal'])
def squeeze_momentum(candles: np.ndarray, length: int = 20, mult: float = 2.0, length_kc: int = 20, mult_kc: float = 1.5, sequential: bool = True) -> SqueezeMomentum:
"""
@author lazyBear
credits: https://www.tradingview.com/script/nqQ1DT5a-Squeeze-Momentum-Indicator-LazyBear/
squeeze_momentum
:param candles: np.ndarray
:length: int - default: 20
:mult: float - default: 2.0
:length_kc: float - default: 2.0
:mult_kc: float - default: 1.5
:sequential: bool - default: True
:return: SqueezeMomentum(squeeze, momentum, momentum_signal)
"""
# calculate bollinger bands
basis = sma(candles, length, sequential=True)
dev = mult_kc * stddev(candles, length, sequential=True)
upper_bb = basis + dev
lower_bb = basis - dev
# calculate KC
ma = sma(candles, length_kc, sequential=True)
range_ma = sma(trange(candles, sequential=True), period=length_kc, sequential=True)
upper_kc = ma + range_ma * mult_kc
lower_kc = ma - range_ma * mult_kc
sqz = []
for i in range(len(lower_bb)):
sqz_on = (lower_bb[i] > lower_kc[i]) and (upper_bb[i] < upper_kc[i])
sqz_off = (lower_bb[i] < lower_kc[i]) and (upper_bb[i] > upper_kc[i])
noSqz = (sqz_on == False) and (sqz_off == False)
sqz.append(0 if noSqz else (-1 if sqz_on else 1))
highs = np.nan_to_num(_highest(candles[:, 3], length_kc), 0)
lows = np.nan_to_num(_lowest(candles[:, 4], length_kc), 0)
sma_arr = np.nan_to_num(sma(candles, period=length_kc, sequential=True))
momentum = []
for i in range(len(highs)):
momentum.append(candles[:, 2][i] - ((highs[i] + lows[i]) / 2 + sma_arr[i]) / 2)
momentum = linearreg(np.array(momentum), period=length_kc, sequential=True)
momentum_signal = []
for i in range(len(momentum) - 1):
if momentum[i + 1] > 0:
momentum_signal.append(1 if momentum[i + 1] > momentum[i] else 2)
else:
momentum_signal.append(-1 if momentum[i + 1] < momentum[i] else -2)
if sequential:
return SqueezeMomentum(sqz, momentum, momentum_signal)
else:
return SqueezeMomentum(sqz[-1], momentum[-1], momentum_signal[-1])
def _highest(values, length):
# Ensure values is a NumPy array for efficient computation
values = np.asarray(values)
# Initialize an array to hold the highest values
highest_values = np.full(values.shape, np.nan)
# Compute the highest value for each window
for i in range(length - 1, len(values)):
highest_values[i] = np.max(values[i - length + 1:i + 1])
return highest_values
def _lowest(values, length):
# Ensure values is a NumPy array for efficient computation
values = np.asarray(values)
# Initialize an array to hold the lowest values
lowest_values = np.full(values.shape, np.nan)
# Compute the lowest value for each window
for i in range(length - 1, len(values)):
lowest_values[i] = np.min(values[i - length + 1:i + 1])
return lowest_values
================================================
FILE: jesse/indicators/sqwma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def sqwma(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Squared Weighted Moving Average
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = sqwma_fast(source, period)
return res if sequential else res[-1]
@njit(cache=True)
def sqwma_fast(source, period):
newseries = np.copy(source)
for j in range(period + 1, source.shape[0]):
my_sum = 0.0
weightSum = 0.0
for i in range(period - 1):
weight = np.power(period - i, 2)
my_sum += (source[j - i] * weight)
weightSum += weight
newseries[j] = my_sum / weightSum
return newseries
================================================
FILE: jesse/indicators/srsi.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
# Import the high-performance Rust implementation
from jesse_rust import srsi as srsi_rust # type: ignore
StochasticRSI = namedtuple('StochasticRSI', ['k', 'd'])
def srsi(
candles: np.ndarray,
period: int = 14,
period_stoch: int = 14,
k: int = 3,
d: int = 3,
source_type: str = "close",
sequential: bool = False,
) -> StochasticRSI:
"""Stochastic RSI – uses Rust implementation for speed."""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
k_line, d_line = srsi_rust(source.astype(np.float64), period, period_stoch, k, d)
if sequential:
return StochasticRSI(k_line, d_line)
else:
return StochasticRSI(float(k_line[-1]), float(d_line[-1]))
================================================
FILE: jesse/indicators/srwma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def srwma(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Square Root Weighted Moving Average
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = srwma_fast(source, period)
return res if sequential else res[-1]
@njit(cache=True)
def srwma_fast(source, period):
newseries = np.copy(source)
for j in range(period + 1, source.shape[0]):
my_sum = 0.0
weightSum = 0.0
for i in range(period - 1):
weight = np.power(period - i, 0.5)
my_sum += (source[j - i] * weight)
weightSum += weight
newseries[j] = my_sum / weightSum
return newseries
================================================
FILE: jesse/indicators/stc.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def ema(series: np.ndarray, period: int) -> np.ndarray:
"""Calculates the Exponential Moving Average (EMA) for a series using a simple recursive formula."""
alpha = 2 / (period + 1)
out = np.empty_like(series, dtype=float)
out[0] = series[0]
for i in range(1, len(series)):
out[i] = alpha * series[i] + (1 - alpha) * out[i - 1]
return out
def stoch(series: np.ndarray, period: int) -> np.ndarray:
"""Calculates the stochastic oscillator for a series over the specified period."""
result = np.full_like(series, np.nan, dtype=float)
for i in range(len(series)):
if i < period - 1:
result[i] = np.nan
else:
window = series[i - period + 1: i + 1]
low = np.min(window)
high = np.max(window)
if high == low:
result[i] = 0
else:
result[i] = 100 * ((series[i] - low) / (high - low))
return result
def stc(candles: np.ndarray, fast_period: int = 23, slow_period: int = 50, k_period: int = 10, d1_period: int = 3, d2_period: int = 3,
source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
STC - Schaff Trend Cycle (Oscillator)
The indicator is computed as follows:
1. macd = EMA(src, fast_period) - EMA(src, slow_period)
2. k = stoch(macd, k_period) with NaNs replaced by 0
3. d = EMA(k, d1_period) -> First %D
4. kd = stoch(d, k_period) with NaNs replaced by 0
5. stc_val = EMA(kd, d2_period) clamped between 0 and 100
:param candles: np.ndarray of candles
:param fast_period: int - default: 23
:param slow_period: int - default: 50
:param k_period: int - default: 10, cycle length for stoch computation
:param d1_period: int - default: 3, used for first EMA smoothing of k
:param d2_period: int - default: 3, used for EMA smoothing of kd
:param source_type: str - default: "close"
:param sequential: bool - default: False. When False, returns only the last value.
:return: float or np.ndarray depending on sequential
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
ema_fast = ema(source, fast_period)
ema_slow = ema(source, slow_period)
macd = ema_fast - ema_slow
k = stoch(macd, k_period)
k = np.nan_to_num(k, nan=0)
d_val = ema(k, d1_period)
kd = stoch(d_val, k_period)
kd = np.nan_to_num(kd, nan=0)
stc_val = ema(kd, d2_period)
stc_val = np.clip(stc_val, 0, 100)
return stc_val if sequential else stc_val[-1]
================================================
FILE: jesse/indicators/stddev.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def stddev(candles: np.ndarray, period: int = 5, nbdev: float = 1, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
STDDEV - Standard Deviation
:param candles: np.ndarray
:param period: int - default: 5
:param nbdev: float - default: 1
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
n = len(source)
# Initialize result array with nan values
result = np.full(n, np.nan, dtype=float)
if n < period:
# Not enough data for full period, result remains as nans
output = result
else:
# Create rolling windows using numpy's sliding_window_view
windows = np.lib.stride_tricks.sliding_window_view(source, window_shape=period)
# Compute standard deviation over the rolling windows using population std (ddof=0) and multiply by nbdev
rolling_std = np.std(windows, axis=1, ddof=0) * nbdev
# Fill the result array from index 'period - 1' onward with the computed rolling std
result[period - 1:] = rolling_std
output = result
return output if sequential else output[-1]
================================================
FILE: jesse/indicators/stiffness.py
================================================
from collections import namedtuple
from .sma import sma
from .ema import ema
from .stddev import stddev
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def stiffness(candles: np.ndarray, ma_length: int = 100, stiff_length: int = 60, stiff_smooth: int = 3, source_type: str = "close") -> float:
"""
@author daviddtech
credits: https://www.tradingview.com/script/MOw6mUQl-Stiffness-Indicator-DaviddTech
STIFNESS - Stifness
:param candles: np.ndarray
:param ma_length: int - default: 100
:param stiff_length: int - default: 60
:param stiff_smooth: int - default: 3
:param source_type: str - default: "close"
:return: Stiffness(stiffness, threshold)
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, False)
source = get_candle_source(candles, source_type=source_type)
bound_stiffness = sma(source, ma_length, sequential=True) - 0.2 * \
stddev(source, ma_length, sequential=True)
sum_above_stiffness = _count_price_exceed_series(source, bound_stiffness, stiff_length)
return ema(np.array(sum_above_stiffness) * 100 / stiff_length, period=stiff_smooth)
def _count_price_exceed_series(close_prices, art_series, length):
ex_counts = []
for i in range(len(close_prices)):
if i < length:
ex_counts.append(0)
continue
count = 0
for j in range(i - length + 1, i + 1):
if close_prices[j] > art_series[j]:
count += 1
ex_counts.append(count)
return ex_counts
================================================
FILE: jesse/indicators/stochastic.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
# Import the high-performance Rust implementation
from jesse_rust import stoch as stoch_rust # type: ignore
Stochastic = namedtuple('Stochastic', ['k', 'd'])
def stoch(candles: np.ndarray, fastk_period: int = 14, slowk_period: int = 3, slowk_matype: int = 0,
slowd_period: int = 3, slowd_matype: int = 0, sequential: bool = False) -> Stochastic:
"""
The Stochastic Oscillator
:param candles: np.ndarray
:param fastk_period: int - default: 14
:param slowk_period: int - default: 3
:param slowk_matype: int - default: 0
:param slowd_period: int - default: 3
:param slowd_matype: int - default: 0
:param sequential: bool - default: False
:return: Stochastic(k, d)
"""
if any(matype in (24, 29) for matype in (slowk_matype, slowd_matype)):
raise ValueError("VWMA (matype 24) and VWAP (matype 29) cannot be used in stochastic indicator.")
candles = slice_candles(candles, sequential)
# Convert to float64 for Rust compatibility
candles_f64 = np.asarray(candles, dtype=np.float64)
# Call the Rust implementation
k, d = stoch_rust(candles_f64, fastk_period, slowk_period, slowk_matype, slowd_period, slowd_matype)
if sequential:
return Stochastic(k, d)
else:
return Stochastic(k[-1], d[-1])
================================================
FILE: jesse/indicators/stochf.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
# Import the high-performance Rust implementation
from jesse_rust import stochf as stochf_rust # type: ignore
StochasticFast = namedtuple('StochasticFast', ['k', 'd'])
def stochf(candles: np.ndarray, fastk_period: int = 5, fastd_period: int = 3, fastd_matype: int = 0,
sequential: bool = False) -> StochasticFast:
"""
Stochastic Fast
:param candles: np.ndarray
:param fastk_period: int - default: 5
:param fastd_period: int - default: 3
:param fastd_matype: int - default: 0
:param sequential: bool - default: False
:return: StochasticFast(k, d)
"""
if fastd_matype == 24 or fastd_matype == 29:
raise ValueError("VWMA (matype 24) and VWAP (matype 29) cannot be used in stochf indicator.")
candles = slice_candles(candles, sequential)
# Convert to float64 for Rust compatibility
candles_f64 = np.asarray(candles, dtype=np.float64)
# Call the Rust implementation
k, d = stochf_rust(candles_f64, fastk_period, fastd_period, fastd_matype)
if sequential:
return StochasticFast(k, d)
else:
return StochasticFast(k[-1], d[-1])
================================================
FILE: jesse/indicators/supersmoother.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def supersmoother(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Super Smoother Filter 2pole Butterworth
This indicator was described by John F. Ehlers
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = supersmoother_fast(source, period)
return res if sequential else res[-1]
@njit(cache=True)
def supersmoother_fast(source, period):
a = np.exp(-1.414 * np.pi / period)
b = 2 * a * np.cos(1.414 * np.pi / period)
newseries = np.copy(source)
for i in range(2, source.shape[0]):
newseries[i] = (1 + a ** 2 - b) / 2 * (source[i] + source[i - 1]) \
+ b * newseries[i - 1] - a ** 2 * newseries[i - 2]
return newseries
================================================
FILE: jesse/indicators/supersmoother_3_pole.py
================================================
from typing import Union
import numpy as np
try:
from numba import njit
except ImportError:
njit = lambda a : a
from jesse.helpers import get_candle_source, slice_candles
def supersmoother_3_pole(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> \
Union[
float, np.ndarray]:
"""
Super Smoother Filter 3pole Butterworth
This indicator was described by John F. Ehlers
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = supersmoother_fast(source, period)
return res if sequential else res[-1]
@njit(cache=True)
def supersmoother_fast(source, period):
a = np.exp(-np.pi / period)
b = 2 * a * np.cos(1.738 * np.pi / period)
c = a ** 2
newseries = np.copy(source)
for i in range(3, source.shape[0]):
newseries[i] = (1 - c ** 2 - b + b * c) * source[i] \
+ (b + c) * newseries[i - 1] + (-c - b * c) * newseries[i - 2] + (c ** 2) * newseries[i - 3]
return newseries
================================================
FILE: jesse/indicators/supertrend.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import slice_candles
SuperTrend = namedtuple('SuperTrend', ['trend', 'changed'])
def supertrend(candles: np.ndarray, period: int = 10, factor: float = 3, sequential: bool = False) -> SuperTrend:
"""
SuperTrend indicator optimized with numba and loop-based calculations.
:param candles: np.ndarray - candle data
:param period: period for ATR calculation
:param factor: multiplier for the bands
:param sequential: if True, returns full arrays; else, returns last value
:return: SuperTrend named tuple with trend and changed arrays/values
"""
candles = slice_candles(candles, sequential)
atr = atr_loop(candles[:, 3], candles[:, 4], candles[:, 2], period)
super_trend, changed = supertrend_fast(candles, atr, factor, period)
if sequential:
return SuperTrend(super_trend, changed)
else:
return SuperTrend(super_trend[-1], changed[-1])
@njit(cache=True)
def atr_loop(high, low, close, period):
n = len(close)
tr = np.empty(n, dtype=np.float64)
tr[0] = high[0] - low[0]
for i in range(1, n):
diff1 = high[i] - low[i]
diff2 = np.abs(high[i] - close[i-1])
diff3 = np.abs(low[i] - close[i-1])
# manual max of the three differences
if diff1 >= diff2 and diff1 >= diff3:
tr[i] = diff1
elif diff2 >= diff1 and diff2 >= diff3:
tr[i] = diff2
else:
tr[i] = diff3
atr = np.empty(n, dtype=np.float64)
# Set initial values to NaN for indices before period-1
for i in range(period - 1):
atr[i] = np.nan
# First ATR value is the simple average of the first 'period' TR values
sum_init = 0.0
for i in range(period):
sum_init += tr[i]
atr[period - 1] = sum_init / period
# Recursive ATR calculation
for i in range(period, n):
atr[i] = ((atr[i-1] * (period - 1)) + tr[i]) / period
return atr
@njit(cache=True)
def supertrend_fast(candles, atr, factor, period):
n = len(candles)
super_trend = np.zeros(n, dtype=np.float64)
changed = np.zeros(n, dtype=np.int8)
# Precompute basic bands and initialize band arrays
upper_basic = np.empty(n, dtype=np.float64)
lower_basic = np.empty(n, dtype=np.float64)
upper_band = np.empty(n, dtype=np.float64)
lower_band = np.empty(n, dtype=np.float64)
for i in range(n):
mid = (candles[i, 3] + candles[i, 4]) / 2.0
upper_basic[i] = mid + factor * atr[i]
lower_basic[i] = mid - factor * atr[i]
upper_band[i] = upper_basic[i]
lower_band[i] = lower_basic[i]
# Set the initial supertrend for index period-1
idx = period - 1
if candles[idx, 2] <= upper_band[idx]:
super_trend[idx] = upper_band[idx]
else:
super_trend[idx] = lower_band[idx]
changed[idx] = 0
# Combined loop: update bands and compute supertrend
for i in range(period, n):
p = i - 1
prevClose = candles[p, 2]
# Update upper_band
if prevClose <= upper_band[p]:
if upper_basic[i] < upper_band[p]:
upper_band[i] = upper_basic[i]
else:
upper_band[i] = upper_band[p]
else:
upper_band[i] = upper_basic[i]
# Update lower_band
if prevClose >= lower_band[p]:
if lower_basic[i] > lower_band[p]:
lower_band[i] = lower_basic[i]
else:
lower_band[i] = lower_band[p]
else:
lower_band[i] = lower_basic[i]
# Compute current supertrend based on previous supertrend value
if super_trend[p] == upper_band[p]:
if candles[i, 2] <= upper_band[i]:
super_trend[i] = upper_band[i]
changed[i] = 0
else:
super_trend[i] = lower_band[i]
changed[i] = 1
else: # super_trend[p] equals lower_band[p]
if candles[i, 2] >= lower_band[i]:
super_trend[i] = lower_band[i]
changed[i] = 0
else:
super_trend[i] = upper_band[i]
changed[i] = 1
return super_trend, changed
================================================
FILE: jesse/indicators/support_resistance_with_break.py
================================================
from collections import namedtuple
import numpy as np
from .ema import ema
SupportResistanceWithBreaks = namedtuple('SupportResistanceWithBreaks', ['support', 'resistance', 'red_break', 'green_break', 'bear_wick', 'bull_wick'])
def support_resistance_with_breaks(candles: np.ndarray, left_bars: int = 15, right_bars: int = 15, vol_threshold: int = 20) -> SupportResistanceWithBreaks:
"""
support_resistance_with_breaks
@author LuxAlgo
credits: https://www.tradingview.com/script/JDFoWQbL-Support-and-Resistance-Levels-with-Breaks-LuxAlgo
:param candles: np.ndarray
:param left_bars: int - default: 15
:param right_bars: int - default: 15
:param vol_threshold: int - default: 20
:return: SupportResistanceWithBreaks(support, resistance, red_break, green_break, bear_wick, bull_wick)
"""
resistance = _resistance(candles[:, 3], left_bars, right_bars)
support = _support(candles[:, 4], left_bars, right_bars)
short = ema(candles[:, 5], 5)
long = ema(candles[:, 5], 10)
osc = 100 * (short - long) / long
last_candles = candles[0]
red_break = True if last_candles[2] < support and not abs(
last_candles[1] - last_candles[2]) < abs(last_candles[1] - last_candles[3]) and osc > vol_threshold else False
green_break = True if last_candles[2] > resistance and abs(
last_candles[1] - last_candles[4]) > abs(last_candles[1] - last_candles[2]) and osc > vol_threshold else False
bull_wick = True if last_candles[2] > resistance and abs(last_candles[1] - last_candles[4]) > abs(last_candles[1] - last_candles[2]) else False
bear_wick = True if last_candles[2] < support and abs(last_candles[1] - last_candles[2]) < abs(last_candles[1] - last_candles[3]) else False
return SupportResistanceWithBreaks(support, resistance, red_break, green_break, bear_wick, bull_wick)
def _resistance(source, left_bars, right_bars):
pivot_highs = [None] * len(source) # Initialize result list with None
for i in range(left_bars, len(source) - right_bars):
is_pivot_high = True
# Check left bars for higher high
for j in range(1, left_bars + 1):
if source[i] <= source[i - j]:
is_pivot_high = False
break
# Check right bars for higher high
if is_pivot_high:
for j in range(1, right_bars + 1):
if source[i] <= source[i + j]:
is_pivot_high = False
break
if is_pivot_high:
is_pivot_high = source[i]
pivot_highs[i] = is_pivot_high
next_valid = None
first_value = None
for i in range(len(pivot_highs)):
if pivot_highs[i] is False:
pivot_highs[i] = next_valid
elif pivot_highs[i] is not None: # Update next_valid if it's not False or None
next_valid = pivot_highs[i]
first_value = i if first_value is None else first_value
pivot_highs[:first_value - 1] = [pivot_highs[first_value]] * len(pivot_highs[:first_value - 1])
pivot_highs[-right_bars:] = [pivot_highs[-right_bars - 1]] * len(pivot_highs[-right_bars:])
return pivot_highs[-1]
def _support(source, left_bars, right_bars):
pivot_lows = [None] * len(source) # Initialize result list with None
for i in range(left_bars, len(source) - right_bars):
is_pivot_low = True
# Check left bars for lower low
for j in range(1, left_bars + 1):
if source[i] >= source[i - j]:
is_pivot_low = False
break
# Check right bars for lower low
if is_pivot_low:
for j in range(1, right_bars + 1):
if source[i] >= source[i + j]:
is_pivot_low = False
break
if is_pivot_low:
is_pivot_low = source[i]
pivot_lows[i] = is_pivot_low
next_valid = None
first_value = None
for i in range(len(pivot_lows)):
if pivot_lows[i] is False:
pivot_lows[i] = next_valid
elif pivot_lows[i] is not None: # Update next_valid if it's not False or None
next_valid = pivot_lows[i]
first_value = i if first_value is None else first_value
pivot_lows[:first_value - 1] = [pivot_lows[first_value]] * len(pivot_lows[:first_value - 1])
pivot_lows[-right_bars:] = [pivot_lows[-right_bars - 1]] * len(pivot_lows[-right_bars:])
return pivot_lows[-1]
================================================
FILE: jesse/indicators/swma.py
================================================
from math import floor
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import get_candle_source, same_length, slice_candles
def swma(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Symmetric Weighted Moving Average (SWMA)
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
triangle = symmetric_triangle(period)
swv = sliding_window_view(source, window_shape=period)
res = np.average(swv, weights=triangle, axis=-1)
return same_length(candles, res) if sequential else res[-1]
def symmetric_triangle(n: int = None) -> np.ndarray:
"""Symmetric Triangle with n >= 2
Returns a numpy array of the nth row of Symmetric Triangle.
n=4 => triangle: [1, 2, 2, 1]
=> weighted: [0.16666667 0.33333333 0.33333333 0.16666667]
"""
n = int(np.fabs(n)) if n is not None else 2
triangle = None
if n == 2:
triangle = [1, 1]
if n > 2:
if n % 2 == 0:
front = [i + 1 for i in range(floor(n / 2))]
triangle = front + front[::-1]
else:
front = [i + 1 for i in range(floor(0.5 * (n + 1)))]
triangle = front.copy()
front.pop()
triangle += front[::-1]
triangle_sum = np.sum(triangle)
return triangle / triangle_sum
================================================
FILE: jesse/indicators/t3.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def t3(candles: np.ndarray, period: int = 5, vfactor: float = 0, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
T3 - Triple Exponential Moving Average (T3)
The T3 moving average is a type of moving average that uses the DEMA (Double Exponential Moving Average)
calculations multiple times with a volume factor weighting.
:param candles: np.ndarray
:param period: int - default: 5
:param vfactor: float - default: 0
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Check if jesse_rust is available
try:
import jesse_rust
if len(candles.shape) == 1:
# Handle case where source array is passed directly
# Convert to candles format for Rust function
mock_candles = np.zeros((len(candles), 6))
mock_candles[:, 2] = candles # Put source in close column
result = jesse_rust.t3(mock_candles, period, vfactor, "close", sequential)
else:
candles = slice_candles(candles, sequential)
result = jesse_rust.t3(candles, period, vfactor, source_type, sequential)
return result if sequential else result[-1]
except ImportError:
# Fallback to pure Python implementation
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
k = 2 / (period + 1)
# Calculate weights based on volume factor
w1 = -vfactor ** 3
w2 = 3 * vfactor ** 2 + 3 * vfactor ** 3
w3 = -6 * vfactor ** 2 - 3 * vfactor - 3 * vfactor ** 3
w4 = 1 + 3 * vfactor + vfactor ** 3 + 3 * vfactor ** 2
t3 = _t3_fast_python(source, k, w1, w2, w3, w4)
return t3 if sequential else t3[-1]
def _t3_fast_python(source: np.ndarray, k: float, w1: float, w2: float, w3: float, w4: float) -> np.ndarray:
"""
Pure Python implementation of T3 calculation
"""
n = len(source)
e1 = np.zeros(n)
e2 = np.zeros(n)
e3 = np.zeros(n)
e4 = np.zeros(n)
e5 = np.zeros(n)
e6 = np.zeros(n)
t3 = np.zeros(n)
# Initialize first values
e1[0] = source[0]
e2[0] = e1[0]
e3[0] = e2[0]
e4[0] = e3[0]
e5[0] = e4[0]
e6[0] = e5[0]
k_rev = 1 - k
# Calculate all EMAs in a single loop for better cache utilization
for i in range(1, n):
e1[i] = k * source[i] + k_rev * e1[i-1]
e2[i] = k * e1[i] + k_rev * e2[i-1]
e3[i] = k * e2[i] + k_rev * e3[i-1]
e4[i] = k * e3[i] + k_rev * e4[i-1]
e5[i] = k * e4[i] + k_rev * e5[i-1]
e6[i] = k * e5[i] + k_rev * e6[i-1]
t3[i] = w1 * e6[i] + w2 * e5[i] + w3 * e4[i] + w4 * e3[i]
return t3
================================================
FILE: jesse/indicators/tema.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import tema as tema_rust
def tema(candles: np.ndarray, period: int = 9, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
TEMA - Triple Exponential Moving Average
:param candles: np.ndarray
:param period: int - default: 9
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if source.size == 0:
return np.nan if not sequential else np.array([])
res = tema_rust(source, period)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/trange.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def trange(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
TRANGE - True Range
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
close = candles[:, 2]
true_range = np.empty_like(high)
true_range[0] = high[0] - low[0]
if len(candles) > 1:
diff_hl = high[1:] - low[1:]
diff_hpc = np.abs(high[1:] - close[:-1])
diff_lpc = np.abs(low[1:] - close[:-1])
true_range[1:] = np.maximum(np.maximum(diff_hl, diff_hpc), diff_lpc)
res = true_range
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/trendflex.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
from .supersmoother import supersmoother_fast
def trendflex(candles: np.ndarray, period: int = 20, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Trendflex indicator by John F. Ehlers
:param candles: np.ndarray
:param period: int - default: 20
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
ssf = supersmoother_fast(source, period / 2)
tf = trendflex_fast(ssf, period)
if sequential:
return tf
else:
return None if np.isnan(tf[-1]) else tf[-1]
@njit(cache=True)
def trendflex_fast(ssf, period):
tf = np.full_like(ssf, 0)
ms = np.full_like(ssf, 0)
sums = np.full_like(ssf, 0)
for i in range(ssf.shape[0]):
if i >= period:
my_sum = 0
for t in range(1, period + 1):
my_sum = my_sum + ssf[i] - ssf[i - t]
my_sum /= period
sums[i] = my_sum
ms[i] = 0.04 * sums[i] * sums[i] + 0.96 * ms[i - 1]
if ms[i] != 0:
tf[i] = sums[i] / np.sqrt(ms[i])
return tf
================================================
FILE: jesse/indicators/trima.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def trima(candles: np.ndarray, period: int = 30, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
TRIMA - Triangular Moving Average
:param candles: np.ndarray
:param period: int - default: 30
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Compute triangular weights
if period % 2 != 0:
mid = period // 2
weights = np.concatenate((np.arange(1, mid + 2), np.arange(mid, 0, -1)))
else:
mid = period // 2
weights = np.concatenate((np.arange(1, mid + 1), np.arange(mid, 0, -1)))
weights_norm = weights / weights.sum()
n = source.shape[0]
if n < period:
res = np.full(n, np.nan)
else:
conv = np.convolve(source, weights_norm, mode='valid')
res = np.concatenate((np.full(period - 1, np.nan), conv))
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/trix.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
@njit
def _ema_numba(data, period):
N = len(data)
result = np.empty(N, dtype=np.float64)
alpha = 2.0 / (period + 1)
result[0] = data[0]
for i in range(1, N):
result[i] = alpha * data[i] + (1 - alpha) * result[i - 1]
return result
def ema(data: np.ndarray, period: int) -> np.ndarray:
return _ema_numba(data, period)
def trix(candles: np.ndarray, period: int = 18, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
:param candles: np.ndarray
:param period: int - default: 18
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Compute triple EMA on the logarithm of the source prices
log_source = np.log(source)
ema1 = ema(log_source, period)
ema2 = ema(ema1, period)
ema3 = ema(ema2, period)
# Calculate the change (current ema3 minus previous ema3), prepending NaN to maintain same length
diff = np.empty_like(ema3)
diff[0] = np.nan
diff[1:] = ema3[1:] - ema3[:-1]
result = diff * 10000
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/tsf.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def tsf(candles: np.ndarray, period: int = 14, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
TSF - Time Series Forecast
A linear regression projection into the future. It calculates a linear regression line
using the specified period and projects it forward.
:param candles: np.ndarray
:param period: int - default: 14
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if sequential:
result = np.full_like(source, np.nan)
if len(source) >= period:
# Create time indices array
x = np.arange(period)
# Calculate means for x
x_mean = np.mean(x)
# Calculate denominator term (sum of squared deviations)
x_diff = x - x_mean
denominator = np.sum(x_diff ** 2)
# Create sliding windows view of the data
windows = np.lib.stride_tricks.sliding_window_view(source, period)
# Calculate means for each window
y_means = np.mean(windows, axis=1)
# Calculate slopes using vectorized operations
slopes = np.sum((windows - y_means[:, None]) * x_diff, axis=1) / denominator
# Calculate intercepts
intercepts = y_means - slopes * x_mean
# Calculate forecast values
forecasts = intercepts + slopes * period
# Place forecasts in result array
result[period-1:] = forecasts
return result
else:
# For non-sequential, just calculate the last window
x = np.arange(period)
X = np.vstack((np.ones(period), x)).T
y = source[-period:]
beta = np.linalg.inv(X.T @ X) @ X.T @ y
return beta[0] + beta[1] * period
================================================
FILE: jesse/indicators/tsi.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def tsi(candles: np.ndarray, long_period: int = 25, short_period: int = 13, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
True strength index (TSI)
:param candles: np.ndarray
:param long_period: int - default: 25
:param short_period: int - default: 13
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
mom = _mom(source, 1)
ema_mom = _ema(mom, long_period)
double_ema_mom = _ema(ema_mom, short_period)
ema_abs_mom = _ema(np.abs(mom), long_period)
double_ema_abs_mom = _ema(ema_abs_mom, short_period)
# Avoid division by zero and invalid results
with np.errstate(divide='ignore', invalid='ignore'):
r = 100 * double_ema_mom / double_ema_abs_mom
r[~np.isfinite(r)] = 0
return r if sequential else r[-1]
def _mom(series, period):
# Calculate momentum as difference between current and period ago value
return np.concatenate((np.zeros(period), series[period:] - series[:-period]))
def _ema(series, period):
# Exponential Moving Average using a vectorized approach with convolution
alpha = 2 / (period + 1)
n = len(series)
t_arr = np.arange(n)
# Calculate the contribution from the first element
ema_vals = series[0] * ((1 - alpha) ** t_arr)
if n > 1:
# For t>=1, add the convolution of the rest of the series with the weights alpha*(1-alpha)^(t)
conv = np.convolve(series[1:], alpha * ((1 - alpha) ** np.arange(n - 1)), mode='full')[:n-1]
ema_vals[1:] += conv
return ema_vals
================================================
FILE: jesse/indicators/ttm_squeeze.py
================================================
from .bollinger_bands import bollinger_bands
from .sma import sma
from .trange import trange
import numpy as np
def ttm_squeeze(candles: np.ndarray, length_ttms: int = 20, bb_mult_ttms: float = 2.0, kc_mult_low_ttms: float = 2.0) -> bool:
"""
@author daviddtech
credits: https://www.tradingview.com/script/Mh3EmxF5-TTM-Squeeze-DaviddTech/
TTMSQUEEZE - TTMSqueeze
:param candles: np.ndarray
:param length_ttms: int - default: 20
:param bb_mult_ttms: float - default: 2.0
:param kc_mult_low_ttms: float - default: 2.0
:return: TTMSqueeze(sqz_signal)
"""
bb_data = bollinger_bands(candles, length_ttms, bb_mult_ttms)
kc_basis_ttms = sma(candles, length_ttms)
devkc_ttms = sma(trange(candles, sequential=True), period=length_ttms)
no_sqz_ttms = bb_data.lowerband < kc_basis_ttms - devkc_ttms * \
kc_mult_low_ttms or bb_data.upperband > kc_basis_ttms + devkc_ttms * kc_mult_low_ttms
sqz_signal = False
if no_sqz_ttms:
sqz_signal = True
return sqz_signal
================================================
FILE: jesse/indicators/ttm_trend.py
================================================
from typing import Union
import numpy as np
from numpy.lib.stride_tricks import sliding_window_view
from jesse.helpers import get_candle_source, same_length, slice_candles
def ttm_trend(candles: np.ndarray, period: int = 5, source_type: str = "hl2", sequential: bool = False) -> Union[
bool, np.ndarray]:
"""
TTM Trend
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "hl2"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
swv = sliding_window_view(source, window_shape=period)
trend_avg = np.mean(swv, axis=-1)
res = np.greater(candles[:, 2], same_length(source, trend_avg))
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/typprice.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def typprice(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
TYPPRICE - Typical Price
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
res = (candles[:, 2] + candles[:, 3] + candles[:, 4]) / 3
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/ui.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def ui(candles: np.ndarray, period: int = 14, scalar: float = 100, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
Ulcer Index (UI)
:param candles: np.ndarray
:param period: int - default: 14
:param scalar: float - default: 100
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
n = source.shape[0]
# Compute rolling maximum over the period
if n < period:
highest_close = np.full_like(source, np.nan)
else:
# sliding_window_view creates a rolling window view: shape (n-period+1, period)
highest_window = np.lib.stride_tricks.sliding_window_view(source, window_shape=period)
highest_max = np.max(highest_window, axis=1)
highest_close = np.concatenate((np.full(period - 1, np.nan), highest_max))
# Calculate downside percentage
downside = scalar * (source - highest_close) / highest_close
d2 = downside ** 2
# Compute rolling sum of squared downside values
if n < period:
rolling_d2_sum = np.full_like(d2, np.nan)
else:
rolling_sum_valid = np.convolve(d2, np.ones(period), mode='valid')
rolling_d2_sum = np.concatenate((np.full(period - 1, np.nan), rolling_sum_valid))
res = np.sqrt(rolling_d2_sum / period)
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/ultosc.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def ultosc(candles: np.ndarray, timeperiod1: int = 7, timeperiod2: int = 14, timeperiod3: int = 28,
sequential: bool = False) -> Union[float, np.ndarray]:
"""
ULTOSC - Ultimate Oscillator
:param candles: np.ndarray
:param timeperiod1: int - default: 7
:param timeperiod2: int - default: 14
:param timeperiod3: int - default: 28
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
high = candles[:, 3]
low = candles[:, 4]
close = candles[:, 2]
n = len(close)
bp = np.empty(n, dtype=float)
tr = np.empty(n, dtype=float)
bp[0] = 0.0
tr[0] = high[0] - low[0]
bp[1:] = close[1:] - np.minimum(low[1:], close[:-1])
tr[1:] = np.maximum(high[1:], close[:-1]) - np.minimum(low[1:], close[:-1])
sum_bp_1 = _rolling_sum(bp, timeperiod1)
sum_tr_1 = _rolling_sum(tr, timeperiod1)
avg1 = np.where(sum_tr_1 != 0, sum_bp_1 / sum_tr_1, np.nan)
sum_bp_2 = _rolling_sum(bp, timeperiod2)
sum_tr_2 = _rolling_sum(tr, timeperiod2)
avg2 = np.where(sum_tr_2 != 0, sum_bp_2 / sum_tr_2, np.nan)
sum_bp_3 = _rolling_sum(bp, timeperiod3)
sum_tr_3 = _rolling_sum(tr, timeperiod3)
avg3 = np.where(sum_tr_3 != 0, sum_bp_3 / sum_tr_3, np.nan)
ult = 100 * (4 * avg1 + 2 * avg2 + avg3) / 7
return ult if sequential else ult[-1]
def _rolling_sum(data, window):
n = len(data)
if n < window:
return np.full(n, np.nan)
conv = np.convolve(data, np.ones(window, dtype=float), mode='valid')
out = np.empty(n, dtype=float)
out[:window-1] = np.nan
out[window-1:] = conv
return out
================================================
FILE: jesse/indicators/var.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def var(candles: np.ndarray, period: int = 14, nbdev: float = 1, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
VAR - Variance
:param candles: np.ndarray
:param period: int - default: 14
:param nbdev: float - default: 1
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
n = len(source)
result = np.empty(n)
result[:period-1] = np.nan
if n >= period:
windows = np.lib.stride_tricks.sliding_window_view(source, window_shape=period)
window_mean = np.mean(windows, axis=1)
window_mean_sq = np.mean(windows ** 2, axis=1)
result[period-1:] = (window_mean_sq - window_mean**2) * nbdev
else:
result[:] = np.nan
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/vi.py
================================================
from collections import namedtuple
import numpy as np
import jesse_rust
from jesse.helpers import slice_candles
VI = namedtuple('VI', ['plus', 'minus'])
def vi(candles: np.ndarray, period: int = 14, sequential: bool = False) -> VI:
"""
Vortex Indicator (VI)
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: VI(plus, minus)
"""
candles = slice_candles(candles, sequential)
# Use the Rust implementation
vi_plus, vi_minus = jesse_rust.vi(candles, period, sequential)
if sequential:
return VI(vi_plus, vi_minus)
else:
return VI(vi_plus[-1], vi_minus[-1])
================================================
FILE: jesse/indicators/vidya.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
@njit
def vidya_numba(source: np.ndarray, length: int, fix_cmo: bool, select: bool) -> np.ndarray:
alpha = 2 / (length + 1)
momm = np.zeros_like(source)
momm[1:] = source[1:] - source[:-1]
momm[0] = 0
# Initialize arrays for positive and negative momentum
m1 = np.where(momm >= 0, momm, 0)
m2 = np.where(momm < 0, -momm, 0)
# Calculate rolling sums
cmo_length = 9 if fix_cmo else length
sm1 = np.zeros_like(source)
sm2 = np.zeros_like(source)
for i in range(len(source)):
start_idx = max(0, i - cmo_length + 1)
sm1[i] = np.sum(m1[start_idx:i+1])
sm2[i] = np.sum(m2[start_idx:i+1])
# Calculate Chande Momentum
total_sum = sm1 + sm2
chande_mo = np.where(total_sum != 0, 100 * (sm1 - sm2) / total_sum, 0)
# Calculate k factor
if select:
k = np.abs(chande_mo) / 100
else:
k = np.zeros_like(source)
for i in range(len(source)):
start_idx = max(0, i - length + 1)
k[i] = np.std(source[start_idx:i+1])
# Calculate VIDYA
vidya = np.zeros_like(source)
vidya[0] = source[0]
for i in range(1, len(source)):
vidya[i] = alpha * k[i] * source[i] + (1 - alpha * k[i]) * vidya[i-1]
return vidya
def vidya(candles: np.ndarray, length: int = 9, fix_cmo: bool = True, select: bool = True, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
VIDYA - Variable Index Dynamic Average
:param candles: np.ndarray
:param length: int - default: 9
:param fix_cmo: bool - default: True Fixed CMO Length (9)?
:param select: bool - default: True Calculation Method: CMO/StDev?
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = vidya_numba(source, length, fix_cmo, select)
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/vlma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
from jesse.indicators.ma import ma
from jesse.indicators.mean_ad import mean_ad
from jesse.indicators.median_ad import median_ad
def moving_std(source: np.ndarray, window: int) -> np.ndarray:
n = len(source)
stdArr = np.empty_like(source)
if n < window:
# Vectorized cumulative standard deviation for all indices
cumsum = np.cumsum(source)
cumsum2 = np.cumsum(source**2)
counts = np.arange(1, n + 1)
means = cumsum / counts
variances = cumsum2 / counts - means**2
stdArr[:] = np.sqrt(np.maximum(variances, 0))
else:
# For indices with less than a full window, use cumulative statistics
cumsum_init = np.cumsum(source[:window-1])
cumsum2_init = np.cumsum(source[:window-1]**2)
counts_init = np.arange(1, window)
means_init = cumsum_init / counts_init
variances_init = cumsum2_init / counts_init - means_init**2
stdArr[:window-1] = np.sqrt(np.maximum(variances_init, 0))
# For full windows, use sliding window view and compute standard deviation
sw = np.lib.stride_tricks.sliding_window_view(source, window_shape=window)
stdArr[window-1:] = np.std(sw, axis=1)
return stdArr
def vlma(candles: np.ndarray, min_period: int = 5, max_period: int = 50, matype: int = 0, devtype: int = 0, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Variable Length Moving Average
:param candles: np.ndarray
:param min_period: int - default: 5
:param max_period: int - default: 50
:param matype: int - default: 0
:param devtype: int - default: 0
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if matype == 24 or matype == 29:
mean = ma(candles, period=max_period, matype=matype, source_type=source_type, sequential=True)
else:
mean = ma(source, period=max_period, matype=matype, sequential=True)
if devtype == 0:
stdDev = moving_std(source, max_period)
elif devtype == 1:
stdDev = mean_ad(source, max_period, sequential=True)
elif devtype == 2:
stdDev = median_ad(source, max_period, sequential=True)
a = mean - (1.75 * stdDev)
b = mean - (0.25 * stdDev)
c = mean + (0.25 * stdDev)
d = mean + (1.75 * stdDev)
res = vlma_fast(source, a, b, c, d , min_period, max_period)
return res if sequential else res[-1]
@njit(cache=True)
def vlma_fast(source, a, b, c, d, min_period, max_period):
newseries = np.copy(source)
period = np.zeros_like(source)
for i in range(1, source.shape[0]):
nz_period = period[i - 1] if period[i - 1] != 0 else max_period
period[i] = nz_period + 1 if b[i] <= source[i] <= c[i] else nz_period - 1 if source[i] < a[i] or source[i] > d[i] else nz_period
period[i] = max(min(period[i], max_period), min_period)
sc = 2 / (period[i] + 1)
newseries[i] = (source[i] * sc) + ((1 - sc) * newseries[i - 1])
return newseries
================================================
FILE: jesse/indicators/volume.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
Volume = namedtuple("Volume", ["volume", "ma"])
def volume(
candles: np.ndarray,
period: int = 20,
sequential: bool = False
) -> Volume:
"""
Volume with Moving Average
:param candles: np.ndarray
:param period: int - default: 20
:param sequential: bool - default: False
:return: Volume(volume, ma)
"""
candles = slice_candles(candles, sequential)
volume_data = candles[:, 5]
if len(volume_data) < period:
volume_ma = np.full(len(volume_data), np.nan)
else:
volume_ma = np.concatenate((np.full(period - 1, np.nan), np.convolve(volume_data, np.ones(period) / period, mode='valid')))
if sequential:
return Volume(volume_data, volume_ma)
else:
return Volume(volume_data[-1], volume_ma[-1])
================================================
FILE: jesse/indicators/vosc.py
================================================
from typing import Union
from jesse.indicators.sma import sma
import numpy as np
def vosc(candles: np.ndarray, short_period: int = 2, long_period: int = 5, sequential: bool = False) -> Union[float, np.ndarray]:
"""
VOSC - Volume Oscillator
:param candles: np.ndarray
:param short_period: int - default: 2
:param long_period: int - default: 5
:param sequential: bool - default: False
:return: float | np.ndarray
"""
from jesse.helpers import same_length, slice_candles
candles = slice_candles(candles, sequential)
volume = candles[:, 5]
short_sma = sma(volume, short_period, sequential=True)
long_sma = sma(volume, long_period, sequential=True)
vosc_values = (short_sma - long_sma) / long_sma * 100
vosc_result = same_length(candles, vosc_values)
return vosc_result if sequential else vosc_result[-1]
================================================
FILE: jesse/indicators/voss.py
================================================
from collections import namedtuple
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
VossFilter = namedtuple('VossFilter', ['voss', 'filt'])
def voss(candles: np.ndarray, period: int = 20, predict: int = 3, bandwith: float = 0.25, source_type: str = "close",
sequential: bool = False) -> VossFilter:
"""
Voss indicator by John F. Ehlers
:param candles: np.ndarray
:param period: int - default: 20
:param predict: int - default: 3
:param bandwith: float - default: 0.25
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
voss_val, filt = voss_fast(source, period, predict, bandwith)
if sequential:
return VossFilter(voss_val, filt)
else:
return VossFilter(voss_val[-1], filt[-1])
@njit(cache=True)
def voss_fast(source, period, predict, bandwith):
voss = np.full_like(source, 0)
filt = np.full_like(source, 0)
pi = np.pi
order = 3 * predict
f1 = np.cos(2 * pi / period)
g1 = np.cos(bandwith * 2 * pi / period)
s1 = 1 / g1 - np.sqrt(1 / (g1 * g1) - 1)
for i in range(source.shape[0]):
if i > period and i > 5 and i > order:
filt[i] = 0.5 * (1 - s1) * (source[i] - source[i - 2]) + f1 * (1 + s1) * filt[i - 1] - s1 * filt[i - 2]
for i in range(source.shape[0]):
if not (i <= period or i <= 5 or i <= order):
sumc = 0
for count in range(order):
sumc = sumc + ((count + 1) / float(order)) * voss[i - (order - count)]
voss[i] = ((3 + order) / 2) * filt[i] - sumc
return voss, filt
================================================
FILE: jesse/indicators/vpci.py
================================================
from collections import namedtuple
from jesse.indicators.sma import sma
import numpy as np
from jesse.helpers import slice_candles
VPCI = namedtuple('VPCI', ['vpci', 'vpcis'])
def vpci(candles: np.ndarray, short_range: int = 5, long_range: int = 25, sequential: bool = False) -> VPCI:
"""
VPCI - Volume Price Confirmation Indicator
:param candles: np.ndarray
:param short_range: int - default: 5
:param long_range: int - default: 25
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
vwma_long = sma(candles[:, 2] * candles[:, 5], long_range, sequential=True) / sma(candles[:, 5], long_range, sequential=True)
VPC = vwma_long - sma(candles[:, 2], long_range, sequential=True)
vwma_short = sma(candles[:, 2] * candles[:, 5], short_range, sequential=True) / sma(candles[:, 5], short_range, sequential=True)
VPR = vwma_short / sma(candles[:, 2], short_range, sequential=True)
VM = sma(candles[:, 5], short_range, sequential=True) / sma(candles[:, 5], long_range, sequential=True)
VPCI_val = VPC * VPR * VM
VPCIS = sma(VPCI_val * candles[:, 5], short_range, sequential=True) / sma(candles[:, 5], short_range, sequential=True)
if sequential:
return VPCI(VPCI_val, VPCIS)
else:
return VPCI(VPCI_val[-1], VPCIS[-1])
================================================
FILE: jesse/indicators/vpt.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, np_shift, slice_candles
def vpt(candles: np.ndarray, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
Volume Price Trend (VPT)
:param candles: np.ndarray
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
vpt_val = (candles[:, 5] * ((source - np_shift(source, 1, fill_value=np.nan)) / np_shift(source, 1, fill_value=np.nan)))
res = np_shift(vpt_val, 1, fill_value=np.nan) + vpt_val
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/vpwma.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, slice_candles
def vpwma(candles: np.ndarray, period: int = 14, power: float = 0.382, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Variable Power Weighted Moving Average
:param candles: np.ndarray
:param period: int - default: 14
:param power: float - default: 0.382
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Accept normal array too.
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = vpwma_fast(source, period, power)
return res if sequential else res[-1]
@njit(cache=True)
def vpwma_fast(source, period, power):
newseries = np.copy(source)
for j in range(period + 1, source.shape[0]):
my_sum = 0.0
weightSum = 0.0
for i in range(period - 1):
weight = np.power(period - i, power)
my_sum += (source[j - i] * weight)
weightSum += weight
newseries[j] = my_sum / weightSum
return newseries
================================================
FILE: jesse/indicators/vwap.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
def vwap(
candles: np.ndarray, source_type: str = "hlc3", anchor: str = "D", sequential: bool = False
) -> Union[float, np.ndarray]:
"""
VWAP
:param candles: np.ndarray
:param source_type: str - default: "hlc3"
:param anchor: str - default: "D"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
# Check if jesse_rust is available
try:
import jesse_rust
candles = slice_candles(candles, sequential)
# Use the Rust implementation with anchoring support
result = jesse_rust.vwap(candles, source_type, anchor, sequential)
if sequential:
return result
else:
return None if np.isnan(result[-1]) else result[-1]
except ImportError:
# Fallback to original Python implementation with anchoring
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Convert timestamps to period indices
timestamps = candles[:, 0].astype('datetime64[ms]').astype(f'datetime64[{anchor}]')
group_indices = np.zeros(len(timestamps), dtype=np.int64)
# Mark the start of each new period
group_indices[1:] = (timestamps[1:] != timestamps[:-1]).astype(np.int64)
group_indices = np.cumsum(group_indices)
vwap_values = _calculate_vwap(source, candles[:, 5], group_indices)
if sequential:
return vwap_values
else:
return None if np.isnan(vwap_values[-1]) else vwap_values[-1]
def _calculate_vwap(source: np.ndarray, volume: np.ndarray, group_indices: np.ndarray) -> np.ndarray:
"""
Calculate VWAP values with anchoring logic (pure Python implementation fallback)
"""
vwap_values = np.zeros_like(source)
cum_vol = 0.0
cum_vol_price = 0.0
current_group = group_indices[0]
for i in range(len(source)):
if group_indices[i] != current_group:
cum_vol = 0.0
cum_vol_price = 0.0
current_group = group_indices[i]
vol_price = volume[i] * source[i]
cum_vol_price += vol_price
cum_vol += volume[i]
vwap_values[i] = cum_vol_price / cum_vol if cum_vol != 0 else np.nan
return vwap_values
================================================
FILE: jesse/indicators/vwma.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import vwma as vwma_rust
def vwma(candles: np.ndarray, period: int = 20, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
VWMA - Volume Weighted Moving Average
:param candles: np.ndarray
:param period: int - default: 20
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
# Handle 1D array case by creating dummy candles with volume=1
source = candles
dummy_candles = np.column_stack([
np.zeros(len(source)), # timestamp
np.zeros(len(source)), # open
source, # close
np.zeros(len(source)), # high
np.zeros(len(source)), # low
np.ones(len(source)) # volume
])
candles_f64 = np.asarray(dummy_candles, dtype=np.float64)
else:
candles = slice_candles(candles, sequential)
# Convert to float64 for Rust compatibility
candles_f64 = np.asarray(candles, dtype=np.float64)
# Update close column if different source type is requested
if source_type != "close":
source = get_candle_source(candles, source_type=source_type)
candles_f64[:, 2] = source
# Call the Rust implementation
result = vwma_rust(candles_f64, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/vwmacd.py
================================================
from collections import namedtuple
import numpy as np
from .vwma import vwma
from jesse.helpers import slice_candles
VWMACD = namedtuple('VWMACD', ['macd', 'signal', 'hist'])
def vwmacd(candles: np.ndarray, fast_period: int = 12, slow_period: int = 26, signal_period: int = 9,
sequential: bool = False) -> VWMACD:
"""
@author David.
credits: https://www.tradingview.com/script/33Y1LzRq-Volume-Weighted-Moving-Average-Convergence-Divergence-MACD/
VWMACD - Volume Weighted Moving Average Convergence/Divergence
:param candles: np.ndarray
:param fast_period: int - default: 12
:param slow_period: int - default: 26
:param signal_period: int - default: 9
:param sequential: bool - default: False
:return: VWMACD(macd, signal, hist)
"""
fastWMA = vwma(candles, fast_period, sequential=True)
slowWMA = vwma(candles, slow_period, sequential=True)
macd_val = fastWMA - slowWMA
signal = vwma(macd_val, signal_period, sequential=True)
hist = macd_val - signal
if sequential:
return VWMACD(macd_val, signal, hist)
else:
return VWMACD(macd_val[-1], signal[-1], hist[-1])
================================================
FILE: jesse/indicators/wad.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import same_length, slice_candles
@njit
def _wad_numba(high: np.ndarray, low: np.ndarray, close: np.ndarray) -> np.ndarray:
n = len(close)
ad = np.zeros(n, dtype=np.float64)
# The first element doesn't have a previous close, so set its adjustment to 0
ad[0] = 0
# Calculate the Acc/Dist component iteratively
for i in range(1, n):
if close[i] > close[i - 1]:
ad[i] = close[i] - min(low[i], close[i - 1])
elif close[i] < close[i - 1]:
ad[i] = close[i] - max(high[i], close[i - 1])
else:
ad[i] = 0
# Williams Accumulation/Distribution is the cumulative sum of these adjustments
wad_values = np.cumsum(ad)
return wad_values
def wad(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
WAD - Williams Accumulation/Distribution
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
# In this project, candle columns are arranged such that:
# candles[:,3] -> high
# candles[:,4] -> low
# candles[:,1] -> close
res = _wad_numba(
np.ascontiguousarray(candles[:, 3]),
np.ascontiguousarray(candles[:, 4]),
np.ascontiguousarray(candles[:, 1])
)
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/waddah_attr_explosion.py
================================================
from collections import namedtuple
from .macd import macd
from .sma import sma
from .stddev import stddev
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
WaddahAttarExplosionTuple = namedtuple(
'WaddahAttarExplosionTuple', ['explosion_line', 'trend_power', 'trend_direction']
)
def waddah_attar_explosion(candles: np.ndarray, sensitivity: int = 150, fast_length: int = 20, slow_length: int = 40, channel_length: int = 20, mult: float = 2.0, source_type: str = "close") -> WaddahAttarExplosionTuple:
"""
@author LazyBear
credits: https://www.tradingview.com/v/iu3kKWDI/
WADDAH_ATTAR_EXPLOSION - Waddah Attar Explosion
:param candles: np.ndarray
:param sensitivity: int - default: 150
:param fast_length: int - default: 20
:param slow_length: int - default: 40
:param channel_length: int - default: 20
:param mult: float - default: 2.0
:param source_type: str - default: "close"
:return: WaddahAttarExplosionTuple(explosion_line, trend_power, trend_direction)
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, False)
source = get_candle_source(candles, source_type=source_type)
t1 = (macd(source, fast_period=fast_length, slow_period=slow_length)[0] -
macd(source[:-1], fast_period=fast_length, slow_period=slow_length)[0])*sensitivity
trend = 1 if t1 >= 0 else -1
e1 = _calc_bb_upper(source, channel_length, mult) - _calc_bb_lower(source, channel_length, mult)
return WaddahAttarExplosionTuple(e1, t1, trend)
def _calc_bb_upper(source, length, mult):
basis = sma(source, length)
dev = mult * stddev(source, length)
return basis + dev
def _calc_bb_lower(source, length, mult):
basis = sma(source, length)
dev = mult * stddev(source, length)
return basis - dev
================================================
FILE: jesse/indicators/wclprice.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
def wclprice(candles: np.ndarray, sequential: bool = False) -> Union[float, np.ndarray]:
"""
WCLPRICE - Weighted Close Price
:param candles: np.ndarray
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
# Calculate weighted close price as (high + low + 2*close) / 4, with high=candles[:,3], low=candles[:,4], close=candles[:,2]
res = (candles[:,3] + candles[:,4] + 2 * candles[:,2]) / 4.0
return res if sequential else res[-1]
================================================
FILE: jesse/indicators/wilders.py
================================================
from typing import Union
import numpy as np
from numba import njit
from jesse.helpers import get_candle_source, same_length, slice_candles
@njit
def _wilders_fast(source: np.ndarray, period: int) -> np.ndarray:
# Pre-allocate the output array
res = np.zeros_like(source)
# First value is a simple copy
res[0] = source[0]
# Calculate Wilder's Smoothing
for i in range(1, len(source)):
res[i] = (res[i - 1] * (period - 1) + source[i]) / period
return res
def wilders(candles: np.ndarray, period: int = 5, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
WILDERS - Wilders Smoothing
:param candles: np.ndarray
:param period: int - default: 5
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
res = _wilders_fast(source, period)
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/willr.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import slice_candles
from jesse_rust import willr as willr_rust
def willr(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]:
"""
WILLR - Williams' %R
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
# Convert to float64 for Rust compatibility
candles_f64 = np.asarray(candles, dtype=np.float64)
# Call the Rust implementation
result = willr_rust(candles_f64, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/wma.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse_rust import wma as wma_rust
def wma(candles: np.ndarray, period: int = 30, source_type: str = "close", sequential: bool = False) -> Union[float, np.ndarray]:
"""
WMA - Weighted Moving Average
:param candles: np.ndarray
:param period: int - default: 30
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Convert to float64 for Rust compatibility
source_f64 = np.asarray(source, dtype=np.float64)
# Call the Rust implementation
result = wma_rust(source_f64, period)
return result if sequential else result[-1]
================================================
FILE: jesse/indicators/wt.py
================================================
from collections import namedtuple
import numpy as np
from jesse.helpers import slice_candles
import jesse_rust
Wavetrend = namedtuple('Wavetrend', ['wt1', 'wt2', 'wtCrossUp', 'wtCrossDown', 'wtOversold', 'wtOverbought', 'wtVwap'])
# Wavetrend indicator ported from: https://www.tradingview.com/script/Msm4SjwI-VuManChu-Cipher-B-Divergences/
# https://www.tradingview.com/script/2KE8wTuF-Indicator-WaveTrend-Oscillator-WT/
#
# buySignal = wtCross and wtCrossUp and wtOversold
# sellSignal = wtCross and wtCrossDown and wtOverbought
#
# See https://github.com/ysdede/lazarus3/blob/partialexit/strategies/lazarus3/__init__.py for working jesse.ai example.
def wt(candles: np.ndarray, wtchannellen: int = 9, wtaveragelen: int = 12, wtmalen: int = 3, oblevel: int = 53, oslevel: int = -53, source_type: str = "hlc3", sequential: bool = False) -> Wavetrend:
"""
Wavetrend indicator
:param candles: np.ndarray
:param wtchannellen: int - default: 9
:param wtaveragelen: int - default: 12
:param wtmalen: int - default: 3
:param oblevel: int - default: 53
:param oslevel: int - default: -53
:param source_type: str - default: "hlc3"
:param sequential: bool - default: False
:return: Wavetrend
"""
candles = slice_candles(candles, sequential)
# Use the Rust implementation
wt1, wt2, wtCrossUp, wtCrossDown, wtOversold, wtOverbought, wtVwap = jesse_rust.wt(
candles,
wtchannellen,
wtaveragelen,
wtmalen,
float(oblevel),
float(oslevel),
source_type
)
if sequential:
return Wavetrend(wt1, wt2, wtCrossUp, wtCrossDown, wtOversold, wtOverbought, wtVwap)
else:
return Wavetrend(wt1[-1], wt2[-1], wtCrossUp[-1], wtCrossDown[-1], wtOversold[-1], wtOverbought[-1], wtVwap[-1])
================================================
FILE: jesse/indicators/zlema.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, same_length, slice_candles
import jesse_rust
def zlema(candles: np.ndarray, period: int = 20, source_type: str = "close", sequential: bool = False) -> Union[
float, np.ndarray]:
"""
Zero-Lag Exponential Moving Average
:param candles: np.ndarray
:param period: int - default: 20
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
if len(candles.shape) == 1:
source = candles
else:
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
# Use the Rust implementation
res = jesse_rust.zlema(source, period)
return same_length(candles, res) if sequential else res[-1]
================================================
FILE: jesse/indicators/zscore.py
================================================
from typing import Union
import numpy as np
from jesse.helpers import get_candle_source, slice_candles
from jesse.indicators.ma import ma
from jesse.indicators.mean_ad import mean_ad
from jesse.indicators.median_ad import median_ad
def zscore(candles: np.ndarray, period: int = 14, matype: int = 0, nbdev: float = 1, devtype: int = 0, source_type: str = "close",
sequential: bool = False) -> Union[float, np.ndarray]:
"""
zScore
:param candles: np.ndarray
:param period: int - default: 14
:param matype: int - default: 0
:param nbdev: float - default: 1
:param devtype: int - default: 0
:param source_type: str - default: "close"
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
source = get_candle_source(candles, source_type=source_type)
if matype == 24 or matype == 29:
means = ma(candles, period=period, matype=matype, source_type=source_type, sequential=True)
else:
means = ma(source, period=period, matype=matype, sequential=True)
if devtype == 0:
if len(source) < period:
sigmas = np.full_like(source, np.nan, dtype=np.float64)
else:
# Create a sliding window view of the source array
rolling_windows = np.lib.stride_tricks.sliding_window_view(source, window_shape=period)
# Calculate std using population formula (ddof=0)
std_values = np.std(rolling_windows, axis=1, ddof=0)
sigmas = np.full(source.shape, np.nan, dtype=np.float64)
sigmas[period-1:] = std_values
sigmas = sigmas * nbdev
elif devtype == 1:
sigmas = mean_ad(source, period, sequential=True) * nbdev
elif devtype == 2:
sigmas = median_ad(source, period, sequential=True) * nbdev
zScores = (source - means) / sigmas
return zScores if sequential else zScores[-1]
================================================
FILE: jesse/info.py
================================================
from jesse.enums import exchanges as exchanges_enums, timeframes
from jesse.services.env import ENV_VALUES, is_dev_env
if is_dev_env():
JESSE_API_URL = ENV_VALUES.get('JESSE_API_URL', 'http://localhost:8040/api')
JESSE_API2_URL = ENV_VALUES.get('JESSE_API2_URL', 'http://localhost:8080')
JESSE_WEBSITE_URL = ENV_VALUES.get('JESSE_WEBSITE_URL', 'http://localhost:8040')
else:
JESSE_API_URL = 'https://api1.jesse.trade/api'
JESSE_API2_URL = 'https://api2.jesse.trade'
JESSE_WEBSITE_URL = 'https://jesse.trade'
BYBIT_TIMEFRAMES = [timeframes.MINUTE_1, timeframes.MINUTE_3, timeframes.MINUTE_5, timeframes.MINUTE_15, timeframes.MINUTE_30,
timeframes.HOUR_1, timeframes.HOUR_2, timeframes.HOUR_4, timeframes.HOUR_6, timeframes.HOUR_12, timeframes.DAY_1]
BINANCE_TIMEFRAMES = [timeframes.MINUTE_1, timeframes.MINUTE_3, timeframes.MINUTE_5, timeframes.MINUTE_15, timeframes.MINUTE_30,
timeframes.HOUR_1, timeframes.HOUR_2, timeframes.HOUR_4, timeframes.HOUR_6, timeframes.HOUR_8, timeframes.HOUR_12, timeframes.DAY_1]
COINBASE_TIMEFRAMES = [timeframes.MINUTE_1, timeframes.MINUTE_5,
timeframes.MINUTE_15, timeframes.HOUR_1, timeframes.HOUR_6, timeframes.DAY_1]
APEX_OMNI_TIMEFRAMES = [timeframes.MINUTE_1, timeframes.MINUTE_5, timeframes.MINUTE_15,
timeframes.MINUTE_30, timeframes.HOUR_1, timeframes.HOUR_2, timeframes.HOUR_4, timeframes.HOUR_6, timeframes.HOUR_12, timeframes.DAY_1]
GATE_TIMEFRAMES = [timeframes.MINUTE_1, timeframes.MINUTE_5, timeframes.MINUTE_15,
timeframes.MINUTE_30, timeframes.HOUR_1, timeframes.HOUR_2, timeframes.HOUR_4, timeframes.HOUR_6, timeframes.HOUR_8, timeframes.HOUR_12, timeframes.DAY_1, timeframes.WEEK_1]
FTX_TIMEFRAMES = [timeframes.MINUTE_1, timeframes.MINUTE_3, timeframes.MINUTE_5, timeframes.MINUTE_15, timeframes.MINUTE_30,
timeframes.HOUR_1, timeframes.HOUR_2, timeframes.HOUR_4, timeframes.HOUR_6, timeframes.HOUR_12, timeframes.DAY_1]
BITGET_TIMEFRAMES = [timeframes.MINUTE_1, timeframes.MINUTE_5, timeframes.MINUTE_15,
timeframes.MINUTE_30, timeframes.HOUR_1, timeframes.HOUR_4, timeframes.HOUR_12, timeframes.DAY_1]
DYDX_TIMEFRAMES = [timeframes.MINUTE_1, timeframes.MINUTE_5, timeframes.MINUTE_15,
timeframes.MINUTE_30, timeframes.HOUR_1, timeframes.HOUR_4, timeframes.DAY_1]
HYPERLIQUID_TIMEFRAMES = [timeframes.MINUTE_1, timeframes.MINUTE_3, timeframes.MINUTE_5, timeframes.MINUTE_15,
timeframes.MINUTE_30, timeframes.HOUR_1, timeframes.HOUR_2, timeframes.HOUR_4, timeframes.HOUR_8, timeframes.HOUR_12, timeframes.DAY_1]
exchange_info = {
# BYBIT_USDT_PERPETUAL
exchanges_enums.BYBIT_USDT_PERPETUAL: {
"name": exchanges_enums.BYBIT_USDT_PERPETUAL,
"url": JESSE_WEBSITE_URL + "/bybit",
"fee": 0.00055,
"type": "futures",
"settlement_currency": "USDT",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BYBIT_TIMEFRAMES,
"modes": {
"backtesting": True,
"live_trading": True,
},
"required_live_plan": "premium",
},
# BYBIT_USDT_PERPETUAL_TESTNET
exchanges_enums.BYBIT_USDT_PERPETUAL_TESTNET: {
"name": exchanges_enums.BYBIT_USDT_PERPETUAL_TESTNET,
"url": JESSE_WEBSITE_URL + "/bybit",
"fee": 0.00055,
"type": "futures",
"settlement_currency": "USDT",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BYBIT_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": True,
},
"required_live_plan": "premium",
},
# BYBIT_USDT_PERPETUAL
exchanges_enums.BYBIT_USDC_PERPETUAL: {
"name": exchanges_enums.BYBIT_USDC_PERPETUAL,
"url": JESSE_WEBSITE_URL + "/bybit",
"fee": 0.00055,
"type": "futures",
"settlement_currency": "USDC",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BYBIT_TIMEFRAMES,
"modes": {
"backtesting": True,
"live_trading": True,
},
"required_live_plan": "premium",
},
# BYBIT_USDC_PERPETUAL_TESTNET
exchanges_enums.BYBIT_USDC_PERPETUAL_TESTNET: {
"name": exchanges_enums.BYBIT_USDC_PERPETUAL_TESTNET,
"url": JESSE_WEBSITE_URL + "/bybit",
"fee": 0.00055,
"type": "futures",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BYBIT_TIMEFRAMES,
"settlement_currency": "USDC",
"modes": {
"backtesting": False,
"live_trading": True,
},
"required_live_plan": "premium",
},
# BYBIT_SPOT_TESTNET
exchanges_enums.BYBIT_SPOT: {
"name": exchanges_enums.BYBIT_SPOT,
"url": "https://jesse.trade/bybit",
"fee": 0.001,
"type": "spot",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BYBIT_TIMEFRAMES,
"modes": {
"backtesting": True,
"live_trading": True,
},
"required_live_plan": "premium",
},
# BYBIT_SPOT_TESTNET
exchanges_enums.BYBIT_SPOT_TESTNET: {
"name": exchanges_enums.BYBIT_SPOT_TESTNET,
"url": "https://jesse.trade/bybit",
"fee": 0.001,
"type": "spot",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BYBIT_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": True,
},
"required_live_plan": "premium",
},
# BITFINEX_SPOT
exchanges_enums.BITFINEX_SPOT: {
"name": exchanges_enums.BITFINEX_SPOT,
"url": "https://bitfinex.com",
"fee": 0.002,
"type": "spot",
"supported_leverage_modes": ["cross"],
"supported_timeframes": [
timeframes.MINUTE_1,
timeframes.MINUTE_5,
timeframes.MINUTE_15,
timeframes.MINUTE_30,
timeframes.HOUR_1,
timeframes.HOUR_3,
timeframes.HOUR_6,
timeframes.HOUR_12,
timeframes.DAY_1,
],
"modes": {
"backtesting": True,
"live_trading": False,
},
"required_live_plan": "premium",
},
# BINANCE_SPOT
exchanges_enums.BINANCE_SPOT: {
"name": exchanges_enums.BINANCE_SPOT,
"url": "https://binance.com",
"fee": 0.001,
"type": "spot",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BINANCE_TIMEFRAMES,
"modes": {
"backtesting": True,
"live_trading": True,
},
"required_live_plan": "premium",
},
# BINANCE_US_SPOT
exchanges_enums.BINANCE_US_SPOT: {
"name": exchanges_enums.BINANCE_US_SPOT,
"url": "https://binance.us",
"fee": 0.001,
"type": "spot",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BINANCE_TIMEFRAMES,
"modes": {
"backtesting": True,
"live_trading": True,
},
"required_live_plan": "premium",
},
# BINANCE_PERPETUAL_FUTURES
exchanges_enums.BINANCE_PERPETUAL_FUTURES: {
"name": exchanges_enums.BINANCE_PERPETUAL_FUTURES,
"url": "https://binance.com",
"fee": 0.0004,
"type": "futures",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BINANCE_TIMEFRAMES,
"modes": {
"backtesting": True,
"live_trading": True,
},
"required_live_plan": "premium",
},
# BINANCE_PERPETUAL_FUTURES_TESTNET
exchanges_enums.BINANCE_PERPETUAL_FUTURES_TESTNET: {
"name": exchanges_enums.BINANCE_PERPETUAL_FUTURES_TESTNET,
"url": "https://binance.com",
"fee": 0.0004,
"type": "futures",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BINANCE_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": True,
},
"required_live_plan": "premium",
},
# COINBASE_SPOT
exchanges_enums.COINBASE_SPOT: {
"name": exchanges_enums.COINBASE_SPOT,
"url": "https://www.coinbase.com/advanced-trade/spot/BTC-USD",
"fee": 0.0003,
"type": "spot",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": COINBASE_TIMEFRAMES,
"modes": {
"backtesting": True,
"live_trading": True,
},
"required_live_plan": "premium",
},
exchanges_enums.APEX_OMNI_PERPETUAL_TESTNET: {
"name": exchanges_enums.APEX_OMNI_PERPETUAL_TESTNET,
"url": "https://testnet.omni.apex.exchange/trade/BTCUSD",
"fee": 0.0005,
"type": "futures",
"supported_leverage_modes": ["cross"],
"supported_timeframes": APEX_OMNI_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": False,
},
"required_live_plan": "free",
},
exchanges_enums.APEX_OMNI_PERPETUAL: {
"name": exchanges_enums.APEX_OMNI_PERPETUAL,
"url": "https://omni.apex.exchange/trade/BTCUSD",
"fee": 0.0005,
"type": "futures",
"supported_leverage_modes": ["cross"],
"supported_timeframes": APEX_OMNI_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": True,
},
"required_live_plan": "premium",
},
exchanges_enums.GATE_USDT_PERPETUAL: {
"name": exchanges_enums.GATE_USDT_PERPETUAL,
"url": "https://jesse.trade/gate",
"fee": 0.0005,
"type": "futures",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": GATE_TIMEFRAMES,
"modes": {
"backtesting": True,
"live_trading": True,
},
"required_live_plan": "premium",
},
exchanges_enums.GATE_SPOT: {
"name": exchanges_enums.GATE_SPOT,
"url": "https://jesse.trade/gate",
"fee": 0.0005,
"type": "spot",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": GATE_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": True,
},
"required_live_plan": "premium",
},
# FTX_PERPETUAL_FUTURES
exchanges_enums.FTX_PERPETUAL_FUTURES: {
"name": exchanges_enums.FTX_PERPETUAL_FUTURES,
"url": "https://ftx.com/markets/future",
"fee": 0.0006,
"type": "futures",
"supported_leverage_modes": ["cross"],
"supported_timeframes": FTX_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": False,
},
"required_live_plan": "premium",
},
# FTX_SPOT
exchanges_enums.FTX_SPOT: {
"name": exchanges_enums.FTX_SPOT,
"url": "https://ftx.com/markets/spot",
"fee": 0.0007,
"type": "spot",
"supported_leverage_modes": ["cross"],
"supported_timeframes": FTX_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": False,
},
"required_live_plan": "premium",
},
# FTX_US_SPOT
exchanges_enums.FTX_US_SPOT: {
"name": exchanges_enums.FTX_US_SPOT,
"url": "https://ftx.us",
"fee": 0.002,
"type": "spot",
"supported_leverage_modes": ["cross"],
"supported_timeframes": FTX_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": False,
},
"required_live_plan": "premium",
},
# BITGET_USDT_PERPETUAL_TESTNET
exchanges_enums.BITGET_USDT_PERPETUAL_TESTNET: {
"name": exchanges_enums.BITGET_USDT_PERPETUAL_TESTNET,
"url": JESSE_WEBSITE_URL + "/bitget",
"fee": 0.0006,
"type": "futures",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BITGET_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": False,
},
"required_live_plan": "premium",
},
# BITGET_USDT_PERPETUAL
exchanges_enums.BITGET_USDT_PERPETUAL: {
"name": exchanges_enums.BITGET_USDT_PERPETUAL,
"url": JESSE_WEBSITE_URL + "/bitget",
"fee": 0.0006,
"type": "futures",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BITGET_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": False,
},
"required_live_plan": "premium",
},
# BITGET_SPOT
exchanges_enums.BITGET_SPOT: {
"name": exchanges_enums.BITGET_SPOT,
"url": JESSE_WEBSITE_URL + "/bitget",
"fee": 0.0006,
"type": "spot",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": BITGET_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": False,
},
"required_live_plan": "premium",
},
# DyDx
exchanges_enums.DYDX_PERPETUAL: {
"name": exchanges_enums.DYDX_PERPETUAL,
"url": JESSE_WEBSITE_URL + "/dydx",
"fee": 0.0005,
"type": "futures",
"supported_leverage_modes": ["cross"],
"supported_timeframes": DYDX_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": False,
},
"required_live_plan": "premium",
},
# DyDx Testnet
exchanges_enums.DYDX_PERPETUAL_TESTNET: {
"name": exchanges_enums.DYDX_PERPETUAL_TESTNET,
"url": "https://trade.stage.dydx.exchange/trade/ETH-USD",
"fee": 0.0005,
"type": "futures",
"supported_leverage_modes": ["cross"],
"supported_timeframes": DYDX_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": False,
},
"required_live_plan": "premium",
},
# HyperLiquid
exchanges_enums.HYPERLIQUID_PERPETUAL: {
"name": exchanges_enums.HYPERLIQUID_PERPETUAL,
"url": "https://app.hyperliquid.xyz/trade",
"fee": 0.0001,
"type": "futures",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": HYPERLIQUID_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": True,
},
"required_live_plan": "premium",
},
exchanges_enums.HYPERLIQUID_PERPETUAL_TESTNET: {
"name": exchanges_enums.HYPERLIQUID_PERPETUAL_TESTNET,
"url": "https://app.hyperliquid-testnet.xyz/trade",
"fee": 0.0001,
"type": "futures",
"supported_leverage_modes": ["cross", "isolated"],
"supported_timeframes": HYPERLIQUID_TIMEFRAMES,
"modes": {
"backtesting": False,
"live_trading": True,
},
"required_live_plan": "free",
},
}
# list of supported exchanges for backtesting
backtesting_exchanges = [k for k, v in exchange_info.items() if v['modes']['backtesting'] is True]
backtesting_exchanges = list(sorted(backtesting_exchanges))
# list of supported exchanges for live trading
live_trading_exchanges = [k for k, v in exchange_info.items() if v['modes']['live_trading'] is True]
live_trading_exchanges = list(sorted(live_trading_exchanges))
# used for backtesting, and live trading when local candle generation is enabled:
jesse_supported_timeframes = [
timeframes.MINUTE_1,
timeframes.MINUTE_3,
timeframes.MINUTE_5,
timeframes.MINUTE_15,
timeframes.MINUTE_30,
timeframes.MINUTE_45,
timeframes.HOUR_1,
timeframes.HOUR_2,
timeframes.HOUR_3,
timeframes.HOUR_4,
timeframes.HOUR_6,
timeframes.HOUR_8,
timeframes.HOUR_12,
timeframes.DAY_1,
]
================================================
FILE: jesse/libs/__init__.py
================================================
from .dynamic_numpy_array import DynamicNumpyArray
================================================
FILE: jesse/libs/custom_json/__init__.py
================================================
import numpy as np
import simplejson as json
class NpEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, np.integer):
return int(obj)
elif isinstance(obj, np.bool_):
return bool(obj)
elif isinstance(obj, np.floating):
return float(obj)
elif isinstance(obj, np.ndarray):
return obj.tolist()
else:
return super(NpEncoder, self).default(obj)
================================================
FILE: jesse/libs/dynamic_numpy_array/__init__.py
================================================
import numpy as np
from jesse.helpers import np_shift
class DynamicNumpyArray:
"""
Dynamic Numpy Array
A data structure containing a numpy array which expands its memory
allocation every N number. Hence, it's both fast and dynamic.
"""
def __init__(self, shape: tuple, drop_at: int = None):
self.index = -1
self.array = np.zeros(shape)
self.bucket_size = shape[0]
self.shape = shape
self.drop_at = drop_at
def __str__(self) -> str:
return str(self.array[:self.index + 1])
def __len__(self) -> int:
return self.index + 1
def __getitem__(self, i):
if isinstance(i, slice):
start = 0 if i.start is None else i.start
stop = self.index + 1 if i.stop is None else i.stop
if stop < 0:
stop = (self.index + 1) - abs(stop)
stop = min(stop, self.index + 1)
return self.array[start:stop]
else:
if i < 0:
i = (self.index + 1) - abs(i)
# validation
if self.index == -1 or i > self.index or i < 0:
raise IndexError(f'list assignment index out of range. self.index={self.index}, i={i}')
return self.array[i]
def __setitem__(self, i, item) -> None:
if isinstance(i, slice):
start = i.start
stop = i.stop
step = i.step
if start is not None and start < 0:
start = (self.index + 1) - abs(start)
if stop is None:
stop = start + len(item)
if stop < 0:
stop = (self.index + 1) - abs(stop)
self.array[slice(start, stop, step)] = item
return
if i < 0:
i = (self.index + 1) - abs(i)
# validation
if i > self.index or i < 0:
raise IndexError('list assignment index out of range')
self.array[i] = item
def append(self, item: np.ndarray) -> None:
self.index += 1
# expand if the arr is almost full
if self.index != 0 and (self.index + 1) % self.bucket_size == 0:
new_bucket = np.zeros(self.shape)
self.array = np.concatenate((self.array, new_bucket), axis=0)
# drop N% of the beginning values to free memory
if (
self.drop_at is not None
and self.index != 0
and (self.index + 1) % self.drop_at == 0
):
shift_num = int(self.drop_at / 2)
self.index -= shift_num
self.array = np_shift(self.array, -shift_num)
self.array[self.index] = item
def get_last_item(self):
# validation
if self.index == -1:
raise IndexError('list assignment index out of range. array is empty which means no past item exists')
return self.array[self.index]
def get_past_item(self, past_index) -> np.ndarray:
# validation
if self.index == -1:
raise IndexError('list assignment index out of range. array is empty which means no past item exists')
# validation
if (self.index - past_index) < 0:
raise IndexError(f'list assignment index out of range. Max allowed is self.index={self.index}, past_index={past_index}')
return self.array[self.index - past_index]
def flush(self) -> None:
self.index = -1
self.array = np.zeros(self.shape)
self.bucket_size = self.shape[0]
def append_multiple(self, items: np.ndarray) -> None:
self.index += len(items)
# expand if the arr will be greater than the maximum
if self.index != 0 and (self.index + 1) >= len(self.array):
# in case the shape is smaller than len(items)
if isinstance(self.shape, int):
shape = max(self.shape, len(items))
else:
shape = list(self.shape)
shape[0] = max(len(items), shape[0])
new_bucket = np.zeros(shape)
self.array = np.concatenate((self.array, new_bucket), axis=0)
# drop N% of the beginning values to free memory
if (
self.drop_at is not None
and self.index != 0
and (self.index + 1) % self.drop_at == 0
):
shift_num = int(self.drop_at / 2)
self.index -= shift_num
self.array = np_shift(self.array, -shift_num)
self.array[self.index - len(items) + 1 : self.index + 1] = items
def delete(self, index: int, axis=None) -> None:
self.array = np.delete(self.array, index, axis=axis)
self.index -= 1
if self.array.shape[0] <= self.shape[0]:
new_bucket = np.zeros(self.shape)
self.array = np.concatenate((self.array, new_bucket), axis=0)
================================================
FILE: jesse/models/BacktestSession.py
================================================
import peewee
import json
from jesse.services.db import database
import jesse.helpers as jh
if database.is_closed():
database.open_connection()
class BacktestSession(peewee.Model):
id = peewee.UUIDField(primary_key=True)
# Status of the backtest session: running, finished, stopped, cancelled, or terminated
status = peewee.CharField()
# Backtest results data in JSON format
metrics = peewee.TextField(null=True)
equity_curve = peewee.TextField(null=True)
trades = peewee.TextField(null=True)
hyperparameters = peewee.TextField(null=True)
chart_data = peewee.TextField(null=True)
# Frontend state in JSON format - used for restoring UI state
state = peewee.TextField(null=True)
# User notes
title = peewee.CharField(max_length=255, null=True)
description = peewee.TextField(null=True)
strategy_codes = peewee.TextField(null=True)
# Error tracking
exception = peewee.TextField(null=True)
traceback = peewee.TextField(null=True)
# Execution metrics
execution_duration = peewee.FloatField(null=True)
# Timestamps for session management
created_at = peewee.BigIntegerField()
updated_at = peewee.BigIntegerField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('id',), True),
(('created_at',), False),
)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
@property
def metrics_json(self):
"""
Returns the metrics as a Python dictionary
"""
if not self.metrics:
return None
return json.loads(self.metrics)
@metrics_json.setter
def metrics_json(self, metrics_dict):
"""
Sets the metrics from a Python dictionary
"""
self.metrics = json.dumps(metrics_dict) if metrics_dict else None
@property
def equity_curve_json(self):
"""
Returns the equity curve data as a Python list
"""
if not self.equity_curve:
return []
return json.loads(self.equity_curve)
@equity_curve_json.setter
def equity_curve_json(self, curve_data):
"""
Sets the equity curve data from a Python list
"""
self.equity_curve = json.dumps(curve_data) if curve_data else None
@property
def trades_json(self):
"""
Returns the trades as a Python list
"""
if not self.trades:
return []
return json.loads(self.trades)
@trades_json.setter
def trades_json(self, trades_list):
"""
Sets the trades from a Python list
"""
self.trades = json.dumps(trades_list) if trades_list else None
@property
def hyperparameters_json(self):
"""
Returns the hyperparameters as a Python dictionary
"""
if not self.hyperparameters:
return {}
return json.loads(self.hyperparameters)
@hyperparameters_json.setter
def hyperparameters_json(self, hp_dict):
"""
Sets the hyperparameters from a Python dictionary
"""
self.hyperparameters = json.dumps(hp_dict) if hp_dict else None
@property
def chart_data_json(self):
"""
Returns the chart data as a Python dictionary
"""
if not self.chart_data:
return {}
return json.loads(self.chart_data)
@chart_data_json.setter
def chart_data_json(self, data_dict):
"""
Sets the chart data from a Python dictionary
"""
self.chart_data = json.dumps(data_dict) if data_dict else None
@property
def state_json(self):
"""
Returns the frontend state as a Python dictionary
"""
if not self.state:
return {}
s = json.loads(self.state)
if isinstance(s, dict) and 'form' in s and isinstance(s['form'], dict):
for key in ['debug_mode', 'export_chart', 'export_tradingview', 'export_csv', 'export_json', 'fast_mode', 'benchmark']:
if key in s['form']:
s['form'][key] = jh.normalize_bool(s['form'].get(key))
return s
@state_json.setter
def state_json(self, state_data):
"""
Sets the frontend state from a Python dictionary
"""
self.state = json.dumps(state_data) if state_data else None
@property
def strategy_codes_json(self):
"""
Returns the strategy codes as a Python dictionary
"""
if not self.strategy_codes:
return {}
return json.loads(self.strategy_codes)
@strategy_codes_json.setter
def strategy_codes_json(self, codes_dict):
"""
Sets the strategy codes from a Python dictionary
"""
self.strategy_codes = json.dumps(codes_dict) if codes_dict else None
@property
def duration(self):
"""
Calculate the duration of the session in seconds
"""
if not self.updated_at:
# For running sessions, calculate duration up to now
return jh.now_to_timestamp(True) - self.created_at
# For completed sessions, use the stored timestamps
return self.updated_at - self.created_at
@property
def net_profit_percentage(self):
"""
Get the net profit percentage from metrics
"""
metrics = self.metrics_json
if not metrics:
return None
return metrics.get('net_profit_percentage', None)
# if database is open, create the table
if database.is_open():
BacktestSession.create_table()
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # DB FUNCTIONS # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
def get_backtest_session_by_id(id: str):
try:
return BacktestSession.get(BacktestSession.id == id)
except BacktestSession.DoesNotExist:
return None
def store_backtest_session(
id: str,
status: str
) -> None:
# Check if session already exists
existing_session = get_backtest_session_by_id(id)
if existing_session:
# Update existing session - reset it to fresh state
d = {
'status': status,
'metrics': None,
'equity_curve': None,
'trades': None,
'hyperparameters': None,
'chart_data': None,
'state': None,
'exception': None,
'traceback': None,
'execution_duration': None,
'updated_at': jh.now_to_timestamp(True)
}
BacktestSession.update(**d).where(BacktestSession.id == id).execute()
else:
# Create a new session
d = {
'id': id,
'status': status,
'created_at': jh.now_to_timestamp(True),
'updated_at': jh.now_to_timestamp(True)
}
BacktestSession.insert(**d).execute()
def update_backtest_session_status(id: str, status: str) -> None:
d = {
'status': status,
'updated_at': jh.now_to_timestamp(True)
}
BacktestSession.update(**d).where(BacktestSession.id == id).execute()
def store_backtest_session_exception(id: str, exception: str, traceback: str) -> None:
d = {
'exception': exception,
'traceback': traceback,
'updated_at': jh.now_to_timestamp(True)
}
BacktestSession.update(**d).where(BacktestSession.id == id).execute()
def update_backtest_session_results(
id: str,
metrics: dict = None,
equity_curve: list = None,
trades: list = None,
hyperparameters: dict = None,
chart_data: dict = None,
execution_duration: float = None,
strategy_codes: dict = None
) -> None:
d = {
'updated_at': jh.now_to_timestamp(True)
}
if metrics is not None:
d['metrics'] = json.dumps(metrics)
if equity_curve is not None:
d['equity_curve'] = json.dumps(equity_curve)
if trades is not None:
d['trades'] = json.dumps(trades)
if hyperparameters is not None:
d['hyperparameters'] = json.dumps(hyperparameters)
if chart_data is not None:
d['chart_data'] = json.dumps(chart_data)
if execution_duration is not None:
d['execution_duration'] = execution_duration
if strategy_codes is not None:
d['strategy_codes'] = json.dumps(strategy_codes)
BacktestSession.update(**d).where(BacktestSession.id == id).execute()
def get_backtest_sessions(limit: int = 50, offset: int = 0, title_search: str = None, status_filter: str = None, date_filter: str = None) -> list:
"""
Returns a list of BacktestSession objects sorted by most recently updated.
Excludes draft sessions by default.
"""
query = BacktestSession.select().where(BacktestSession.status != 'draft').order_by(BacktestSession.updated_at.desc())
# Apply title filter (case-insensitive)
if title_search:
query = query.where(BacktestSession.title.contains(title_search))
# Apply status filter
if status_filter and status_filter != 'all':
query = query.where(BacktestSession.status == status_filter)
# Apply date filter
if date_filter and date_filter != 'all_time':
current_timestamp = jh.now_to_timestamp(True)
if date_filter == '7_days':
threshold = current_timestamp - (7 * 24 * 60 * 60 * 1000)
elif date_filter == '30_days':
threshold = current_timestamp - (30 * 24 * 60 * 60 * 1000)
elif date_filter == '90_days':
threshold = current_timestamp - (90 * 24 * 60 * 60 * 1000)
else:
threshold = 0
if threshold > 0:
query = query.where(BacktestSession.created_at >= threshold)
return list(query.limit(limit).offset(offset))
def delete_backtest_session(id: str) -> bool:
try:
BacktestSession.delete().where(BacktestSession.id == id).execute()
return True
except Exception as e:
print(f"Error deleting backtest session: {e}")
return False
def purge_backtest_sessions(days_old: int = None) -> int:
try:
current_timestamp = jh.now_to_timestamp(True)
if days_old is not None:
days_old = int(days_old)
if days_old is not None and days_old > 0:
threshold = current_timestamp - (days_old * 24 * 60 * 60 * 1000)
all_sessions = BacktestSession.select()
sessions_to_delete = []
for session in all_sessions:
try:
session_updated_at = int(session.updated_at) if session.updated_at else 0
if session_updated_at < threshold:
sessions_to_delete.append(session.id)
except (ValueError, TypeError):
continue
deleted_count = 0
for session_id in sessions_to_delete:
try:
BacktestSession.delete().where(BacktestSession.id == session_id).execute()
deleted_count += 1
except Exception:
pass
else:
deleted_count = BacktestSession.delete().execute()
return deleted_count
except Exception as e:
print(f"Error purging backtest sessions: {e}")
return 0
def update_backtest_session_state(id: str, state: dict) -> None:
"""
Update or create (upsert) backtest session state. If session doesn't exist, creates as draft.
"""
if isinstance(state, dict) and 'form' in state and isinstance(state['form'], dict):
for key in ['debug_mode', 'export_chart', 'export_tradingview', 'export_csv', 'export_json', 'fast_mode', 'benchmark']:
if key in state['form']:
state['form'][key] = jh.normalize_bool(state['form'].get(key))
existing = BacktestSession.select().where(BacktestSession.id == id).first()
if existing:
# Update existing session's state
d = {
'state': json.dumps(state),
'updated_at': jh.now_to_timestamp(True)
}
BacktestSession.update(**d).where(BacktestSession.id == id).execute()
else:
# Create new draft session
d = {
'id': id,
'status': 'draft',
'state': json.dumps(state),
'created_at': jh.now_to_timestamp(True),
'updated_at': jh.now_to_timestamp(True)
}
BacktestSession.insert(**d).execute()
def update_backtest_session_notes(id: str, title: str = None, description: str = None, strategy_codes: dict = None) -> None:
d = {
'updated_at': jh.now_to_timestamp(True)
}
if title is not None:
d['title'] = title
if description is not None:
d['description'] = description
if strategy_codes is not None:
d['strategy_codes'] = json.dumps(strategy_codes)
BacktestSession.update(**d).where(BacktestSession.id == id).execute()
================================================
FILE: jesse/models/Candle.py
================================================
import peewee
from jesse.services.db import database
import jesse.helpers as jh
import numpy as np
if database.is_closed():
database.open_connection()
class Candle(peewee.Model):
id = peewee.UUIDField(primary_key=True)
timestamp = peewee.BigIntegerField()
open = peewee.FloatField()
close = peewee.FloatField()
high = peewee.FloatField()
low = peewee.FloatField()
volume = peewee.FloatField()
exchange = peewee.CharField()
symbol = peewee.CharField()
timeframe = peewee.CharField()
# partial candles: 5 * 1m candle = 5m candle while 1m == partial candle
is_partial = True
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('exchange', 'symbol', 'timeframe', 'timestamp'), True),
)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
# if database is open, create the table
if database.is_open():
Candle.create_table()
================================================
FILE: jesse/models/ClosedTrade.py
================================================
import numpy as np
import peewee
import jesse.helpers as jh
from jesse.services.db import database
from jesse.libs.dynamic_numpy_array import DynamicNumpyArray
from jesse.enums import trade_types
from jesse.models.Order import Order
from jesse.enums import order_statuses
if database.is_closed():
database.open_connection()
class ClosedTrade(peewee.Model):
"""A trade is made when a position is opened AND closed."""
id = peewee.UUIDField(primary_key=True)
session_id = peewee.UUIDField()
strategy_name = peewee.CharField()
symbol = peewee.CharField()
exchange = peewee.CharField()
type = peewee.CharField()
timeframe = peewee.CharField()
opened_at = peewee.BigIntegerField()
closed_at = peewee.BigIntegerField(null=True)
leverage = peewee.IntegerField()
created_at = peewee.BigIntegerField()
updated_at = peewee.BigIntegerField()
session_mode = peewee.CharField()
soft_deleted_at = peewee.BigIntegerField(null=True)
class Meta:
from jesse.services.db import database
database = database.db
indexes = ((('strategy_name', 'exchange', 'symbol'), False),)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
# used for fast calculation of the total qty, entry_price, exit_price, etc.
self.buy_orders = DynamicNumpyArray((10, 2))
self.sell_orders = DynamicNumpyArray((10, 2))
# to store the actual order objects
self.orders = []
@property
def to_json(self) -> dict:
return {
"id": self.id,
"strategy_name": jh.get_class_name(self.strategy_name),
"symbol": self.symbol,
"exchange": self.exchange,
"type": self.type,
"entry_price": self.entry_price,
"exit_price": self.exit_price,
"qty": self.qty,
"fee": self.fee,
"size": self.size,
"PNL": self.pnl,
"PNL_percentage": self.pnl_percentage,
"holding_period": self.holding_period,
"opened_at": self.opened_at,
"closed_at": self.closed_at,
}
@property
def to_dict(self) -> dict:
return {
'id': self.id,
'strategy_name': jh.get_class_name(self.strategy_name),
'symbol': self.symbol,
'exchange': self.exchange,
'type': self.type,
'entry_price': self.entry_price,
'exit_price': self.exit_price,
'qty': self.qty,
'opened_at': self.opened_at,
'closed_at': self.closed_at,
"fee": self.fee,
"size": self.size,
"PNL": self.pnl,
"PNL_percentage": self.pnl_percentage,
"holding_period": self.holding_period,
}
@property
def to_dict_with_orders(self) -> dict:
data = self.to_dict
data['orders'] = [order.to_dict for order in self.orders]
return data
@property
def fee(self) -> float:
return sum(order.fee or 0 for order in self.orders)
@property
def size(self) -> float:
return self.qty * self.entry_price
@property
def pnl(self) -> float:
# calculate raw profit/loss
qty = abs(self.qty)
profit = qty * (self.exit_price - self.entry_price)
if self.type == 'short':
profit *= -1
# subtract actual fee (which already uses order fees if available)
return profit - self.fee
@property
def pnl_percentage(self) -> float:
"""
Alias for self.roi
"""
return self.roi
@property
def roi(self) -> float:
"""
Return on Investment in percentage
More at: https://www.binance.com/en/support/faq/5b9ad93cb4854f5990b9fb97c03cfbeb
"""
return self.pnl / self.total_cost * 100
@property
def total_cost(self) -> float:
"""
How much we paid to open this position (currently does not include fees, should we?!)
"""
return self.entry_price * abs(self.qty) / self.leverage
@property
def holding_period(self) -> int:
"""How many SECONDS has it taken for the trade to be done."""
if self.closed_at is None:
return None
return (self.closed_at - self.opened_at) / 1000
@property
def is_long(self) -> bool:
return self.type == trade_types.LONG
@property
def is_short(self) -> bool:
return self.type == trade_types.SHORT
@property
def qty(self) -> float:
if self.is_long:
return self.buy_orders[:][:, 0].sum()
elif self.is_short:
return self.sell_orders[:][:, 0].sum()
else:
return 0.0
@property
def entry_price(self) -> float:
if self.is_long:
orders = self.buy_orders[:]
elif self.is_short:
orders = self.sell_orders[:]
else:
return np.nan
return (orders[:, 0] * orders[:, 1]).sum() / orders[:, 0].sum()
@property
def current_qty(self) -> float:
trade_orders = Order.select().where(Order.trade_id == self.id).where(Order.status == order_statuses.EXECUTED).order_by(Order.executed_at)
if len(trade_orders) == 0:
return 0.0
else:
import jesse.utils as utils
qty = 0.0
for order in trade_orders:
qty = utils.sum_floats(qty, order.filled_qty)
return qty
@property
def exit_price(self) -> float:
if self.is_long:
orders = self.sell_orders[:]
elif self.is_short:
orders = self.buy_orders[:]
else:
return np.nan
return (orders[:, 0] * orders[:, 1]).sum() / orders[:, 0].sum()
@property
def is_open(self) -> bool:
return self.opened_at is not None
# if database is open, create the table
if database.is_open():
ClosedTrade.create_table()
================================================
FILE: jesse/models/Exchange.py
================================================
from abc import ABC, abstractmethod
from jesse.models.Order import Order
import jesse.helpers as jh
from jesse.libs import DynamicNumpyArray
from jesse.info import exchange_info
from jesse.routes import router
class Exchange(ABC):
def __init__(self, name: str, starting_balance: float, fee_rate: float, exchange_type: str):
# currently holding assets
self.assets = {}
# used for calculating available balance in futures mode:
self.temp_reduced_amount = {}
# used for calculating final performance metrics
self.starting_assets = {}
# current available assets (dynamically changes based on active orders)
self.available_assets = {}
self.fee_rate = fee_rate
# some exchanges might require even further info
self.vars = {}
self.buy_orders = {}
self.sell_orders = {}
self.name = name
self.type = exchange_type.lower()
# in running session's quote currency
self.starting_balance = starting_balance
all_trading_routes = router.routes
first_route = all_trading_routes[0]
# check the settlement_currency is in the exchange info with name equal to the exchange name
if self.name in exchange_info and 'settlement_currency' in exchange_info[self.name]:
self.settlement_currency = exchange_info[self.name]['settlement_currency']
else:
self.settlement_currency = jh.quote_asset(first_route.symbol)
# initiate dict keys for trading assets
for r in all_trading_routes:
base_asset = jh.base_asset(r.symbol)
self.buy_orders[base_asset] = DynamicNumpyArray((10, 2))
self.sell_orders[base_asset] = DynamicNumpyArray((10, 2))
self.assets[base_asset] = 0.0
self.assets[self.settlement_currency] = 0.0 if jh.is_livetrading() else starting_balance
self.temp_reduced_amount[base_asset] = 0.0
self.temp_reduced_amount[self.settlement_currency] = 0.0
self.starting_assets[base_asset] = 0.0
self.starting_assets[self.settlement_currency] = starting_balance
self.available_assets[base_asset] = 0.0
self.available_assets[self.settlement_currency] = starting_balance
@property
@abstractmethod
def wallet_balance(self) -> float:
pass
@property
@abstractmethod
def available_margin(self) -> float:
pass
@abstractmethod
def on_order_submission(self, order: Order) -> None:
pass
@abstractmethod
def on_order_execution(self, order: Order) -> None:
pass
@abstractmethod
def on_order_cancellation(self, order: Order) -> None:
pass
================================================
FILE: jesse/models/ExchangeApiKeys.py
================================================
import json
import peewee
from jesse.services.db import database
if database.is_closed():
database.open_connection()
class ExchangeApiKeys(peewee.Model):
id = peewee.UUIDField(primary_key=True)
exchange_name = peewee.CharField()
name = peewee.CharField(unique=True)
api_key = peewee.CharField()
api_secret = peewee.CharField()
additional_fields = peewee.TextField()
created_at = peewee.DateTimeField()
class Meta:
from jesse.services.db import database
database = database.db
def __init__(self, attributes=None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a in attributes:
setattr(self, a, attributes[a])
def get_additional_fields(self) -> dict:
return json.loads(self.additional_fields)
# if database is open, create the table
if database.is_open():
ExchangeApiKeys.create_table()
================================================
FILE: jesse/models/FuturesExchange.py
================================================
import numpy as np
from numba import njit
import jesse.helpers as jh
import jesse.services.logger as logger
from jesse.enums import sides
from jesse.exceptions import InsufficientMargin
from jesse.models.Order import Order
from jesse.models.Exchange import Exchange
from jesse.store import store
class FuturesExchange(Exchange):
def __init__(
self,
name: str,
starting_balance: float,
fee_rate: float,
futures_leverage_mode: str,
futures_leverage: int
):
super().__init__(name, starting_balance, fee_rate, 'futures')
# # # # live-trading only # # # #
# in futures trading, margin is only with one asset, so:
self._available_margin = 0
# in futures trading, wallet is only with one asset, so:
self._wallet_balance = 0
# so is started_balance
self._started_balance = 0
# # # # # # # # # # # # # # # # #
self.futures_leverage_mode = futures_leverage_mode
self.futures_leverage = futures_leverage
@property
def started_balance(self) -> float:
if jh.is_livetrading():
return self._started_balance
return self.starting_assets[jh.app_currency()]
@property
def wallet_balance(self) -> float:
if jh.is_livetrading():
return self._wallet_balance
return self.assets[self.settlement_currency]
@property
def available_margin(self) -> float:
if jh.is_livetrading():
return self._available_margin
# In both live trading and backtesting/paper trading, we start with the balance
margin = self.wallet_balance
# Calculate the total spent amount considering leverage
# Here we need to calculate the total cost of all open positions and orders, considering leverage
total_spent = 0
for asset in self.assets:
if asset == self.settlement_currency:
continue
position = store.positions.get_position(self.name, f"{asset}-{self.settlement_currency}")
if position and position.is_open:
# Adding the cost of open positions
total_spent += position.total_cost
# add unrealized PNL
total_spent -= position.pnl
# Summing up the cost of open orders (buy and sell), considering leverage
sum_buy_orders = (self.buy_orders[asset][:][:, 0] * self.buy_orders[asset][:][:, 1]).sum()
sum_sell_orders = (self.sell_orders[asset][:][:, 0] * self.sell_orders[asset][:][:, 1]).sum()
total_spent += max(
abs(sum_buy_orders) / self.futures_leverage, abs(sum_sell_orders) / self.futures_leverage
)
# Subtracting the total spent from the margin
margin -= total_spent
return margin
def charge_fee(self, amount: float) -> None:
if jh.is_livetrading():
return
fee_amount = abs(amount) * self.fee_rate
new_balance = self.assets[self.settlement_currency] - fee_amount
if fee_amount != 0:
logger.info(
f'Charged {round(fee_amount, 2)} as fee. Balance for {self.settlement_currency} on {self.name} changed from {round(self.assets[self.settlement_currency], 2)} to {round(new_balance, 2)}'
)
self.assets[self.settlement_currency] = new_balance
def add_realized_pnl(self, realized_pnl: float) -> None:
if jh.is_livetrading():
return
new_balance = self.assets[self.settlement_currency] + realized_pnl
logger.info(
f'Added realized PNL of {round(realized_pnl, 2)}. Balance for {self.settlement_currency} on {self.name} changed from {round(self.assets[self.settlement_currency], 2)} to {round(new_balance, 2)}')
self.assets[self.settlement_currency] = new_balance
def on_order_submission(self, order: Order) -> None:
if jh.is_livetrading():
return
base_asset = jh.base_asset(order.symbol)
# make sure we don't spend more than we're allowed considering current allowed leverage
if not order.reduce_only:
# Calculate the effective order size considering leverage
effective_order_size = abs(order.qty * order.price) / self.futures_leverage
if effective_order_size > self.available_margin:
raise InsufficientMargin(
f'Cannot submit an order with a value of ${round(order.qty * order.price)} when your available margin is ${round(self.available_margin)}. Consider increasing leverage number from the settings or reducing the order size.'
)
self.available_assets[base_asset] += order.qty
if not order.reduce_only:
if order.side == sides.BUY:
self.buy_orders[base_asset].append(np.array([order.qty, order.price]))
else:
self.sell_orders[base_asset].append(np.array([order.qty, order.price]))
def on_order_execution(self, order: Order) -> None:
if jh.is_livetrading():
return
base_asset = jh.base_asset(order.symbol)
if not order.reduce_only:
order_array = np.array([order.qty, order.price])
if order.side == sides.BUY:
item_index = np.where(np.all(self.buy_orders[base_asset].array == order_array, axis=1))[0]
if len(item_index) > 0:
index = item_index[0]
self.buy_orders[base_asset].delete(index, axis=0)
else:
item_index = np.where(np.all(self.sell_orders[base_asset].array == order_array, axis=1))[0]
if len(item_index) > 0:
index = item_index[0]
self.sell_orders[base_asset].delete(index, axis=0)
def on_order_cancellation(self, order: Order) -> None:
if jh.is_livetrading():
return
base_asset = jh.base_asset(order.symbol)
self.available_assets[base_asset] -= order.qty
if not order.reduce_only:
order_array = np.array([order.qty, order.price])
if order.side == sides.BUY:
index = find_order_index(self.buy_orders[base_asset].array, order_array)
if index != -1:
self.buy_orders[base_asset].delete(index, axis=0)
else:
index = find_order_index(self.sell_orders[base_asset].array, order_array)
if index != -1:
self.sell_orders[base_asset].delete(index, axis=0)
def update_from_stream(self, data: dict) -> None:
"""
Used for updating the exchange from the WS stream (only for live trading)
"""
if not jh.is_livetrading():
raise Exception('This method is only for live trading')
self._available_margin = data['available_margin']
self._wallet_balance = data['wallet_balance']
if self._started_balance == 0:
self._started_balance = self._wallet_balance
@njit(cache=True)
def find_order_index(orders, order_array):
for i in range(len(orders)):
if np.all(orders[i] == order_array):
return i
return -1
================================================
FILE: jesse/models/LiveEquitySnapshot.py
================================================
import peewee
from jesse.services.db import database
if database.is_closed():
database.open_connection()
class LiveEquitySnapshot(peewee.Model):
session_id = peewee.UUIDField()
timestamp = peewee.BigIntegerField()
currency = peewee.CharField()
equity = peewee.DoubleField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('session_id', 'timestamp'), True), # Unique constraint
)
primary_key = peewee.CompositeKey('session_id', 'timestamp')
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
# if database is open, create the table
if database.is_open():
LiveEquitySnapshot.create_table()
================================================
FILE: jesse/models/LiveSession.py
================================================
import peewee
import json
from jesse.services.db import database
import jesse.helpers as jh
if database.is_closed():
database.open_connection()
class LiveSession(peewee.Model):
id = peewee.UUIDField(primary_key=True)
# Status of the live session: running, stopped, or terminated
status = peewee.CharField()
# Session mode: livetrade or papertrade
session_mode = peewee.CharField()
# Exchange name
exchange = peewee.CharField()
# Frontend state in JSON format - used for restoring UI state
state = peewee.TextField(null=True)
# User notes
title = peewee.CharField(max_length=255, null=True)
description = peewee.TextField(null=True)
strategy_codes = peewee.TextField(null=True)
# Error tracking
exception = peewee.TextField(null=True)
traceback = peewee.TextField(null=True)
# Timestamps for session management
finished_at = peewee.BigIntegerField(null=True)
created_at = peewee.BigIntegerField()
updated_at = peewee.BigIntegerField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('id',), True),
(('created_at',), False),
(('updated_at',), False),
)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
@property
def state_json(self):
"""
Returns the frontend state as a Python dictionary
"""
if not self.state:
return {}
s = json.loads(self.state)
if isinstance(s, dict) and 'form' in s and isinstance(s['form'], dict):
for key in ['debug_mode', 'export_chart', 'export_tradingview', 'export_csv', 'export_json', 'fast_mode', 'benchmark']:
if key in s['form']:
s['form'][key] = jh.normalize_bool(s['form'].get(key))
return s
@state_json.setter
def state_json(self, state_data):
"""
Sets the frontend state from a Python dictionary
"""
self.state = json.dumps(state_data) if state_data else None
@property
def strategy_codes_json(self):
"""
Returns the strategy codes as a Python dictionary
"""
if not self.strategy_codes:
return {}
return json.loads(self.strategy_codes)
@strategy_codes_json.setter
def strategy_codes_json(self, codes_dict):
"""
Sets the strategy codes from a Python dictionary
"""
self.strategy_codes = json.dumps(codes_dict) if codes_dict else None
@property
def duration(self):
"""
Calculate the duration of the session in seconds
"""
if self.finished_at:
# For completed sessions, use the stored timestamps
return self.finished_at - self.created_at
else:
# For running sessions, calculate duration up to now
return jh.now_to_timestamp(True) - self.created_at
# if database is open, create the table
if database.is_open():
LiveSession.create_table()
================================================
FILE: jesse/models/Log.py
================================================
import peewee
from jesse.services.db import database
if database.is_closed():
database.open_connection()
class Log(peewee.Model):
id = peewee.UUIDField(primary_key=True)
session_id = peewee.UUIDField(index=True)
timestamp = peewee.BigIntegerField()
message = peewee.TextField()
# 1: info, 2: error, maybe add more in the future?
type = peewee.SmallIntegerField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('session_id', 'type', 'timestamp'), False),
)
def __init__(self, attributes=None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a in attributes:
setattr(self, a, attributes[a])
# if database is open, create the table
if database.is_open():
Log.create_table()
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # DB FUNCTIONS # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
def store_log_into_db(log: dict, log_type: str) -> None:
if log_type == 'info':
log_type = 1
elif log_type == 'error':
log_type = 2
else:
raise ValueError(f"Unsupported log_type value: {log_type}")
d = {
'id': log['id'],
'session_id': log['session_id'],
'type': log_type,
'timestamp': log['timestamp'],
'message': log['message']
}
try:
Log.insert(**d).execute()
except Exception:
try:
database.db.rollback()
except Exception:
pass
try:
Log.insert(**d).execute()
except Exception:
pass
================================================
FILE: jesse/models/MonteCarloSession.py
================================================
import peewee
import json
import numpy as np
from jesse.services.db import database
import jesse.helpers as jh
def _convert_numpy_types(obj):
"""Convert NumPy types to native Python types for JSON serialization"""
if isinstance(obj, dict):
return {k: _convert_numpy_types(v) for k, v in obj.items()}
elif isinstance(obj, list):
return [_convert_numpy_types(item) for item in obj]
elif isinstance(obj, np.integer):
return int(obj)
elif isinstance(obj, np.floating):
return float(obj)
elif isinstance(obj, np.bool_):
return bool(obj)
elif isinstance(obj, np.ndarray):
return obj.tolist()
return obj
if database.is_closed():
database.open_connection()
class MonteCarloSession(peewee.Model):
id = peewee.UUIDField(primary_key=True)
status = peewee.CharField()
state = peewee.TextField(null=True)
title = peewee.CharField(max_length=255, null=True)
description = peewee.TextField(null=True)
strategy_codes = peewee.TextField(null=True)
created_at = peewee.BigIntegerField()
updated_at = peewee.BigIntegerField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('id',), True),
(('updated_at',), False),
)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
@property
def state_json(self):
if not self.state:
return {}
s = json.loads(self.state)
if isinstance(s, dict) and 'form' in s and isinstance(s['form'], dict):
for key in ['debug_mode', 'export_chart', 'export_tradingview', 'export_csv', 'export_json', 'fast_mode', 'benchmark']:
if key in s['form']:
s['form'][key] = jh.normalize_bool(s['form'].get(key))
return s
@state_json.setter
def state_json(self, state_data):
self.state = json.dumps(state_data)
@property
def strategy_codes_json(self):
if not self.strategy_codes:
return {}
return json.loads(self.strategy_codes)
@strategy_codes_json.setter
def strategy_codes_json(self, codes_dict):
self.strategy_codes = json.dumps(codes_dict) if codes_dict else None
@property
def trades_session(self):
try:
return MonteCarloTradesSession.get(
MonteCarloTradesSession.monte_carlo_session_id == self.id
)
except MonteCarloTradesSession.DoesNotExist:
return None
@property
def candles_session(self):
try:
return MonteCarloCandlesSession.get(
MonteCarloCandlesSession.monte_carlo_session_id == self.id
)
except MonteCarloCandlesSession.DoesNotExist:
return None
class MonteCarloTradesSession(peewee.Model):
id = peewee.UUIDField(primary_key=True)
monte_carlo_session_id = peewee.UUIDField()
num_scenarios = peewee.IntegerField()
completed_scenarios = peewee.IntegerField(default=0)
status = peewee.CharField()
results = peewee.TextField(null=True)
logs = peewee.TextField(null=True)
exception = peewee.TextField(null=True)
traceback = peewee.TextField(null=True)
created_at = peewee.BigIntegerField()
updated_at = peewee.BigIntegerField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('id',), True),
(('monte_carlo_session_id',), False),
)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
@property
def results_json(self):
if not self.results:
return {}
return json.loads(self.results)
@results_json.setter
def results_json(self, results_data):
self.results = json.dumps(results_data)
class MonteCarloCandlesSession(peewee.Model):
id = peewee.UUIDField(primary_key=True)
monte_carlo_session_id = peewee.UUIDField()
num_scenarios = peewee.IntegerField()
completed_scenarios = peewee.IntegerField(default=0)
status = peewee.CharField()
pipeline_type = peewee.CharField()
pipeline_params = peewee.TextField(null=True)
results = peewee.TextField(null=True)
logs = peewee.TextField(null=True)
exception = peewee.TextField(null=True)
traceback = peewee.TextField(null=True)
created_at = peewee.BigIntegerField()
updated_at = peewee.BigIntegerField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('id',), True),
(('monte_carlo_session_id',), False),
)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
@property
def results_json(self):
if not self.results:
return {}
return json.loads(self.results)
@results_json.setter
def results_json(self, results_data):
self.results = json.dumps(results_data)
@property
def pipeline_params_json(self):
if not self.pipeline_params:
return {}
return json.loads(self.pipeline_params)
@pipeline_params_json.setter
def pipeline_params_json(self, params_data):
self.pipeline_params = json.dumps(params_data)
# Create tables if database is open
if database.is_open():
MonteCarloSession.create_table()
MonteCarloTradesSession.create_table()
MonteCarloCandlesSession.create_table()
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # DB FUNCTIONS # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# Parent Session Functions
def get_monte_carlo_session_by_id(id: str):
try:
return MonteCarloSession.get(MonteCarloSession.id == id)
except MonteCarloSession.DoesNotExist:
return None
def get_monte_carlo_sessions(limit: int = 50, offset: int = 0, title_search: str = None, status_filter: str = None, date_filter: str = None):
"""
Returns a list of MonteCarloSession objects sorted by most recently updated.
Excludes draft sessions by default.
"""
query = MonteCarloSession.select().where(MonteCarloSession.status != 'draft').order_by(MonteCarloSession.updated_at.desc())
# Apply title filter (case-insensitive)
if title_search:
query = query.where(MonteCarloSession.title.contains(title_search))
# Apply status filter
if status_filter and status_filter != 'all':
query = query.where(MonteCarloSession.status == status_filter)
# Apply date filter
if date_filter and date_filter != 'all_time':
current_timestamp = jh.now_to_timestamp(True)
if date_filter == '7_days':
threshold = current_timestamp - (7 * 24 * 60 * 60 * 1000)
elif date_filter == '30_days':
threshold = current_timestamp - (30 * 24 * 60 * 60 * 1000)
elif date_filter == '90_days':
threshold = current_timestamp - (90 * 24 * 60 * 60 * 1000)
else:
threshold = 0
if threshold > 0:
query = query.where(MonteCarloSession.created_at >= threshold)
return list(query.limit(limit).offset(offset))
def store_monte_carlo_session(id: str, status: str, state: dict = None, strategy_codes: dict = None) -> None:
if isinstance(state, dict) and 'form' in state and isinstance(state['form'], dict):
for key in ['debug_mode', 'export_chart', 'export_tradingview', 'export_csv', 'export_json', 'fast_mode', 'benchmark']:
if key in state['form']:
state['form'][key] = jh.normalize_bool(state['form'].get(key))
d = {
'id': id,
'status': status,
'state': json.dumps(state) if state else None,
'created_at': jh.now_to_timestamp(True),
'updated_at': jh.now_to_timestamp(True)
}
if strategy_codes is not None:
d['strategy_codes'] = json.dumps(strategy_codes)
MonteCarloSession.insert(**d).execute()
def update_monte_carlo_session_status(id: str, status: str) -> None:
d = {
'status': status,
'updated_at': jh.now_to_timestamp(True)
}
MonteCarloSession.update(**d).where(MonteCarloSession.id == id).execute()
def update_monte_carlo_session_state(id: str, state: dict, strategy_codes: dict = None) -> None:
"""
Update or create (upsert) monte carlo session state. If session doesn't exist, creates as draft.
"""
if isinstance(state, dict) and 'form' in state and isinstance(state['form'], dict):
for key in ['debug_mode', 'export_chart', 'export_tradingview', 'export_csv', 'export_json', 'fast_mode', 'benchmark']:
if key in state['form']:
state['form'][key] = jh.normalize_bool(state['form'].get(key))
existing = MonteCarloSession.select().where(MonteCarloSession.id == id).first()
if existing:
# Update existing session's state
d = {
'state': json.dumps(state),
'updated_at': jh.now_to_timestamp(True)
}
if strategy_codes is not None:
d['strategy_codes'] = json.dumps(strategy_codes)
MonteCarloSession.update(**d).where(MonteCarloSession.id == id).execute()
else:
# Create new draft session
d = {
'id': id,
'status': 'draft',
'state': json.dumps(state),
'created_at': jh.now_to_timestamp(True),
'updated_at': jh.now_to_timestamp(True)
}
MonteCarloSession.insert(**d).execute()
def delete_monte_carlo_session(id: str) -> bool:
try:
# Delete child sessions first
MonteCarloTradesSession.delete().where(
MonteCarloTradesSession.monte_carlo_session_id == id
).execute()
MonteCarloCandlesSession.delete().where(
MonteCarloCandlesSession.monte_carlo_session_id == id
).execute()
# Delete parent session
MonteCarloSession.delete().where(MonteCarloSession.id == id).execute()
return True
except Exception as e:
print(f"Error deleting Monte Carlo session: {e}")
return False
def update_monte_carlo_session_notes(id: str, title: str = None, description: str = None, strategy_codes: dict = None) -> None:
d = {
'updated_at': jh.now_to_timestamp(True)
}
if title is not None:
d['title'] = title
if description is not None:
d['description'] = description
if strategy_codes is not None:
d['strategy_codes'] = json.dumps(strategy_codes)
MonteCarloSession.update(**d).where(MonteCarloSession.id == id).execute()
def purge_monte_carlo_sessions(days_old: int = None) -> int:
try:
current_timestamp = jh.now_to_timestamp(True)
if days_old is not None:
days_old = int(days_old)
if days_old is not None and days_old > 0:
threshold = current_timestamp - (days_old * 24 * 60 * 60 * 1000)
all_sessions = MonteCarloSession.select()
sessions_to_delete = []
for session in all_sessions:
try:
session_updated_at = int(session.updated_at) if session.updated_at else 0
if session_updated_at < threshold:
sessions_to_delete.append(session.id)
except (ValueError, TypeError):
continue
deleted_count = 0
for session_id in sessions_to_delete:
try:
if delete_monte_carlo_session(session_id):
deleted_count += 1
except Exception:
pass
else:
# Delete all sessions
all_sessions = MonteCarloSession.select()
deleted_count = 0
for session in all_sessions:
try:
if delete_monte_carlo_session(str(session.id)):
deleted_count += 1
except Exception:
pass
return deleted_count
except Exception as e:
print(f"Error purging Monte Carlo sessions: {e}")
return 0
def get_running_monte_carlo_session_id():
try:
session = MonteCarloSession.select().where(MonteCarloSession.status == 'running').order_by(MonteCarloSession.updated_at.desc()).first()
if session:
return str(session.id)
return None
except Exception as e:
raise e
# Trades Session Functions
def get_trades_session_by_parent_id(parent_id: str):
try:
return MonteCarloTradesSession.get(
MonteCarloTradesSession.monte_carlo_session_id == parent_id
)
except MonteCarloTradesSession.DoesNotExist:
return None
def store_trades_session(parent_id: str, num_scenarios: int) -> str:
import uuid
session_id = str(uuid.uuid4())
d = {
'id': session_id,
'monte_carlo_session_id': parent_id,
'num_scenarios': num_scenarios,
'completed_scenarios': 0,
'status': 'running',
'created_at': jh.now_to_timestamp(True),
'updated_at': jh.now_to_timestamp(True)
}
MonteCarloTradesSession.insert(**d).execute()
return session_id
def update_trades_session_progress(id: str, completed: int, results: dict = None) -> None:
d = {
'completed_scenarios': completed,
'updated_at': jh.now_to_timestamp(True)
}
if results is not None:
# Convert NumPy types to native Python types before JSON serialization
cleaned_results = _convert_numpy_types(results)
d['results'] = json.dumps(cleaned_results)
MonteCarloTradesSession.update(**d).where(MonteCarloTradesSession.id == id).execute()
def update_trades_session_status(id: str, status: str) -> None:
d = {
'status': status,
'updated_at': jh.now_to_timestamp(True)
}
MonteCarloTradesSession.update(**d).where(MonteCarloTradesSession.id == id).execute()
# Candles Session Functions
def get_candles_session_by_parent_id(parent_id: str):
try:
return MonteCarloCandlesSession.get(
MonteCarloCandlesSession.monte_carlo_session_id == parent_id
)
except MonteCarloCandlesSession.DoesNotExist:
return None
def store_candles_session(parent_id: str, num_scenarios: int, pipeline_type: str, pipeline_params: dict) -> str:
import uuid
session_id = str(uuid.uuid4())
d = {
'id': session_id,
'monte_carlo_session_id': parent_id,
'num_scenarios': num_scenarios,
'completed_scenarios': 0,
'status': 'running',
'pipeline_type': pipeline_type,
'pipeline_params': json.dumps(pipeline_params),
'created_at': jh.now_to_timestamp(True),
'updated_at': jh.now_to_timestamp(True)
}
MonteCarloCandlesSession.insert(**d).execute()
return session_id
def update_candles_session_progress(id: str, completed: int, results: dict = None) -> None:
d = {
'completed_scenarios': completed,
'updated_at': jh.now_to_timestamp(True)
}
if results is not None:
# Convert NumPy types to native Python types before JSON serialization
cleaned_results = _convert_numpy_types(results)
d['results'] = json.dumps(cleaned_results)
MonteCarloCandlesSession.update(**d).where(MonteCarloCandlesSession.id == id).execute()
def update_candles_session_status(id: str, status: str) -> None:
d = {
'status': status,
'updated_at': jh.now_to_timestamp(True)
}
MonteCarloCandlesSession.update(**d).where(MonteCarloCandlesSession.id == id).execute()
# Exception and Logs Functions
def store_session_exception(session_id: str, session_type: str, exception: str, traceback: str) -> None:
d = {
'exception': exception,
'traceback': traceback,
'status': 'stopped',
'updated_at': jh.now_to_timestamp(True)
}
if session_type == 'trades':
MonteCarloTradesSession.update(**d).where(MonteCarloTradesSession.id == session_id).execute()
elif session_type == 'candles':
MonteCarloCandlesSession.update(**d).where(MonteCarloCandlesSession.id == session_id).execute()
def append_session_logs(session_id: str, session_type: str, log_message: str) -> None:
if session_type == 'trades':
session = MonteCarloTradesSession.get(MonteCarloTradesSession.id == session_id)
current_logs = session.logs or ''
new_logs = current_logs + log_message + '\n'
MonteCarloTradesSession.update(
logs=new_logs,
updated_at=jh.now_to_timestamp(True)
).where(MonteCarloTradesSession.id == session_id).execute()
elif session_type == 'candles':
session = MonteCarloCandlesSession.get(MonteCarloCandlesSession.id == session_id)
current_logs = session.logs or ''
new_logs = current_logs + log_message + '\n'
MonteCarloCandlesSession.update(
logs=new_logs,
updated_at=jh.now_to_timestamp(True)
).where(MonteCarloCandlesSession.id == session_id).execute()
def append_monte_carlo_session_logs(session_id: str, log_message: str) -> None:
"""Append logs to the parent Monte Carlo session"""
try:
session = MonteCarloSession.get(MonteCarloSession.id == session_id)
current_logs = session.logs or ''
new_logs = current_logs + log_message + '\n'
MonteCarloSession.update(
logs=new_logs,
updated_at=jh.now_to_timestamp(True)
).where(MonteCarloSession.id == session_id).execute()
except Exception as e:
# Session doesn't exist yet, silently fail
jh.dump(f'exception: {e}')
raise
pass
================================================
FILE: jesse/models/NotificationApiKeys.py
================================================
import peewee
from jesse.services.db import database
if database.is_closed():
database.open_connection()
class NotificationApiKeys(peewee.Model):
id = peewee.UUIDField(primary_key=True)
name = peewee.CharField(unique=True)
driver = peewee.CharField() # notification driver (Telegram, Discord, Slack)
fields = peewee.TextField() # for storing the fields as a JSON string
created_at = peewee.DateTimeField()
class Meta:
from jesse.services.db import database
database = database.db
def __init__(self, attributes=None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a in attributes:
setattr(self, a, attributes[a])
# if database is open, create the table
if database.is_open():
NotificationApiKeys.create_table()
================================================
FILE: jesse/models/OpenTab.py
================================================
import peewee
from jesse.services.db import database
import jesse.helpers as jh
if database.is_closed():
database.open_connection()
class OpenTab(peewee.Model):
id = peewee.UUIDField(primary_key=True)
# Module name: live, backtest, optimization, monte_carlo
module = peewee.CharField(max_length=50)
# The session_id this tab references
session_id = peewee.UUIDField()
# Order index for tab ordering within the module
order_index = peewee.IntegerField()
# Timestamps
created_at = peewee.BigIntegerField()
updated_at = peewee.BigIntegerField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('module', 'session_id'), True),
)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
================================================
FILE: jesse/models/OptimizationSession.py
================================================
import peewee
import json
from jesse.services.db import database
import jesse.helpers as jh
import json
if database.is_closed():
database.open_connection()
class OptimizationSession(peewee.Model):
id = peewee.UUIDField(primary_key=True)
# Status of the optimization session: running, paused, finished, or stopped
status = peewee.CharField()
# Best trials data in JSON format
best_trials = peewee.TextField(null=True)
# Objective curve data in JSON format
objective_curve = peewee.TextField(null=True)
# Frontend state in JSON format - used for restoring UI state
state = peewee.TextField(null=True)
# Progress tracking
completed_trials = peewee.IntegerField(default=0)
total_trials = peewee.IntegerField(default=0)
exception = peewee.TextField(null=True)
traceback = peewee.TextField(null=True)
# User notes
title = peewee.CharField(max_length=255, null=True)
description = peewee.TextField(null=True)
strategy_codes = peewee.TextField(null=True)
# Timestamps for session management
created_at = peewee.BigIntegerField()
updated_at = peewee.BigIntegerField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = (
(('id',), True),
(('updated_at',), False),
)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
@property
def best_trials_json(self):
"""
Returns the best trials as a Python list
"""
if not self.best_trials:
return []
return json.loads(self.best_trials)
@best_trials_json.setter
def best_trials_json(self, trials_list):
"""
Sets the best trials from a Python list
"""
self.best_trials = json.dumps(trials_list)
@property
def objective_curve_json(self):
"""
Returns the objective curve data as a Python list
"""
if not self.objective_curve:
return []
return json.loads(self.objective_curve)
@objective_curve_json.setter
def objective_curve_json(self, curve_data):
"""
Sets the objective curve data from a Python list
"""
self.objective_curve = json.dumps(curve_data)
@property
def state_json(self):
"""
Returns the frontend state as a Python dictionary
"""
if not self.state:
return {}
s = json.loads(self.state)
if isinstance(s, dict) and 'form' in s and isinstance(s['form'], dict):
for key in ['debug_mode', 'export_chart', 'export_tradingview', 'export_csv', 'export_json', 'fast_mode', 'benchmark']:
if key in s['form']:
s['form'][key] = jh.normalize_bool(s['form'].get(key))
return s
@state_json.setter
def state_json(self, state_data):
"""
Sets the frontend state from a Python dictionary
"""
self.state = json.dumps(state_data)
@property
def strategy_codes_json(self):
"""
Returns the strategy codes as a Python dictionary
"""
if not self.strategy_codes:
return {}
return json.loads(self.strategy_codes)
@strategy_codes_json.setter
def strategy_codes_json(self, codes_dict):
"""
Sets the strategy codes from a Python dictionary
"""
self.strategy_codes = json.dumps(codes_dict) if codes_dict else None
@property
def duration(self):
"""
Calculate the duration of the session in seconds
"""
if not self.updated_at:
# For running sessions, calculate duration up to now
import jesse.helpers as jh
return jh.now_to_timestamp(True) - self.created_at
# For completed sessions, use the stored timestamps
return self.updated_at - self.created_at
@property
def best_score(self):
"""
Get the best score from the best trials
"""
trials = self.best_trials_json
if not trials:
return None
# The first trial in the list should be the best one
# (assuming trials are sorted by score)
return trials[0].get('fitness', None)
# if database is open, create the table
if database.is_open():
OptimizationSession.create_table()
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # DB FUNCTIONS # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
def get_optimization_session_by_id(id: str):
try:
return OptimizationSession.get(OptimizationSession.id == id)
except OptimizationSession.DoesNotExist:
return None
def reset_optimization_session(id: str):
OptimizationSession.update(
status='running',
completed_trials=0,
best_trials=None,
objective_curve=None,
exception=None,
traceback=None,
updated_at=jh.now_to_timestamp(True)
).where(OptimizationSession.id == id).execute()
def store_optimization_session(
id: str,
status: str,
strategy_codes: dict = None
) -> None:
# Create a new session
d = {
'id': id,
'status': status,
'completed_trials': 0,
'created_at': jh.now_to_timestamp(True),
'updated_at': jh.now_to_timestamp(True)
}
if strategy_codes is not None:
d['strategy_codes'] = json.dumps(strategy_codes)
# Save to database
OptimizationSession.insert(**d).execute()
def update_optimization_session_status(id: str, status: str) -> None:
d = {
'status': status,
'updated_at': jh.now_to_timestamp(True)
}
OptimizationSession.update(**d).where(OptimizationSession.id == id).execute()
def add_session_exception(id: str, exception: str, traceback: str) -> None:
d = {
'exception': exception,
'traceback': traceback,
'updated_at': jh.now_to_timestamp(True)
}
OptimizationSession.update(**d).where(OptimizationSession.id == id).execute()
def update_optimization_session_trials(
id: str,
completed_trials: int,
best_trials: list = None,
objective_curve: list = None,
total_trials: int = None
) -> None:
d = {
'completed_trials': completed_trials,
'total_trials': total_trials,
'updated_at': jh.now_to_timestamp(True)
}
if best_trials is not None:
d['best_trials'] = json.dumps(best_trials)
if objective_curve is not None:
d['objective_curve'] = json.dumps(objective_curve)
OptimizationSession.update(**d).where(OptimizationSession.id == id).execute()
def get_optimization_session(id: str) -> dict:
session = OptimizationSession.get(OptimizationSession.id == id)
return {
'id': session.id,
'status': session.status,
'best_trials': session.best_trials_json,
'objective_curve': session.objective_curve_json,
'completed_trials': session.completed_trials,
'created_at': session.created_at,
'updated_at': session.updated_at,
'best_score': session.best_score,
'state': session.state_json
}
def get_optimization_sessions(limit: int = 50, offset: int = 0, title_search: str = None, status_filter: str = None, date_filter: str = None) -> list:
"""
Returns a list of OptimizationSession objects sorted by most recently updated.
Excludes draft sessions by default.
"""
query = OptimizationSession.select().where(OptimizationSession.status != 'draft').order_by(OptimizationSession.updated_at.desc())
# Apply title filter (case-insensitive)
if title_search:
query = query.where(OptimizationSession.title.contains(title_search))
# Apply status filter
if status_filter and status_filter != 'all':
query = query.where(OptimizationSession.status == status_filter)
# Apply date filter
if date_filter and date_filter != 'all_time':
current_timestamp = jh.now_to_timestamp(True)
if date_filter == '7_days':
threshold = current_timestamp - (7 * 24 * 60 * 60 * 1000)
elif date_filter == '30_days':
threshold = current_timestamp - (30 * 24 * 60 * 60 * 1000)
elif date_filter == '90_days':
threshold = current_timestamp - (90 * 24 * 60 * 60 * 1000)
else:
threshold = 0
if threshold > 0:
query = query.where(OptimizationSession.created_at >= threshold)
return list(query.limit(limit).offset(offset))
def delete_optimization_session(id: str) -> bool:
try:
OptimizationSession.delete().where(OptimizationSession.id == id).execute()
return True
except Exception as e:
print(f"Error deleting optimization session: {e}")
return False
def update_optimization_session_state(id: str, state: dict, strategy_codes: dict = None) -> None:
"""
Update or create (upsert) optimization session state. If session doesn't exist, creates as draft.
"""
if isinstance(state, dict) and 'form' in state and isinstance(state['form'], dict):
for key in ['debug_mode', 'export_chart', 'export_tradingview', 'export_csv', 'export_json', 'fast_mode', 'benchmark']:
if key in state['form']:
state['form'][key] = jh.normalize_bool(state['form'].get(key))
existing = OptimizationSession.select().where(OptimizationSession.id == id).first()
if existing:
# Update existing session's state
d = {
'state': json.dumps(state),
'updated_at': jh.now_to_timestamp(True)
}
if strategy_codes is not None:
d['strategy_codes'] = json.dumps(strategy_codes)
OptimizationSession.update(**d).where(OptimizationSession.id == id).execute()
else:
# Create new draft session
d = {
'id': id,
'status': 'draft',
'state': json.dumps(state),
'completed_trials': 0,
'total_trials': 0,
'created_at': jh.now_to_timestamp(True),
'updated_at': jh.now_to_timestamp(True)
}
OptimizationSession.insert(**d).execute()
def update_optimization_session_notes(id: str, title: str = None, description: str = None, strategy_codes: dict = None) -> None:
d = {
'updated_at': jh.now_to_timestamp(True)
}
OptimizationSession.update(**d).where(OptimizationSession.id == id).execute()
def update_optimization_session_notes(id: str, title: str = None, description: str = None, strategy_codes: dict = None) -> None:
d = {
'updated_at': jh.now_to_timestamp(True)
}
if title is not None:
d['title'] = title
if description is not None:
d['description'] = description
if strategy_codes is not None:
d['strategy_codes'] = json.dumps(strategy_codes)
OptimizationSession.update(**d).where(OptimizationSession.id == id).execute()
def purge_optimization_sessions(days_old: int = None) -> int:
try:
current_timestamp = jh.now_to_timestamp(True)
if days_old is not None:
days_old = int(days_old)
if days_old is not None and days_old > 0:
threshold = current_timestamp - (days_old * 24 * 60 * 60 * 1000)
all_sessions = OptimizationSession.select()
sessions_to_delete = []
for session in all_sessions:
try:
session_updated_at = int(session.updated_at) if session.updated_at else 0
if session_updated_at < threshold:
sessions_to_delete.append(session.id)
except (ValueError, TypeError):
continue
deleted_count = 0
for session_id in sessions_to_delete:
try:
OptimizationSession.delete().where(OptimizationSession.id == session_id).execute()
deleted_count += 1
except Exception:
pass
else:
deleted_count = OptimizationSession.delete().execute()
return deleted_count
except Exception as e:
print(f"Error purging optimization sessions: {e}")
return 0
def get_running_optimization_session_id():
try:
session = OptimizationSession.select().where(OptimizationSession.status == 'running').order_by(OptimizationSession.updated_at.desc()).first()
if session:
return str(session.id)
return None
except Exception as e:
raise e
================================================
FILE: jesse/models/Option.py
================================================
import peewee
from jesse.services.db import database
if database.is_closed():
database.open_connection()
class Option(peewee.Model):
id = peewee.UUIDField(primary_key=True)
updated_at = peewee.BigIntegerField()
type = peewee.CharField()
json = peewee.TextField()
class Meta:
from jesse.services.db import database
database = database.db
def __init__(self, attributes=None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a in attributes:
setattr(self, a, attributes[a])
# if database is open, create the table
if database.is_open():
Option.create_table()
================================================
FILE: jesse/models/Order.py
================================================
from playhouse.postgres_ext import *
import jesse.helpers as jh
from jesse.enums import order_statuses, order_submitted_via
from jesse.services.db import database
if database.is_closed():
database.open_connection()
class Order(Model):
# id generated by Jesse for database usage
id = UUIDField(primary_key=True)
trade_id = UUIDField(index=True, null=True)
session_id = UUIDField(index=True)
# id generated by market, used in live-trade mode
exchange_id = CharField(null=True)
# some exchanges might require even further info
vars = JSONField(default={})
symbol = CharField()
exchange = CharField()
side = CharField()
type = CharField()
reduce_only = BooleanField()
qty = FloatField()
filled_qty = FloatField(default=0)
price = FloatField(null=True)
status = CharField(default=order_statuses.ACTIVE)
created_at = BigIntegerField()
updated_at = BigIntegerField()
executed_at = BigIntegerField(null=True)
canceled_at = BigIntegerField(null=True)
session_mode = CharField()
jesse_submitted = BooleanField(default=True)
submitted_via = CharField(null=True)
order_exist_in_exchange = BooleanField(default=True)
fee = FloatField(null=True)
class Meta:
from jesse.services.db import database
database = database.db
indexes = ((('trade_id', 'exchange', 'symbol', 'status', 'created_at'), False),)
def __init__(self, attributes: dict = None, **kwargs) -> None:
Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
@property
def is_canceled(self) -> bool:
return self.status == order_statuses.CANCELED
@property
def is_active(self) -> bool:
return self.status == order_statuses.ACTIVE
@property
def is_cancellable(self):
"""
orders that are either active or partially filled
"""
return self.is_active or self.is_partially_filled or self.is_queued
@property
def is_queued(self) -> bool:
"""
Used in live mode only: it means the strategy has considered the order as submitted,
but the exchange does not accept it because of the distance between the current
price and price of the order. Hence it's been queued for later submission.
:return: bool
"""
return self.status == order_statuses.QUEUED
@property
def is_new(self) -> bool:
return self.is_active
@property
def is_executed(self) -> bool:
return self.status == order_statuses.EXECUTED
@property
def is_filled(self) -> bool:
return self.is_executed
@property
def is_partially_filled(self) -> bool:
return self.status == order_statuses.PARTIALLY_FILLED
@property
def is_stop_loss(self):
return self.submitted_via == order_submitted_via.STOP_LOSS
@property
def is_take_profit(self):
return self.submitted_via == order_submitted_via.TAKE_PROFIT
@property
def to_dict(self):
return {
'id': self.id,
'trade_id': self.trade_id,
'session_id': self.session_id,
'exchange_id': self.exchange_id,
'symbol': self.symbol,
'side': self.side,
'type': self.type,
'qty': self.qty,
'filled_qty': self.filled_qty,
'price': self.price,
'status': self.status,
'created_at': self.created_at,
'canceled_at': self.canceled_at,
'executed_at': self.executed_at,
'exchange': self.exchange,
'reduce_only': self.reduce_only,
'submitted_via': self.submitted_via,
'jesse_submitted': self.jesse_submitted,
'order_exist_in_exchange': self.order_exist_in_exchange,
'updated_at': self.updated_at,
'session_mode': self.session_mode,
}
@property
def value(self) -> float:
return abs(self.qty) * self.price
@property
def remaining_qty(self) -> float:
return jh.prepare_qty(abs(self.qty) - abs(self.filled_qty), self.side)
if database.is_open():
Order.create_table()
================================================
FILE: jesse/models/Orderbook.py
================================================
import peewee
import jesse.helpers as jh
import numpy as np
class Orderbook(peewee.Model):
id = peewee.UUIDField(primary_key=True)
# timestamp in milliseconds
timestamp = peewee.BigIntegerField()
symbol = peewee.CharField()
exchange = peewee.CharField()
data = peewee.BlobField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = ((('exchange', 'symbol', 'timestamp'), True),)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # DB FUNCTIONS # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
def store_orderbook_into_db(exchange: str, symbol: str, orderbook: np.ndarray) -> None:
return
d = {
'id': jh.generate_unique_id(),
'timestamp': jh.now_to_timestamp(),
'data': orderbook.dumps(),
'symbol': symbol,
'exchange': exchange,
}
def async_save() -> None:
Orderbook.insert(**d).on_conflict_ignore().execute()
print(
jh.color(
f'orderbook: {jh.timestamp_to_time(d["timestamp"])}-{exchange}-{symbol}: [{orderbook[0][0][0]}, {orderbook[0][0][1]}], [{orderbook[1][0][0]}, {orderbook[1][0][1]}]',
'magenta'
)
)
# async call
threading.Thread(target=async_save).start()
================================================
FILE: jesse/models/Position.py
================================================
from typing import Union
import numpy as np
import jesse.helpers as jh
class Position:
id: str = None
entry_price: float = None
exit_price: float = None
current_price: float = None
qty: float = 0
previous_qty: float = 0
opened_at: int = None
closed_at: int = None
_mark_price: float = None
_funding_rate: float = None
_next_funding_timestamp: int = None
_liquidation_price: float = None
exchange_name: str = None
exchange = None
symbol: str = None
strategy = None
def __init__(self, attributes: dict = None) -> None:
if attributes is None:
attributes = {}
for a in attributes:
setattr(self, a, attributes[a])
@property
def mark_price(self) -> float:
if not jh.is_live():
return self.current_price
if self.exchange_type == 'spot':
return self.current_price
return self._mark_price
@property
def funding_rate(self) -> float:
if not jh.is_live():
return 0
if self.exchange_type == 'spot':
raise ValueError('funding rate is not applicable to spot trading')
return self._funding_rate
@property
def next_funding_timestamp(self) -> Union[int, None]:
if not jh.is_live():
return None
if self.exchange_type == 'spot':
raise ValueError('funding rate is not applicable to spot trading')
return self._next_funding_timestamp
@property
def value(self) -> float:
"""
The value of open position in the quote currency
:return: float
"""
if self.is_close:
return 0
if self.current_price is None:
return None
return abs(self.current_price * self.qty)
@property
def type(self) -> str:
"""
The type of open position - long, short, or close
:return: str
"""
if self.is_long:
return 'long'
elif self.is_short:
return 'short'
return 'close'
@property
def pnl_percentage(self) -> float:
"""
Alias for self.roi
:return: float
"""
return self.roi
@property
def roi(self) -> float:
"""
Return on Investment in percentage
More at: https://www.binance.com/en/support/faq/5b9ad93cb4854f5990b9fb97c03cfbeb
"""
if self.pnl == 0:
return 0
return self.pnl / self.total_cost * 100
@property
def total_cost(self) -> float:
"""
How much we paid to open this position (currently does not include fees, should we?!)
"""
if self.is_close:
return np.nan
base_cost = self.entry_price * abs(self.qty)
if self.strategy:
return base_cost / self.leverage
return base_cost
@property
def leverage(self) -> Union[int, np.float64]:
if self.exchange_type == 'spot':
return 1
if self.strategy:
return self.strategy.leverage
else:
return np.nan
@property
def exchange_type(self) -> str:
return self.exchange.type
@property
def entry_margin(self) -> float:
"""
Alias for self.total_cost
"""
return self.total_cost
@property
def pnl(self) -> float:
"""
The PNL of the position
:return: float
"""
if abs(self.qty) < self._min_qty:
return 0
if self.entry_price is None:
return 0
if self.value is None:
return 0
diff = self.value - abs(self.entry_price * self.qty)
return -diff if self.type == 'short' else diff
@property
def is_open(self) -> bool:
"""
Is the current position open?
:return: bool
"""
return self.type in ['long', 'short']
@property
def is_close(self) -> bool:
"""
Is the current position close?
:return: bool
"""
return self.type == 'close'
@property
def is_long(self) -> bool:
"""
Is the current position a long position?
:return: bool
"""
return self.qty > self._min_qty
@property
def is_short(self) -> bool:
"""
Is the current position a short position?
:return: bool
"""
return self.qty < -abs(self._min_qty)
@property
def mode(self) -> str:
if self.exchange.type == 'spot':
return 'spot'
else:
return self.exchange.futures_leverage_mode
@property
def liquidation_price(self) -> Union[float, np.float64]:
"""
The price at which the position gets liquidated. formulas are taken from:
https://help.bybit.com/hc/en-us/articles/900000181046-Liquidation-Price-USDT-Contract-
"""
if self.is_close:
return np.nan
if jh.is_livetrading():
return self._liquidation_price
if self.mode in ['cross', 'spot']:
return np.nan
elif self.mode == 'isolated':
if self.type == 'long':
return self.entry_price * (1 - self._initial_margin_rate + 0.004)
elif self.type == 'short':
return self.entry_price * (1 + self._initial_margin_rate - 0.004)
else:
return np.nan
else:
raise ValueError
@property
def _initial_margin_rate(self) -> float:
return 1 / self.leverage
@property
def bankruptcy_price(self) -> Union[float, np.float64]:
if self.type == 'long':
return self.entry_price * (1 - self._initial_margin_rate)
elif self.type == 'short':
return self.entry_price * (1 + self._initial_margin_rate)
else:
return np.nan
@property
def to_dict(self):
return {
'entry_price': self.entry_price,
'qty': self.qty,
'current_price': self.current_price,
'value': self.value,
'type': self.type,
'exchange': self.exchange_name,
'pnl': self.pnl,
'pnl_percentage': self.pnl_percentage,
'leverage': self.leverage,
'liquidation_price': self.liquidation_price,
'bankruptcy_price': self.bankruptcy_price,
'mode': self.mode,
}
@property
def _min_notional_size(self) -> float:
if not (jh.is_livetrading() and self.exchange_type == 'spot'):
return 0
return self.exchange.vars['precisions'][self.symbol]['min_notional_size']
@property
def _min_qty(self) -> float:
if not (jh.is_livetrading() and self.exchange_type == 'spot'):
return 0
# first check exchange return min_qty or not
if 'min_qty' in self.exchange.vars['precisions'][self.symbol]:
return self.exchange.vars['precisions'][self.symbol]['min_qty']
if self._min_notional_size and self.current_price:
return self._min_notional_size / self.current_price
else:
return 0
@property
def _can_mutate_qty(self):
return not (self.exchange_type == 'spot' and jh.is_livetrading())
================================================
FILE: jesse/models/Route.py
================================================
class Route:
def __init__(
self,
exchange: str,
symbol: str,
timeframe: str = None,
strategy_name: str = None,
dna: str = None
) -> None:
self.exchange = exchange
self.symbol = symbol
self.timeframe = timeframe
self.strategy_name = strategy_name
self.strategy = None
self.dna = dna
================================================
FILE: jesse/models/SpotExchange.py
================================================
import jesse.helpers as jh
from jesse.enums import sides
from jesse.exceptions import InsufficientBalance
from jesse.models.Order import Order
from jesse.models.Exchange import Exchange
from jesse.enums import order_types
from jesse.utils import sum_floats, subtract_floats
class SpotExchange(Exchange):
def __init__(self, name: str, starting_balance: float, fee_rate: float):
super().__init__(name, starting_balance, fee_rate, 'spot')
self.stop_orders_sum = {}
self.limit_orders_sum = {}
# # # # live-trading only # # # #
self._started_balance = 0
# # # # # # # # # # # # # # # # #
@property
def started_balance(self) -> float:
if jh.is_livetrading():
return self._started_balance
return self.starting_assets[jh.app_currency()]
@property
def wallet_balance(self) -> float:
return self.assets[self.settlement_currency]
@property
def available_margin(self) -> float:
return self.wallet_balance
def on_order_submission(self, order: Order) -> None:
if jh.is_livetrading():
return
if order.side == sides.SELL:
if order.type == order_types.STOP:
self.stop_orders_sum[order.symbol] = sum_floats(self.stop_orders_sum.get(order.symbol, 0), abs(order.qty))
elif order.type == order_types.LIMIT:
self.limit_orders_sum[order.symbol] = sum_floats(self.limit_orders_sum.get(order.symbol, 0), abs(order.qty))
base_asset = jh.base_asset(order.symbol)
# buy order
if order.side == sides.BUY:
# cannot buy if we don't have enough balance (of the settlement currency)
quote_balance = self.assets[self.settlement_currency]
self.assets[self.settlement_currency] = subtract_floats(self.assets[self.settlement_currency], (abs(order.qty) * order.price))
if self.assets[self.settlement_currency] < 0:
raise InsufficientBalance(
f"Not enough balance. Available balance at {self.name} for {self.settlement_currency} is {quote_balance} but you're trying to spend {abs(order.qty * order.price)}"
)
# sell order
else:
base_balance = self.assets[base_asset]
# sell order's qty cannot be bigger than the amount of existing base asset
if order.type == order_types.MARKET:
order_qty = sum_floats(abs(order.qty), self.limit_orders_sum.get(order.symbol, 0))
elif order.type == order_types.STOP:
order_qty = self.stop_orders_sum[order.symbol]
elif order.type == order_types.LIMIT:
order_qty = self.limit_orders_sum[order.symbol]
else:
raise Exception(f"Unknown order type {order.type}")
# validate that the total selling amount is not bigger than the amount of the existing base asset
if order_qty > base_balance:
raise InsufficientBalance(
f"Not enough balance. Available balance at {self.name} for {base_asset} is {base_balance} but you're trying to sell {order_qty}"
)
def on_order_execution(self, order: Order) -> None:
if jh.is_livetrading():
return
if order.side == sides.SELL:
if order.type == order_types.STOP:
self.stop_orders_sum[order.symbol] = subtract_floats(self.stop_orders_sum[order.symbol], abs(order.qty))
elif order.type == order_types.LIMIT:
self.limit_orders_sum[order.symbol] = subtract_floats(self.limit_orders_sum[order.symbol], abs(order.qty))
base_asset = jh.base_asset(order.symbol)
# buy order
if order.side == sides.BUY:
# asset's balance is increased by the amount of the order's qty after fees are deducted
self.assets[base_asset] = sum_floats(self.assets[base_asset], abs(order.qty) * (1 - self.fee_rate))
# sell order
else:
current_balance = self.assets[base_asset]
if abs(order.qty) > current_balance:
adjusted_qty = current_balance
order_qty = abs(adjusted_qty)
else:
order_qty = abs(order.qty)
# settlement currency's balance is increased by the amount of the order's qty after fees are deducted
self.assets[self.settlement_currency] = sum_floats(
self.assets[self.settlement_currency], (order_qty * order.price) * (1 - self.fee_rate)
)
# now reduce base asset's balance by the amount of the order's qty
self.assets[base_asset] = subtract_floats(self.assets[base_asset], order_qty)
def on_order_cancellation(self, order: Order) -> None:
if jh.is_livetrading():
return
if order.side == sides.SELL:
if order.type == order_types.STOP:
self.stop_orders_sum[order.symbol] = subtract_floats(self.stop_orders_sum[order.symbol], abs(order.qty))
elif order.type == order_types.LIMIT:
self.limit_orders_sum[order.symbol] = subtract_floats(self.limit_orders_sum[order.symbol], abs(order.qty))
base_asset = jh.base_asset(order.symbol)
# buy order
if order.side == sides.BUY:
self.assets[self.settlement_currency] = sum_floats(self.assets[self.settlement_currency], abs(order.qty) * order.price)
# sell order
else:
if order.type == order_types.STOP:
self.stop_orders_sum[order.symbol] = subtract_floats(self.stop_orders_sum[order.symbol], abs(order.qty))
elif order.type == order_types.LIMIT:
self.limit_orders_sum[order.symbol] = subtract_floats(self.limit_orders_sum[order.symbol], abs(order.qty))
def update_from_stream(self, data: dict) -> None:
"""
Used for updating the exchange from the WS stream (only for live trading)
"""
import jesse.services.logger as logger
if not jh.is_livetrading():
raise Exception('This method is only for live trading')
old_balance = self.assets[self.settlement_currency]
self.assets[self.settlement_currency] = data['balance']
if old_balance != 0 and self.assets[self.settlement_currency] != old_balance:
logger.info(
f'Balance for {self.settlement_currency} on {self.name} changed from {round(old_balance, 2)} to {round(self.assets[self.settlement_currency], 2)}'
)
if self._started_balance == 0:
self._started_balance = data['balance']
================================================
FILE: jesse/models/Ticker.py
================================================
import peewee
import jesse.helpers as jh
import numpy as np
class Ticker(peewee.Model):
id = peewee.UUIDField(primary_key=True)
# timestamp in milliseconds
timestamp = peewee.BigIntegerField()
# the latest trades price
last_price = peewee.FloatField()
# the trading volume in the last 24 hours
volume = peewee.FloatField()
# the highest price in the last 24 hours
high_price = peewee.FloatField()
# the lowest price in the last 24 hours
low_price = peewee.FloatField()
symbol = peewee.CharField()
exchange = peewee.CharField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = ((('exchange', 'symbol', 'timestamp'), True),)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # DB FUNCTIONS # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
def store_ticker_into_db(exchange: str, symbol: str, ticker: np.ndarray) -> None:
return
d = {
'id': jh.generate_unique_id(),
'timestamp': ticker[0],
'last_price': ticker[1],
'high_price': ticker[2],
'low_price': ticker[3],
'volume': ticker[4],
'symbol': symbol,
'exchange': exchange,
}
def async_save() -> None:
Ticker.insert(**d).on_conflict_ignore().execute()
print(
jh.color(f'ticker: {jh.timestamp_to_time(d["timestamp"])}-{exchange}-{symbol}: {ticker}', 'yellow')
)
# async call
threading.Thread(target=async_save).start()
================================================
FILE: jesse/models/Trade.py
================================================
import peewee
import jesse.helpers as jh
import numpy as np
import threading
class Trade(peewee.Model):
id = peewee.UUIDField(primary_key=True)
# timestamp in milliseconds
timestamp = peewee.BigIntegerField()
price = peewee.FloatField()
buy_qty = peewee.FloatField()
sell_qty = peewee.FloatField()
buy_count = peewee.IntegerField()
sell_count = peewee.IntegerField()
symbol = peewee.CharField()
exchange = peewee.CharField()
class Meta:
from jesse.services.db import database
database = database.db
indexes = ((('exchange', 'symbol', 'timestamp'), True),)
def __init__(self, attributes: dict = None, **kwargs) -> None:
peewee.Model.__init__(self, attributes=attributes, **kwargs)
if attributes is None:
attributes = {}
for a, value in attributes.items():
setattr(self, a, value)
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # DB FUNCTIONS # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
def store_trade_into_db(exchange: str, symbol: str, trade: np.ndarray) -> None:
return
d = {
'id': jh.generate_unique_id(),
'timestamp': trade[0],
'price': trade[1],
'buy_qty': trade[2],
'sell_qty': trade[3],
'buy_count': trade[4],
'sell_count': trade[5],
'symbol': symbol,
'exchange': exchange,
}
def async_save() -> None:
Trade.insert(**d).on_conflict_ignore().execute()
print(
jh.color(
f'trade: {jh.timestamp_to_time(d["timestamp"])}-{exchange}-{symbol}: {trade}',
'green'
)
)
# async call
threading.Thread(target=async_save).start()
================================================
FILE: jesse/models/__init__.py
================================================
from .Candle import Candle
from .ClosedTrade import ClosedTrade
from .Exchange import Exchange
from .FuturesExchange import FuturesExchange
from .Order import Order
from .Position import Position
from .Route import Route
from .SpotExchange import SpotExchange
from .Ticker import Ticker
from .Log import Log
from .NotificationApiKeys import NotificationApiKeys
from .ExchangeApiKeys import ExchangeApiKeys
from .BacktestSession import BacktestSession
from .OpenTab import OpenTab
from .LiveEquitySnapshot import LiveEquitySnapshot
================================================
FILE: jesse/modes/__init__.py
================================================
================================================
FILE: jesse/modes/backtest_mode.py
================================================
import time
import re
from typing import Dict, List, Tuple, Optional
import numpy as np
import jesse.helpers as jh
import jesse.services.metrics as stats
from jesse import exceptions
from jesse.config import config
from jesse.enums import timeframes, order_types
from jesse.models import Order, Position
from jesse.modes.utils import save_daily_portfolio_balance
from jesse.candle_pipelines import BaseCandlesPipeline
from jesse.routes import router
from jesse.services import charts
from jesse.services import report
from jesse.services import candle_service
from jesse.services.file import store_logs
from jesse.services.validators import validate_routes
from jesse.store import store
from jesse.services import logger
from jesse.services.failure import register_custom_exception_handler
from jesse.services.redis import sync_publish, is_process_active
from jesse.services import order_service
from timeloop import Timeloop
from datetime import timedelta
from jesse.services.progressbar import Progressbar
from jesse.constants import TIMEFRAME_TO_ONE_MINUTES
from jesse.services import candle_service, order_service, position_service, exchange_service
def run(
client_id: str,
debug_mode: bool,
user_config: dict,
exchange: str,
routes: List[Dict[str, str]],
data_routes: List[Dict[str, str]],
start_date: str,
finish_date: str,
candles: dict = None,
chart: bool = False,
tradingview: bool = False,
csv: bool = False,
json: bool = False,
fast_mode: bool = False,
benchmark: bool = False
) -> None:
if not jh.is_unit_testing():
# at every second, we check to see if it's time to execute stuff
status_checker = Timeloop()
@status_checker.job(interval=timedelta(seconds=1))
def handle_time():
if is_process_active(client_id) is False:
raise exceptions.Termination
status_checker.start()
from jesse.config import config
config['app']['trading_mode'] = 'backtest'
# debug flag
config['app']['debug_mode'] = debug_mode
register_custom_exception_handler()
_execute_backtest(
client_id, debug_mode, user_config, exchange, routes, data_routes, start_date, finish_date, candles, chart,
tradingview, csv, json, fast_mode, benchmark
)
def _execute_backtest(
client_id: str,
debug_mode: bool,
user_config: dict,
exchange: str,
routes: List[Dict[str, str]],
data_routes: List[Dict[str, str]],
start_date: str,
finish_date: str,
candles: dict = None,
chart: bool = False,
tradingview: bool = False,
csv: bool = False,
json: bool = False,
fast_mode: bool = False,
benchmark: bool = False
):
"""
Executes the backtest that has been initiated from within the dashboard. The purpose of extracting these
functionalities into this function is so that in case it fails due to a missing data route, it can add
it and then re-execute itself.
"""
from jesse.config import set_config
# inject config
if not jh.is_unit_testing():
set_config(user_config)
# add exchange to routes
for r in routes:
r['exchange'] = exchange
for r in data_routes:
r['exchange'] = exchange
# set routes
router.initiate(routes, data_routes)
# reset store
store.reset()
# set session id
store.app.set_session_id(client_id)
# validate routes
validate_routes(router)
# initiate candle store
store.candles.init_storage(5000)
# initialize exchanges state
exchange_service.initialize_exchanges_state()
# initialize orders state
order_service.initialize_orders_state()
# initialize positions state
position_service.initialize_positions_state()
# Store backtest session in database (only for UI dashboard, not for CLI/research)
if not jh.should_execute_silently():
from jesse.models.BacktestSession import store_backtest_session
store_backtest_session(
id=client_id,
status='running'
)
# load historical candles
if candles is None:
try:
warmup_candles, candles = load_candles(
jh.date_to_timestamp(start_date),
jh.date_to_timestamp(finish_date)
)
_handle_warmup_candles(warmup_candles, start_date)
except exceptions.CandlesNotFound as e:
_handle_sync_no_candles(e, start_date, exchange)
except exceptions.CandleNotFoundInDatabase as e:
_handle_sync_no_candles(e, start_date, exchange)
if not jh.should_execute_silently():
sync_publish('general_info', {
'session_id': jh.get_session_id(),
'debug_mode': str(config['app']['debug_mode']),
})
# candles info
key = f"{config['app']['considering_candles'][0][0]}-{config['app']['considering_candles'][0][1]}"
sync_publish('candles_info', stats.candles_info(candles[key]['candles']))
# routes info
sync_publish('routes_info', stats.routes(router.routes))
# run backtest simulation
result = None
try:
result = simulator(
candles,
run_silently=jh.should_execute_silently(),
generate_tradingview=tradingview,
generate_csv=csv,
generate_json=json,
generate_equity_curve=True,
benchmark=benchmark,
generate_hyperparameters=True,
fast_mode=fast_mode,
)
except exceptions.RouteNotFound as e:
# Extract exchange, symbol, and timeframe using regular expressions
match = re.search(r"symbol='(.+?)', timeframe='(.+?)'", str(e))
if match:
symbol = match.group(1)
timeframe = match.group(2)
# Adjust data_routes to include the missing route
data_routes.append({
'exchange': exchange,
'symbol': symbol,
'timeframe': timeframe
})
# to prevent an issue with warmupcandles being None
candles = None
# notify the user about the missing data route and retry the backtest simulation
sync_publish('notification', {
'message': f'Missing data route for "{symbol}" with "{timeframe}" timeframe. Adding it and retrying...',
'type': 'error'
})
# retry the backtest simulation
_execute_backtest(
client_id, debug_mode, user_config, exchange, routes, data_routes, start_date, finish_date, candles,
chart, tradingview, csv, json, fast_mode, benchmark
)
return
else:
raise e
except Exception as e:
# Store exception in database (only for UI dashboard)
if not jh.should_execute_silently():
import traceback
from jesse.models.BacktestSession import store_backtest_session_exception, update_backtest_session_status
store_backtest_session_exception(client_id, str(e), traceback.format_exc())
update_backtest_session_status(client_id, 'stopped')
raise
if result and not jh.should_execute_silently():
sync_publish('alert', {
'message': f"Successfully executed backtest simulation in: {result['execution_duration']} seconds",
'type': 'success'
})
sync_publish('hyperparameters', result['hyperparameters'])
sync_publish('metrics', result['metrics'])
sync_publish('equity_curve', result['equity_curve'], compression=True)
sync_publish('trades', result['trades'], compression=True)
# Prepare chart data if requested (call formatting functions once and cache)
chart_data = None
if chart:
# Store the data for database
chart_data = {
'candles_chart': _get_formatted_candles_for_frontend(),
'orders_chart': _get_formatted_orders_for_frontend(),
'add_line_to_candle_chart': _get_add_line_to_candle_chart(),
'add_extra_line_chart': _get_add_extra_line_chart(),
'add_horizontal_line_to_candle_chart': _get_add_horizontal_line_to_candle_chart(),
'add_horizontal_line_to_extra_chart': _get_add_horizontal_line_to_extra_chart()
}
# Capture strategy codes for each route
strategy_codes = {}
import os
for r in router.routes:
key = f"{r.exchange}-{r.symbol}"
if key not in strategy_codes:
try:
strategy_path = f'strategies/{r.strategy_name}/__init__.py'
if os.path.exists(strategy_path):
with open(strategy_path, 'r') as f:
content = f.read()
strategy_codes[key] = content
except Exception:
pass
# Update backtest session in database with results
from jesse.models.BacktestSession import update_backtest_session_results, update_backtest_session_status
update_backtest_session_results(
id=client_id,
metrics=result.get('metrics'),
equity_curve=result.get('equity_curve'),
trades=result.get('trades'),
hyperparameters=result.get('hyperparameters'),
chart_data=chart_data,
execution_duration=result.get('execution_duration'),
strategy_codes=strategy_codes if strategy_codes else None
)
update_backtest_session_status(client_id, 'finished')
# close database connection
from jesse.services.db import database
database.close_connection()
def _handle_sync_no_candles(e, start_date, exchange):
# Extract symbol and exchange from error message
match = re.search(r"for (.*?) on (.*?)$", str(e))
if match:
symbol = match.group(1)
message = f'Missing trading candles for {symbol} on {exchange} from {start_date}'
warmup_num = jh.get_config('env.data.warmup_candles_num', 210)
if warmup_num > 0:
start_date = jh.date_to_timestamp(start_date) - (
warmup_num * jh.timeframe_to_one_minutes(jh.max_timeframe(config['app']['considering_timeframes'])) * 2 * 60_000)
start_date = jh.timestamp_to_date(start_date)
sync_publish(
"missing_candles",
{
"message": message,
"symbol": symbol,
"exchange": exchange,
"start_date": start_date,
},
)
raise exceptions.CandlesNotFound({
'message': str(e),
'symbol': symbol,
'exchange': exchange,
'start_date': start_date,
'type': 'missing_candles'
})
raise e
def _get_formatted_candles_for_frontend():
arr = []
for r in router.routes:
candles_arr = candle_service.get_candles(r.exchange, r.symbol, r.timeframe)
# Find the index where the starting time actually begins.
starting_index = 0
for i, c in enumerate(candles_arr):
if c[0] >= store.app.starting_time:
starting_index = i
break
candles = [{
'time': int(c[0]/1000),
'open': c[1],
'close': c[2],
'high': c[3],
'low': c[4],
'volume': c[5]
} for c in candles_arr[starting_index:]]
arr.append({
'exchange': r.exchange,
'symbol': r.symbol,
'timeframe': r.timeframe,
'candles': candles
})
return arr
def _get_formatted_orders_for_frontend():
arr = []
for r in router.routes:
arr.append({
'exchange': r.exchange,
'symbol': r.symbol,
'timeframe': r.timeframe,
'orders': r.strategy._executed_orders
})
return arr
def _get_add_line_to_candle_chart():
arr = []
for r in router.routes:
arr.append({
'exchange': r.exchange,
'symbol': r.symbol,
'timeframe': r.timeframe,
'lines': r.strategy._add_line_to_candle_chart_values
})
return arr
def _get_add_extra_line_chart():
arr = []
for r in router.routes:
arr.append({
'exchange': r.exchange,
'symbol': r.symbol,
'timeframe': r.timeframe,
'charts': r.strategy._add_extra_line_chart_values
})
return arr
def _get_add_horizontal_line_to_candle_chart():
arr = []
for r in router.routes:
arr.append({
'exchange': r.exchange,
'symbol': r.symbol,
'timeframe': r.timeframe,
'lines': r.strategy._add_horizontal_line_to_candle_chart_values
})
return arr
def _get_add_horizontal_line_to_extra_chart():
arr = []
for r in router.routes:
arr.append({
'exchange': r.exchange,
'symbol': r.symbol,
'timeframe': r.timeframe,
'lines': r.strategy._add_horizontal_line_to_extra_chart_values
})
return arr
def _handle_missing_candles(exchange: str, symbol: str, start_date: int, message: str = None):
"""Helper function to handle missing candles scenarios"""
formatted_date = jh.timestamp_to_date(start_date)
if message is None:
message = f'Missing trading candles for {symbol} on {exchange} from {formatted_date}'
sync_publish(
"missing_candles",
{
"message": message,
"symbol": symbol,
"exchange": exchange,
"start_date": formatted_date,
},
)
raise exceptions.CandlesNotFound({
'message': message,
'symbol': symbol,
'exchange': exchange,
'start_date': start_date,
'type': 'missing_candles'
})
def load_candles(start_date: int, finish_date: int) -> Tuple[dict, dict]:
warmup_num = jh.get_config('env.data.warmup_candles_num', 210)
max_timeframe = jh.max_timeframe(config['app']['considering_timeframes'])
# load and add required warm-up candles for backtest, and then Prepare trading candles
trading_candles = {}
warmup_candles = {}
for c in config['app']['considering_candles']:
exchange, symbol = c[0], c[1]
warmup_candles_arr, trading_candle_arr = candle_service.get_candles_from_db(
exchange, symbol, max_timeframe, start_date, finish_date, warmup_num, caching=True, is_for_jesse=True
)
# Ensure that trading_candle_arr is not None or empty
if trading_candle_arr is None or (isinstance(trading_candle_arr, np.ndarray) and trading_candle_arr.size == 0):
_handle_missing_candles(
exchange,
symbol,
start_date,
f"Missing trading candles for {symbol} on {exchange}"
)
# Check that the first trading candle covers the requested start date.
if trading_candle_arr[0][0] > start_date:
_handle_missing_candles(exchange, symbol, start_date)
# Check that the last trading candle covers the requested finish date.
if trading_candle_arr[-1][0] < (finish_date - 60_000):
_handle_missing_candles(exchange, symbol, start_date)
# add trading candles
trading_candles[jh.key(exchange, symbol)] = {
'exchange': exchange,
'symbol': symbol,
'candles': trading_candle_arr
}
warmup_candles[jh.key(exchange, symbol)] = {
'exchange': exchange,
'symbol': symbol,
'candles': warmup_candles_arr
}
return warmup_candles, trading_candles
def _handle_warmup_candles(warmup_candles: dict, start_date: str) -> None:
try:
for c in config['app']['considering_candles']:
exchange, symbol = c[0], c[1]
candle_service.inject_warmup_candles_to_store(warmup_candles[jh.key(exchange, symbol)]['candles'], exchange, symbol)
except ValueError as e:
# Extract exchange and symbol from error message
match = re.search(r"for (.*?)/(.*?)\?", str(e))
if match:
exchange, symbol = match.groups()
# Calculate warmup start date using the same logic as load_candles()
warmup_num = jh.get_config('env.data.warmup_candles_num', 210)
max_timeframe = jh.max_timeframe(config['app']['considering_timeframes'])
# Convert max_timeframe to minutes and multiply by warmup_num
warmup_minutes = TIMEFRAME_TO_ONE_MINUTES[max_timeframe] * warmup_num
warmup_start_timestamp = jh.date_to_timestamp(start_date) - (warmup_minutes * 60_000)
warmup_start_date = jh.timestamp_to_date(warmup_start_timestamp)
# Publish the missing candles error to the frontend
# This will trigger the alert in the BacktestTab.vue component
# so that the user can import the missing candles
sync_publish(
"missing_candles",
{
"message": f'Missing warmup candles for {symbol} on {exchange} from {warmup_start_date}',
"symbol": symbol,
"exchange": exchange,
"start_date": warmup_start_date,
},
)
raise exceptions.CandlesNotFound(str(e))
raise e
def simulator(*args, fast_mode: bool = False, **kwargs) -> dict:
if fast_mode:
return _skip_simulator(*args, **kwargs)
return _step_simulator(*args, **kwargs)
def _step_simulator(
candles: dict,
run_silently: bool,
hyperparameters: dict = None,
generate_tradingview: bool = False,
generate_csv: bool = False,
generate_json: bool = False,
generate_equity_curve: bool = False,
benchmark: bool = False,
generate_hyperparameters: bool = False,
generate_logs: bool = False,
with_candles_pipeline: bool = True,
candles_pipeline_class = None,
candles_pipeline_kwargs: dict = None,
) -> dict:
# In case generating logs is specifically demanded, the debug mode must be enabled.
if generate_logs:
config['app']['debug_mode'] = True
begin_time_track = time.time()
key = f"{config['app']['considering_candles'][0][0]}-{config['app']['considering_candles'][0][1]}"
first_candles_set = candles[key]['candles']
length = _simulation_minutes_length(candles)
_prepare_times_before_simulation(candles)
candles_pipelines = _prepare_routes(
hyperparameters=hyperparameters,
with_candles_pipeline=with_candles_pipeline,
candles_pipeline_class=candles_pipeline_class,
candles_pipeline_kwargs=candles_pipeline_kwargs
)
# add initial balance
save_daily_portfolio_balance(is_initial=True)
progressbar = Progressbar(length, step=420)
last_update_time = None
for i in range(length):
# update time
store.app.time = first_candles_set[i][0] + 60_000
# add candles
for j in candles:
candles_pipeline = candles_pipelines[j]
short_candle = get_candles_from_pipeline(candles_pipeline, candles[j]['candles'], i)
if i != 0:
previous_short_candle = candles[j]['candles'][i - 1]
short_candle = _get_fixed_jumped_candle(previous_short_candle, short_candle)
exchange = candles[j]['exchange']
symbol = candles[j]['symbol']
candle_service.add_candle(short_candle, exchange, symbol, '1m', with_execution=False,
with_generation=False)
# print short candle
if jh.is_debuggable('shorter_period_candles'):
candle_service.print_candle(short_candle, True, symbol)
_simulate_price_change_effect(short_candle, exchange, symbol)
# generate and add candles for bigger timeframes
for timeframe in config['app']['considering_timeframes']:
# for 1m, no work is needed
if timeframe == '1m':
continue
count = TIMEFRAME_TO_ONE_MINUTES[timeframe]
# until = count - ((i + 1) % count)
if (i + 1) % count == 0:
generated_candle = candle_service.generate_candle_from_one_minutes(
timeframe,
candles[j]['candles'][(i - (count - 1)):(i + 1)]
)
candle_service.add_candle(
generated_candle,
exchange,
symbol,
timeframe,
with_execution=False,
with_generation=False
)
last_update_time = _update_progress_bar(progressbar, run_silently, i, candle_step=420,
last_update_time=last_update_time)
# now that all new generated candles are ready, execute
for r in router.routes:
count = TIMEFRAME_TO_ONE_MINUTES[r.timeframe]
# 1m timeframe
if r.timeframe == timeframes.MINUTE_1:
r.strategy._execute()
elif (i + 1) % count == 0:
# print candle
if jh.is_debuggable('trading_candles'):
candle_service.print_candle(candle_service.get_current_candle(r.exchange, r.symbol, r.timeframe), False,
r.symbol)
r.strategy._execute()
order_service.update_active_orders(r.exchange, r.symbol)
# now check to see if there's any MARKET orders waiting to be executed
order_service.execute_simulated_market_orders()
if i != 0 and i % 1440 == 0:
save_daily_portfolio_balance()
_finish_progress_bar(progressbar, run_silently)
execution_duration = 0
if not run_silently:
# print executed time for the backtest session
finish_time_track = time.time()
execution_duration = round(finish_time_track - begin_time_track, 2)
for r in router.routes:
r.strategy._terminate()
order_service.execute_simulated_market_orders()
# now that backtest simulation is finished, add finishing balance
save_daily_portfolio_balance()
# set the ending time for the backtest session
store.app.ending_time = store.app.time + 60_000
result = _generate_outputs(
candles,
generate_tradingview=generate_tradingview,
generate_csv=generate_csv,
generate_json=generate_json,
generate_equity_curve=generate_equity_curve,
benchmark=benchmark,
generate_hyperparameters=generate_hyperparameters,
generate_logs=generate_logs,
)
result['execution_duration'] = execution_duration
return result
def _simulation_minutes_length(candles: dict) -> int:
key = f"{config['app']['considering_candles'][0][0]}-{config['app']['considering_candles'][0][1]}"
first_candles_set = candles[key]["candles"]
return len(first_candles_set)
def _prepare_times_before_simulation(candles: dict) -> None:
# result = {}
# begin_time_track = time.time()
key = f"{config['app']['considering_candles'][0][0]}-{config['app']['considering_candles'][0][1]}"
first_candles_set = candles[key]["candles"]
# length = len(first_candles_set)
# to preset the array size for performance
try:
store.app.starting_time = first_candles_set[0][0]
except IndexError:
raise IndexError('Check your "warm_up_candles" config value')
store.app.time = first_candles_set[0][0]
def _prepare_routes(
hyperparameters: dict = None,
with_candles_pipeline: bool = True,
candles_pipeline_class = None,
candles_pipeline_kwargs: dict = None,
) -> Dict[str, BaseCandlesPipeline | None]:
# initiate strategies
candles_pipeline = {}
for r in router.routes:
# if the r.strategy is str read it from file
if isinstance(r.strategy_name, str):
StrategyClass = jh.get_strategy_class(r.strategy_name)
# else it is a class object so just use it
else:
StrategyClass = r.strategy_name
try:
r.strategy = StrategyClass()
except TypeError:
raise exceptions.InvalidStrategy(
"Strategy validation failed. Make sure your strategy has the mandatory methods such as should_long(), "
"go_long(), etc. For working examples, visit: https://jesse.trade/strategies"
)
except:
raise
r.strategy.name = r.strategy_name
r.strategy.exchange = r.exchange
r.strategy.symbol = r.symbol
r.strategy.timeframe = r.timeframe
# read the dna from strategy's dna() and use it for injecting inject hyperparameters
# first convert DNS string into hyperparameters
if len(r.strategy.dna()) > 0 and hyperparameters is None:
hyperparameters = jh.dna_to_hp(
r.strategy.hyperparameters(), r.strategy.dna()
)
# inject hyperparameters sent within the optimize mode
if hyperparameters is not None:
r.strategy.hp = hyperparameters
# init few objects that couldn't be initiated in Strategy __init__
# it also injects hyperparameters into self.hp in case the route does not uses any DNAs
r.strategy._init_objects()
# monte-carlo simulation
if with_candles_pipeline:
if candles_pipeline_class is not None:
# Use the provided pipeline class with kwargs if available
kwargs = candles_pipeline_kwargs or {}
candles_pipeline[jh.key(r.exchange, r.symbol)] = candles_pipeline_class(**kwargs)
else:
# Otherwise, fall back to the strategy's pipeline
candles_pipeline[jh.key(r.exchange, r.symbol)] = r.strategy.candles_pipeline()
else: # normal backtest
candles_pipeline[jh.key(r.exchange, r.symbol)] = None
store.positions.get_position(r.exchange, r.symbol).strategy = r.strategy
# Ensure pipelines exist for data routes as well (no strategy attached)
# Keys in `candles` include both trading and data routes; provide a pipeline (or None) for each
for dr in getattr(router, 'data_routes', []) or []:
key = jh.key(dr.exchange, dr.symbol)
if key in candles_pipeline:
continue
if with_candles_pipeline and candles_pipeline_class is not None:
kwargs = candles_pipeline_kwargs or {}
candles_pipeline[key] = candles_pipeline_class(**kwargs)
else:
candles_pipeline[key] = None
return candles_pipeline
def get_candles_from_pipeline(candles_pipeline: Optional[BaseCandlesPipeline], candles: np.ndarray, i: int, candles_step: int = -1) -> np.ndarray:
if candles_pipeline is None:
if candles_step == -1:
return candles[i]
else:
return candles[i: i+candles_step]
return candles_pipeline.get_candles(candles[i: i + candles_pipeline._batch_size], i, candles_step)
def _update_progress_bar(
progressbar: Progressbar, run_silently: bool, candle_index: int, candle_step: int, last_update_time: float
) -> float:
throttle_interval = 0.5
current_time = time.time()
if not run_silently and candle_index % candle_step == 0:
progressbar.update()
if last_update_time is None or (current_time - last_update_time) >= throttle_interval:
sync_publish(
"progressbar",
{
"current": progressbar.current,
"estimated_remaining_seconds": progressbar.estimated_remaining_seconds,
},
)
# Update the last update time
last_update_time = current_time
# Return the last update time for future reference
return last_update_time
def _finish_progress_bar(progressbar: Progressbar, run_silently: bool):
if run_silently:
return
progressbar.finish()
sync_publish(
"progressbar",
{
"current": 100,
"estimated_remaining_seconds": 0,
},
)
def _get_fixed_jumped_candle(
previous_candle: np.ndarray, candle: np.ndarray
) -> np.ndarray:
"""
A little workaround for the times that the price has jumped and the opening
price of the current candle is not equal to the previous candle's close!
:param previous_candle: np.ndarray
:param candle: np.ndarray
"""
if previous_candle[2] < candle[1]:
candle[1] = previous_candle[2]
candle[4] = min(previous_candle[2], candle[4])
elif previous_candle[2] > candle[1]:
candle[1] = previous_candle[2]
candle[3] = max(previous_candle[2], candle[3])
return candle
def _simulate_price_change_effect(real_candle: np.ndarray, exchange: str, symbol: str) -> None:
current_temp_candle = real_candle.copy()
executed_order = False
executing_orders = _get_executing_orders(exchange, symbol, real_candle)
if len(executing_orders) > 1:
# extend the candle shape from (6,) to (1,6)
executing_orders = _sort_execution_orders(executing_orders, current_temp_candle[None, :])
while True:
if len(executing_orders) == 0:
executed_order = False
else:
for index, order in enumerate(executing_orders):
if index == len(executing_orders) - 1 and not order.is_active:
executed_order = False
if not order.is_active:
continue
if candle_service.candle_includes_price(current_temp_candle, order.price):
storable_temp_candle, current_temp_candle = candle_service.split_candle(current_temp_candle, order.price)
_update_all_routes_a_partial_candle(exchange, symbol, storable_temp_candle)
p = store.positions.get_position(exchange, symbol)
p.current_price = storable_temp_candle[2]
executed_order = True
order_service.execute_order(order)
executing_orders = _get_executing_orders(exchange, symbol, current_temp_candle)
if len(executing_orders) > 1:
# extend the candle shape from (6,) to (1,6)
executing_orders = _sort_execution_orders(executing_orders, current_temp_candle[None, :])
# break from the for loop, we'll try again inside the while
# loop with the new current_temp_candle
break
else:
executed_order = False
if not executed_order:
# add/update the real_candle to the store so we can move on
candle_service.add_candle(
real_candle, exchange, symbol, '1m',
with_execution=False,
with_generation=False
)
p = store.positions.get_position(exchange, symbol)
if p:
p.current_price = real_candle[2]
break
_check_for_liquidations(real_candle, exchange, symbol)
def _check_for_liquidations(candle: np.ndarray, exchange: str, symbol: str) -> None:
p: Position = store.positions.get_position(exchange, symbol)
if not p:
return
# for now, we only support the isolated mode:
if p.mode != 'isolated':
return
if candle_service.candle_includes_price(candle, p.liquidation_price):
closing_order_side = jh.closing_side(p.type)
# create the market order that is used as the liquidation order
order = Order({
'id': jh.generate_unique_id(),
'symbol': symbol,
'exchange': exchange,
'side': closing_order_side,
'type': order_types.MARKET,
'reduce_only': True,
'qty': jh.prepare_qty(p.qty, closing_order_side),
'price': p.bankruptcy_price
})
store.orders.add_order(order)
store.app.total_liquidations += 1
logger.info(f'{p.symbol} liquidated at {p.liquidation_price}')
order_service.execute_order(order)
def _generate_outputs(
candles: dict,
generate_tradingview: bool = False,
generate_csv: bool = False,
generate_json: bool = False,
generate_equity_curve: bool = False,
benchmark: bool = False,
generate_hyperparameters: bool = False,
generate_logs: bool = False,
):
result = {}
if generate_hyperparameters:
result["hyperparameters"] = stats.hyperparameters(router.routes)
result["metrics"] = report.portfolio_metrics()
result["trades"] = report.trades()
# generate logs in json, csv and tradingview's pine-editor format
logs_path = store_logs(generate_json, generate_tradingview, generate_csv)
if generate_json:
result["json"] = logs_path["json"]
if generate_tradingview:
result["tradingview"] = logs_path["tradingview"]
if generate_csv:
result["csv"] = logs_path["csv"]
if generate_equity_curve:
result["equity_curve"] = charts.equity_curve(benchmark)
if generate_logs:
result["logs"] = f"storage/logs/backtest-mode/{jh.get_session_id()}.txt"
return result
def _skip_simulator(
candles: dict,
run_silently: bool,
hyperparameters: dict = None,
generate_tradingview: bool = False,
generate_csv: bool = False,
generate_json: bool = False,
generate_equity_curve: bool = False,
benchmark: bool = False,
generate_hyperparameters: bool = False,
generate_logs: bool = False,
with_candles_pipeline: bool = True,
candles_pipeline_class = None,
candles_pipeline_kwargs: dict = None,
) -> dict:
# In case generating logs is specifically demanded, the debug mode must be enabled.
if generate_logs:
config["app"]["debug_mode"] = True
begin_time_track = time.time()
length = _simulation_minutes_length(candles)
_prepare_times_before_simulation(candles)
candles_pipelines = _prepare_routes(hyperparameters, with_candles_pipeline, candles_pipeline_class, candles_pipeline_kwargs)
# add initial balance
save_daily_portfolio_balance(is_initial=True)
candles_step = _calculate_minimum_candle_step()
progressbar = Progressbar(length, step=candles_step)
last_update_time = None
for i in range(0, length, candles_step):
# update time moved to _simulate_price_change_effect__multiple_candles
# store.app.time = first_candles_set[i][0] + (60_000 * candles_step)
_simulate_new_candles(candles, candles_pipelines, i, candles_step)
last_update_time = _update_progress_bar(progressbar, run_silently, i, candles_step,
last_update_time=last_update_time)
_execute_routes(i, candles_step)
# now check to see if there's any MARKET orders waiting to be executed
order_service.execute_simulated_market_orders()
if i != 0 and i % 1440 == 0:
save_daily_portfolio_balance()
_finish_progress_bar(progressbar, run_silently)
execution_duration = 0
if not run_silently:
# print executed time for the backtest session
finish_time_track = time.time()
execution_duration = round(finish_time_track - begin_time_track, 2)
for r in router.routes:
r.strategy._terminate()
order_service.execute_simulated_market_orders()
# now that backtest simulation is finished, add finishing balance
save_daily_portfolio_balance()
# set the ending time for the backtest session
store.app.ending_time = store.app.time + 60_000
result = _generate_outputs(
candles,
generate_tradingview=generate_tradingview,
generate_csv=generate_csv,
generate_json=generate_json,
generate_equity_curve=generate_equity_curve,
benchmark=benchmark,
generate_hyperparameters=generate_hyperparameters,
generate_logs=generate_logs,
)
result['execution_duration'] = execution_duration
return result
def _calculate_minimum_candle_step():
"""
Calculates the minimum step for update candles that will allow simple updates on the simulator.
"""
# config["app"]["considering_timeframes"] use '1m' also even if not required by the user so take only what the user
# is requested.
consider_time_frames = [
TIMEFRAME_TO_ONE_MINUTES[route["timeframe"]]
for route in router.all_formatted_routes
]
return np.gcd.reduce(consider_time_frames)
timeframe_to_one_minutes = {
timeframes.MINUTE_1: 1,
timeframes.MINUTE_3: 3,
timeframes.MINUTE_5: 5,
timeframes.MINUTE_15: 15,
timeframes.MINUTE_30: 30,
timeframes.MINUTE_45: 45,
timeframes.HOUR_1: 60,
timeframes.HOUR_2: 60 * 2,
timeframes.HOUR_3: 60 * 3,
timeframes.HOUR_4: 60 * 4,
timeframes.HOUR_6: 60 * 6,
timeframes.HOUR_8: 60 * 8,
timeframes.HOUR_12: 60 * 12,
timeframes.DAY_1: 60 * 24,
timeframes.DAY_3: 60 * 24 * 3,
timeframes.WEEK_1: 60 * 24 * 7,
timeframes.MONTH_1: 60 * 24 * 30,
}
def _simulate_new_candles(candles: dict, candles_pipelines: Dict[str, BaseCandlesPipeline], candle_index: int, candles_step: int) -> None:
i = candle_index
# add candles
for j in candles:
candles_pipeline = candles_pipelines[j]
short_candles = get_candles_from_pipeline(candles_pipeline, candles[j]['candles'], i, candles_step)
candles[j]['candles'][i:i+candles_step] = short_candles
if i != 0:
previous_short_candles = candles[j]["candles"][i - 1]
# work the same, the fix needs to be done only on the gap of 1m edge candles.
short_candles[0] = _get_fixed_jumped_candle(
previous_short_candles, short_candles[0]
)
exchange = candles[j]["exchange"]
symbol = candles[j]["symbol"]
_simulate_price_change_effect_multiple_candles(
short_candles, exchange, symbol
)
# generate and add candles for bigger timeframes
for timeframe in config["app"]["considering_timeframes"]:
# for 1m, no work is needed
if timeframe == "1m":
continue
count = TIMEFRAME_TO_ONE_MINUTES[timeframe]
if (i + candles_step) % count == 0:
generated_candle = candle_service.generate_candle_from_one_minutes(
timeframe,
candles[j]["candles"][
i - count + candles_step: i + candles_step],
)
candle_service.add_candle(
generated_candle,
exchange,
symbol,
timeframe,
with_execution=False,
with_generation=False,
)
def _simulate_price_change_effect_multiple_candles(
short_timeframes_candles: np.ndarray, exchange: str, symbol: str
) -> None:
real_candle = np.array(
[
short_timeframes_candles[0][0],
short_timeframes_candles[0][1],
short_timeframes_candles[-1][2],
short_timeframes_candles[:, 3].max(),
short_timeframes_candles[:, 4].min(),
short_timeframes_candles[:, 5].sum(),
]
)
executing_orders = _get_executing_orders(exchange, symbol, real_candle)
if len(executing_orders) > 0:
if len(executing_orders) > 1:
executing_orders = _sort_execution_orders(executing_orders, short_timeframes_candles)
for i in range(len(short_timeframes_candles)):
current_temp_candle = short_timeframes_candles[i].copy()
if i > 0:
current_temp_candle[3] = max(current_temp_candle[3], short_timeframes_candles[i-1, 2])
current_temp_candle[4] = min(current_temp_candle[4], short_timeframes_candles[i-1, 2])
is_executed_order = False
while True:
if len(executing_orders) == 0:
is_executed_order = False
else:
for index, order in enumerate(executing_orders):
if index == len(executing_orders) - 1 and not order.is_active:
is_executed_order = False
if not order.is_active:
continue
if candle_service.candle_includes_price(current_temp_candle, order.price):
storable_temp_candle, current_temp_candle = candle_service.split_candle(
current_temp_candle, order.price
)
_update_all_routes_a_partial_candle(
exchange,
symbol,
storable_temp_candle,
)
p = store.positions.get_position(exchange, symbol)
p.current_price = storable_temp_candle[2]
is_executed_order = True
store.app.time = storable_temp_candle[0] + 60_000
order_service.execute_order(order)
executing_orders = _get_executing_orders(
exchange, symbol, real_candle
)
# break from the for loop, we'll try again inside the while
# loop with the new current_temp_candle
break
else:
is_executed_order = False
if not is_executed_order:
# add/update the real_candle to the store so we can move on
candle_service.add_candle(
short_timeframes_candles[i].copy(),
exchange,
symbol,
"1m",
with_execution=False,
with_generation=False,
)
p = store.positions.get_position(exchange, symbol)
if p:
p.current_price = current_temp_candle[2]
break
candle_service.add_multiple_1m_candles(
short_timeframes_candles,
exchange,
symbol,
)
store.app.time = real_candle[0] + (60_000 * len(short_timeframes_candles))
_check_for_liquidations(real_candle, exchange, symbol)
p = store.positions.get_position(exchange, symbol)
if p:
p.current_price = short_timeframes_candles[-1, 2]
def _update_all_routes_a_partial_candle(
exchange: str,
symbol: str,
storable_temp_candle: np.ndarray,
) -> None:
"""
This function get called when an order is getting executed you need to update the other timeframe how their last
candles looks like
"""
candle_service.add_candle(
storable_temp_candle,
exchange,
symbol,
"1m",
with_execution=False,
with_generation=False,
)
for route in router.all_formatted_routes:
timeframe = route['timeframe']
if route['exchange'] != exchange or route['symbol'] != symbol:
continue
if timeframe == '1m':
continue
tf_minutes = TIMEFRAME_TO_ONE_MINUTES[timeframe]
number_of_needed_candles = int(storable_temp_candle[0] % (tf_minutes * 60_000) // 60000) + 1
candles_1m = candle_service.get_candles(exchange, symbol, '1m')[-number_of_needed_candles:]
generated_candle = candle_service.generate_candle_from_one_minutes(
timeframe,
candles_1m,
accept_forming_candles=True
)
candle_service.add_candle(
generated_candle,
exchange,
symbol,
timeframe,
with_execution=False,
with_generation=False,
)
def _execute_routes(candle_index: int, candles_step: int) -> None:
# now that all new generated candles are ready, execute
for r in router.routes:
count = TIMEFRAME_TO_ONE_MINUTES[r.timeframe]
# 1m timeframe
if r.timeframe == timeframes.MINUTE_1:
r.strategy._execute()
elif (candle_index + candles_step) % count == 0:
# print candle
if jh.is_debuggable("trading_candles"):
candle_service.print_candle(
candle_service.get_current_candle(
r.exchange, r.symbol, r.timeframe
),
False,
r.symbol,
)
r.strategy._execute()
order_service.update_active_orders(r.exchange, r.symbol)
def _get_executing_orders(exchange, symbol, real_candle):
orders = store.orders.get_active_orders(exchange, symbol)
return [
order
for order in orders
if order.is_active and candle_service.candle_includes_price(real_candle, order.price)
]
def _sort_execution_orders(orders: List[Order], short_candles: np.ndarray):
remaining_orders = set(orders)
sorted_orders = []
for candle in short_candles:
open_price, close_price, low, high = candle[1], candle[2], candle[4], candle[3]
# Did not use candle_includes_price() for performance, keeping it vectorization-friendly
included_orders = [order for order in remaining_orders if low <= order.price <= high]
if len(included_orders) == 1:
sorted_orders.append(included_orders[0])
remaining_orders.remove(included_orders[0])
elif len(included_orders) > 1:
# in case that the orders are above
on_open, above_open, below_open = [], [], []
for order in included_orders:
if order.price == open_price:
on_open.append(order)
if order.price > open_price:
above_open.append(order)
else:
below_open.append(order)
sorted_orders += on_open
remaining_orders.difference_update(on_open)
is_red = open_price > close_price
if is_red:
# heuristic that first the price goes up and then down, so this is the order execution sort
above_open.sort(key=lambda o: o.price)
below_open.sort(key=lambda o: o.price, reverse=True)
sorted_orders += above_open + below_open
remaining_orders.difference_update(above_open + below_open)
else:
below_open.sort(key=lambda o: o.price, reverse=True)
above_open.sort(key=lambda o: o.price)
sorted_orders += below_open + above_open
remaining_orders.difference_update(below_open + above_open)
if len(sorted_orders) == len(orders):
break
return sorted_orders
================================================
FILE: jesse/modes/data_provider.py
================================================
import json
import os
import numpy as np
import peewee
from fastapi.responses import FileResponse
import jesse.helpers as jh
from jesse.info import live_trading_exchanges, backtesting_exchanges
from jesse.repositories import candle_repository
from jesse.services import candle_service
from typing import List, Dict
import csv
import io
from jesse.models.ExchangeApiKeys import ExchangeApiKeys
from jesse.services.db import database
from fastapi.responses import StreamingResponse
def get_candles(exchange: str, symbol: str, timeframe: str):
from jesse.services.db import database
database.open_connection()
if 'hyperliquid' not in exchange.lower():
symbol = symbol.upper()
# fetch the current value for warmup_candles from the database
from jesse.models.Option import Option
o = Option.get(Option.type == 'config')
db_config = json.loads(o.json)
warmup_candles_num = db_config['live']['warm_up_candles']
one_min_count = jh.timeframe_to_one_minutes(timeframe)
finish_date = jh.now(force_fresh=True)
start_date = jh.get_candle_start_timestamp_based_on_timeframe(timeframe, warmup_candles_num)
# fetch value of generate_candles_from_1m fresh from the database
o = Option.get(Option.type == 'config')
generate_candles_from_1m: bool = json.loads(o.json)['live']['generate_candles_from_1m']
# fetch 1m candles from database
if generate_candles_from_1m:
timeframe_to_fetch = '1m'
else:
timeframe_to_fetch = timeframe
candles = np.array(
candle_repository.fetch_candles_from_db(exchange, symbol, timeframe_to_fetch, start_date, finish_date)
)
# if there are no candles in the database, return []
if candles.size == 0:
database.close_connection()
return []
if generate_candles_from_1m:
# leave out first candles until the timestamp of the first candle is the beginning of the timeframe
timeframe_duration = one_min_count * 60_000
while candles[0][0] % timeframe_duration != 0:
candles = candles[1:]
# generate bigger candles from 1m candles
if timeframe != '1m':
generated_candles = []
for i in range(len(candles)):
if (i + 1) % one_min_count == 0:
bigger_candle = candle_service.generate_candle_from_one_minutes(
timeframe,
candles[(i - (one_min_count - 1)):(i + 1)],
True
)
generated_candles.append(bigger_candle)
candles = generated_candles
database.close_connection()
return [
{
'time': int(c[0] / 1000),
'open': c[1],
'close': c[2],
'high': c[3],
'low': c[4],
'volume': c[5],
} for c in candles
]
def get_config(client_config: dict, has_live=False) -> dict:
from jesse.services.db import database
database.open_connection()
from jesse.models.Option import Option
try:
o = Option.get(Option.type == 'config')
# merge it with client's config (because it could include new keys added),
# update it in the database, and then return it
data = jh.merge_dicts(client_config, json.loads(o.json))
# make sure the list of BACKTEST exchanges is up to date
for k in list(data['backtest']['exchanges'].keys()):
if k not in backtesting_exchanges:
del data['backtest']['exchanges'][k]
# make sure the list of LIVE exchanges is up to date
if has_live:
for k in list(data['live']['exchanges'].keys()):
if k not in live_trading_exchanges:
del data['live']['exchanges'][k]
o.updated_at = jh.now(True)
o.save()
except peewee.DoesNotExist:
# if not found, that means it's the first time. Store in the DB and
# then return what was sent from the client side without changing it
o = Option({
'id': jh.generate_unique_id(),
'updated_at': jh.now(True),
'type': 'config',
'json': json.dumps(client_config)
})
o.save(force_insert=True)
data = client_config
database.close_connection()
return {
'data': data
}
def update_config(client_config: dict):
from jesse.services.db import database
database.open_connection()
from jesse.models.Option import Option
# at this point there must already be one option record for "config" existing, so:
o = Option.get(Option.type == 'config')
o.json = json.dumps(client_config)
o.updated_at = jh.now(True)
o.save()
database.close_connection()
def download_file(mode: str, file_type: str, session_id: str = None):
if mode == 'backtest' and file_type == 'log':
path = f'storage/logs/backtest-mode/{session_id}.txt'
filename = f'backtest-{session_id}.txt'
elif mode == 'backtest' and file_type == 'csv':
path = f'storage/csv/{session_id}.csv'
filename = f'backtest-{session_id}.csv'
elif mode == 'backtest' and file_type == 'json':
path = f'storage/json/{session_id}.json'
filename = f'backtest-{session_id}.json'
elif mode == 'backtest' and file_type == 'full-reports':
path = f'storage/full-reports/{session_id}.html'
filename = f'backtest-{session_id}.html'
elif mode == 'backtest' and file_type == 'tradingview':
path = f'storage/trading-view-pine-editor/{session_id}.txt'
filename = f'backtest-{session_id}.txt'
elif mode == 'optimize' and file_type == 'log':
path = f'storage/logs/optimize-mode.txt'
# filename should be "optimize-" + current timestamp
filename = f'optimize-{jh.timestamp_to_date(jh.now(True))}.txt'
elif mode == 'monte-carlo' and file_type == 'log':
path = f'storage/logs/monte-carlo-mode/{session_id}.txt'
filename = f'monte-carlo-{session_id}.txt'
else:
raise Exception(f'Unknown file type: {file_type} or mode: {mode}')
return FileResponse(path=path, filename=filename, media_type='application/octet-stream')
def download_api_keys():
try:
database.open_connection()
api_keys = list(ExchangeApiKeys.select())
if not api_keys:
database.close_connection()
return StreamingResponse(
io.StringIO("No API keys found"),
media_type='text/csv',
headers={'Content-Disposition': 'attachment; filename=api-keys.csv'}
)
output = io.StringIO()
writer = csv.writer(output)
# Prepare the CSV data
headers = ['Name', 'Exchange', 'API Key', 'API Secret', 'api_passphrase', 'wallet_address', 'stark_private_key']
writer.writerow(headers)
for api_key in api_keys:
additional_fields = api_key.get_additional_fields()
row = [
api_key.name,
api_key.exchange_name,
api_key.api_key,
api_key.api_secret,
additional_fields['api_passphrase'] if 'api_passphrase' in additional_fields else None,
additional_fields['wallet_address'] if 'wallet_address' in additional_fields else None,
additional_fields['stark_private_key'] if 'stark_private_key' in additional_fields else None
]
writer.writerow(row)
database.close_connection()
# Return the CSV as a streaming response
output.seek(0)
return StreamingResponse(
output,
media_type='text/csv',
headers={'Content-Disposition': 'attachment; filename=api-keys.csv'}
)
except Exception as e:
database.close_connection()
raise e
def validate_csv_content(content: str) -> bool:
"""
Basic validation: header names + no obvious malicious patterns.
"""
try:
# Reject obvious SQL‑injection patterns
sql_patterns = [
';--', '/*', '*/', 'xp_', 'sp_',
'union ', 'select ', 'insert ', 'update ',
'delete ', 'drop ', 'alter ', 'create '
]
if any(p.lower() in content.lower() for p in sql_patterns):
return False
# Reject suspicious control chars
if any(c in content for c in ['\0', '\x01', '\x1a']):
return False
reader = csv.DictReader(io.StringIO(content))
required_columns = {
'Name',
'Exchange',
'API Key',
'API Secret'
}
# Case‑insensitive comparison
header_set = {h.strip().lower() for h in reader.fieldnames or []}
if not all(col.lower() in header_set for col in required_columns):
return False
return True
except Exception:
return False
def import_api_keys_from_csv(content: str) -> Dict[str, any]:
"""
Import API keys from CSV content string.
Returns a dict with success flag and summary info.
"""
from jesse.models.ExchangeApiKeys import ExchangeApiKeys
from jesse.services.db import database
try:
database.open_connection()
reader = csv.DictReader(io.StringIO(content))
imported_names: list[str] = []
# Keep track of existing names to avoid duplicates
existing_names = {k.name for k in ExchangeApiKeys.select(ExchangeApiKeys.name)}
for row in reader:
name = (row.get('Name') or '').strip()
if not name or name in existing_names:
continue
exchange = (row.get('Exchange') or '').strip()
api_key = (row.get('API Key') or '').strip()
api_secret = (row.get('API Secret') or '').strip()
# Skip rows with missing mandatory fields
if not all([name, exchange, api_key, api_secret]):
continue
additional_fields = {}
if row.get('api_passphrase'):
additional_fields = {
'api_passphrase': (row.get('api_passphrase') or '').strip(),
'wallet_address': (row.get('wallet_address') or '').strip(),
'stark_private_key': (row.get('stark_private_key') or '').strip()
}
# Persist
exchange_api_key: ExchangeApiKeys = ExchangeApiKeys.create(
id=jh.generate_unique_id(),
exchange_name=exchange,
name=name,
api_key=api_key,
api_secret=api_secret,
additional_fields=json.dumps(additional_fields),
created_at=jh.now_to_datetime(),
general_notifications_id=None,
error_notifications_id=None
)
imported_names.append(name)
database.close_connection()
return {
'success': True,
'imported_count': len(imported_names),
}
except Exception as e:
database.close_connection()
return {'success': False, 'error': str(e)}
def get_backtest_logs(session_id: str):
path = f"storage/logs/backtest-mode/{session_id}.txt"
if not os.path.exists(path):
return None
with open(path, "r") as f:
content = f.read()
return jh.compressed_response(content)
def get_monte_carlo_logs(session_id: str):
path = f'storage/logs/monte-carlo-mode/{session_id}.txt'
if not os.path.exists(path):
return None
with open(path, 'r') as f:
content = f.read()
return content
def get_optimization_logs(session_id: str):
path = f'storage/logs/optimize-mode/{session_id}.txt'
if not os.path.exists(path):
return None
with open(path, 'r') as f:
content = f.read()
return content
def download_backtest_log(session_id: str):
"""
Returns the log file for a specific backtest session as a downloadable file
"""
path = f'storage/logs/backtest-mode/{session_id}.txt'
if not os.path.exists(path):
raise Exception('Log file not found')
filename = f'backtest-{session_id}.txt'
return FileResponse(
path=path,
filename=filename,
media_type='text/plain'
)
================================================
FILE: jesse/modes/exchange_api_keys.py
================================================
import json
from typing import Optional
from starlette.responses import JSONResponse
from jesse.info import live_trading_exchanges
import jesse.helpers as jh
from jesse.services import transformers
def get_exchange_api_keys() -> JSONResponse:
from jesse.services.db import database
database.open_connection()
from jesse.models.ExchangeApiKeys import ExchangeApiKeys
try:
# fetch all the api keys
api_keys = ExchangeApiKeys.select()
except Exception as e:
database.close_connection()
return JSONResponse({
'status': 'error',
'message': str(e)
}, status_code=500)
# transform each api_key using transformers.get_exchange_api_key()
api_keys = [transformers.get_exchange_api_key(api_key) for api_key in api_keys]
database.close_connection()
return JSONResponse({
'data': api_keys
}, status_code=200)
def store_exchange_api_keys(
exchange: str,
name: str,
api_key: str,
api_secret: str,
additional_fields: Optional[dict] = None,
general_notifications_id: Optional[str] = None,
error_notifications_id: Optional[str] = None,
) -> JSONResponse:
# validate the exchange
if exchange not in live_trading_exchanges:
return JSONResponse({
'status': 'error',
'message': f'Invalid exchange: {exchange}'
}, status_code=400)
from jesse.services.db import database
database.open_connection()
from jesse.models.ExchangeApiKeys import ExchangeApiKeys
# check if the api key already exists
if ExchangeApiKeys.select().where(ExchangeApiKeys.name == name).exists():
database.close_connection()
return JSONResponse({
'status': 'error',
'message': f'API key with the name "{name}" already exists. Please choose another name.'
}, status_code=400)
# Ensure additional_fields is a dictionary
if additional_fields is None:
additional_fields = {}
try:
# create the record
exchange_api_key: ExchangeApiKeys = ExchangeApiKeys.create(
id=jh.generate_unique_id(),
exchange_name=exchange,
name=name,
api_key=api_key,
api_secret=api_secret,
additional_fields=json.dumps(additional_fields),
created_at=jh.now_to_datetime(),
general_notifications_id=general_notifications_id if general_notifications_id else None,
error_notifications_id=error_notifications_id if error_notifications_id else None
)
except ValueError as e:
database.close_connection()
return JSONResponse({
'status': 'error',
'message': str(e)
}, status_code=400)
except Exception as e:
database.close_connection()
return JSONResponse({
'status': 'error',
'message': str(e)
}, status_code=500)
database.close_connection()
return JSONResponse({
'status': 'success',
'message': 'API key has been stored successfully.',
'data': transformers.get_exchange_api_key(exchange_api_key)
}, status_code=200)
def delete_exchange_api_keys(exchange_api_key_id: str) -> JSONResponse:
from jesse.services.db import database
database.open_connection()
from jesse.models.ExchangeApiKeys import ExchangeApiKeys
try:
# delete the record
ExchangeApiKeys.delete().where(ExchangeApiKeys.id == exchange_api_key_id).execute()
except Exception as e:
database.close_connection()
return JSONResponse({
'status': 'error',
'message': str(e)
}, status_code=500)
database.close_connection()
return JSONResponse({
'status': 'success',
'message': 'API key has been deleted successfully.'
}, status_code=200)
================================================
FILE: jesse/modes/import_candles_mode/__init__.py
================================================
import math
import time
from datetime import timedelta
from typing import Dict, List, Any, Union
import arrow
import pydash
from timeloop import Timeloop
import jesse.helpers as jh
from jesse.exceptions import CandleNotFoundInExchange
from jesse.models.Candle import Candle
from jesse.modes.import_candles_mode.drivers import drivers, driver_names
from jesse.modes.import_candles_mode.drivers.interface import CandleExchange
from jesse.config import config
from jesse.services.failure import register_custom_exception_handler
from jesse.services.redis import sync_publish, is_process_active
from jesse.store import store
from jesse import exceptions
from jesse.services.progressbar import Progressbar
def run(
client_id: str,
exchange: str,
symbol: str,
start_date_str: str,
mode: str = 'candles',
running_via_dashboard: bool = True,
show_progressbar: bool = False,
):
if running_via_dashboard:
config['app']['trading_mode'] = mode
register_custom_exception_handler()
store.app.set_session_id(client_id)
# open database connection
from jesse.services.db import database
database.open_connection()
if running_via_dashboard:
# at every second, we check to see if it's time to execute stuff
status_checker = Timeloop()
@status_checker.job(interval=timedelta(seconds=1))
def handle_time():
if is_process_active(client_id) is False:
raise exceptions.Termination
status_checker.start()
try:
start_timestamp = jh.arrow_to_timestamp(arrow.get(start_date_str, 'YYYY-MM-DD'))
except:
raise ValueError(
f'start_date must be a string representing a date before today. ex: 2020-01-17. You entered: {start_date_str}')
# more start_date validations
today = arrow.utcnow().floor('day').int_timestamp * 1000
if start_timestamp == today:
raise ValueError("Today's date is not accepted. start_date must be a string a representing date BEFORE today.")
elif start_timestamp > today:
raise ValueError("Future's date is not accepted. start_date must be a string a representing date BEFORE today.")
# We just call this to throw a exception in case of a symbol without dash
jh.quote_asset(symbol)
symbol = symbol.upper()
until_date = arrow.utcnow().floor('day')
start_date = arrow.get(start_timestamp / 1000)
days_count = jh.date_diff_in_days(start_date, until_date)
candles_count = days_count * 1440
try:
driver: CandleExchange = drivers[exchange]()
except KeyError:
raise ValueError(f'{exchange} is not a supported exchange. Supported exchanges are: {driver_names}')
loop_length = int(candles_count / driver.count) + 1
progressbar = Progressbar(loop_length, step=2)
frontend_update_counter = 0
frontend_update_threshold = 100 # Only notify frontend after this many updates when skipping existing candles
skipped_minutes = 0
imported_minutes = 0
for i in range(candles_count):
temp_start_timestamp = start_date.int_timestamp * 1000
temp_end_timestamp = temp_start_timestamp + (driver.count - 1) * 60000
# to make sure it won't try to import candles from the future! LOL
if temp_start_timestamp > jh.now_to_timestamp():
break
# prevent duplicates calls to boost performance
count = Candle.select().where(
Candle.exchange == exchange,
Candle.symbol == symbol,
Candle.timeframe == '1m' or Candle.timeframe.is_null(),
Candle.timestamp.between(temp_start_timestamp, temp_end_timestamp)
).count()
already_exists = count == driver.count
if already_exists:
skipped_minutes += driver.count
else:
imported_minutes += driver.count
# it's today's candles if temp_end_timestamp < now
if temp_end_timestamp > jh.now_to_timestamp():
temp_end_timestamp = arrow.utcnow().floor('minute').int_timestamp * 1000 - 60000
# fetch from market
candles = driver.fetch(symbol, temp_start_timestamp, timeframe='1m')
# check if candles have been returned and check those returned start with the right timestamp.
# Sometimes exchanges just return the earliest possible candles if the start date doesn't exist.
time_diff = int((candles[0]['timestamp'] - temp_start_timestamp) / 1000) if len(candles) else 0
if not len(candles) or time_diff < 0 or time_diff > 60*100:
first_existing_timestamp = driver.get_starting_time(symbol)
# if driver can't provide accurate get_starting_time()
if first_existing_timestamp is None:
raise CandleNotFoundInExchange(
f'No candles exists in the market for this day: {jh.timestamp_to_time(temp_start_timestamp)[:10]} \n'
'Try another start_date'
)
# handle when there's missing candles during the period
if temp_start_timestamp > first_existing_timestamp:
# see if there are candles for the same date for the backup exchange,
# if so, get those, if not, download from that exchange.
if driver.backup_exchange is not None:
candles = _get_candles_from_backup_exchange(
exchange, driver.backup_exchange, symbol, temp_start_timestamp, temp_end_timestamp
)
else:
temp_start_time = jh.timestamp_to_time(temp_start_timestamp)[:10]
temp_existing_time = jh.timestamp_to_time(first_existing_timestamp)[:10]
msg = f'No candle exists in the market for {temp_start_time}. So Jesse started importing since the first existing date which is {temp_existing_time}'
if running_via_dashboard:
sync_publish('alert', {
'message': msg,
'type': 'info'
})
else:
print(msg)
run(client_id, exchange, symbol, jh.timestamp_to_time(first_existing_timestamp)[:10], mode,
running_via_dashboard, show_progressbar)
return
# fill absent candles (if there's any)
candles = _fill_absent_candles(candles, temp_start_timestamp, temp_end_timestamp)
# store in the database
store_candles_list(candles)
# add as much as driver's count to the temp_start_time
start_date = start_date.shift(minutes=driver.count)
if i % 2 == 0:
progressbar.update()
# For existing candles, throttle frontend updates
if already_exists:
frontend_update_counter += 1
if frontend_update_counter >= frontend_update_threshold:
frontend_update_counter = 0
if running_via_dashboard:
sync_publish('progressbar', {
'current': progressbar.current,
'estimated_remaining_seconds': progressbar.estimated_remaining_seconds
})
# For new candles being fetched, update frontend normally
else:
if running_via_dashboard:
sync_publish('progressbar', {
'current': progressbar.current,
'estimated_remaining_seconds': progressbar.estimated_remaining_seconds
})
if show_progressbar:
jh.clear_output()
print(
f"Progress: {progressbar.current}% - {round(progressbar.estimated_remaining_seconds)} seconds remaining")
# sleep so that the exchange won't get angry at us
if not already_exists:
time.sleep(driver.sleep_time)
skipped_days = round(skipped_minutes / 1440, 1)
imported_days = round(imported_minutes / 1440, 1)
success_text = (
f'Successfully imported candles since "{jh.timestamp_to_date(start_timestamp)}" until today '
f'({imported_days} days imported, {skipped_days} days already existed in the database). '
)
# stop the status_checker time loop
if running_via_dashboard:
status_checker.stop()
sync_publish('alert', {
'message': success_text,
'type': 'success'
})
# # TODO: shen should it close the database?
# # if it is to skip, then it's being called from another process hence we should leave the database be
# if not skip_confirmation:
if not running_via_dashboard:
# close database connection
from jesse.services.db import database
database.close_connection()
return success_text
def _get_candles_from_backup_exchange(exchange: str, backup_driver: CandleExchange, symbol: str, start_timestamp: int,
end_timestamp: int) -> List[Dict[str, Union[str, Any]]]:
timeframe = '1m'
total_candles = []
# try fetching from database first
backup_candles = Candle.select(
Candle.timestamp, Candle.open, Candle.close, Candle.high, Candle.low,
Candle.volume
).where(
Candle.exchange == backup_driver.name,
Candle.symbol == symbol,
Candle.timeframe == timeframe,
Candle.timestamp.between(start_timestamp, end_timestamp)
).order_by(Candle.timestamp.asc()).tuples()
already_exists = len(backup_candles) == (end_timestamp - start_timestamp) / 60_000 + 1
if already_exists:
# loop through them and set new ID and exchange
for c in backup_candles:
total_candles.append({
'id': jh.generate_unique_id(),
'exchange': exchange,
'symbol': symbol,
'timeframe': timeframe,
'timestamp': c[0],
'open': c[1],
'close': c[2],
'high': c[3],
'low': c[4],
'volume': c[5]
})
return total_candles
# try fetching from market now
days_count = jh.date_diff_in_days(jh.timestamp_to_arrow(start_timestamp), jh.timestamp_to_arrow(end_timestamp))
# make sure it's rounded up so that we import maybe more candles, but not less
days_count = max(days_count, 1)
if type(days_count) is float and not days_count.is_integer():
days_count = math.ceil(days_count)
candles_count = days_count * 1440
start_date = jh.timestamp_to_arrow(start_timestamp).floor('day')
for _ in range(candles_count):
temp_start_timestamp = start_date.int_timestamp * 1000
temp_end_timestamp = temp_start_timestamp + (backup_driver.count - 1) * 60000
# to make sure it won't try to import candles from the future! LOL
if temp_start_timestamp > jh.now_to_timestamp():
break
# prevent duplicates
count = Candle.select().where(
Candle.exchange == backup_driver.name,
Candle.symbol == symbol,
Candle.timeframe == timeframe,
Candle.timestamp.between(temp_start_timestamp, temp_end_timestamp)
).count()
already_exists = count == backup_driver.count
if not already_exists:
# it's today's candles if temp_end_timestamp < now
if temp_end_timestamp > jh.now_to_timestamp():
temp_end_timestamp = arrow.utcnow().floor('minute').int_timestamp * 1000 - 60000
# fetch from market
candles = backup_driver.fetch(symbol, temp_start_timestamp)
if not len(candles):
raise CandleNotFoundInExchange(
f'No candles exists in the market for this day: {jh.timestamp_to_time(temp_start_timestamp)[:10]} \n'
'Try another start_date'
)
# fill absent candles (if there's any)
candles = _fill_absent_candles(candles, temp_start_timestamp, temp_end_timestamp)
# store in the database
store_candles_list(candles)
# add as much as driver's count to the temp_start_time
start_date = start_date.shift(minutes=backup_driver.count)
# sleep so that the exchange won't get angry at us
if not already_exists:
time.sleep(backup_driver.sleep_time)
# now try fetching from database again. Why? because we might have fetched more
# than what's needed, but we only want as much was requested. Don't worry, the next
# request will probably fetch from database and there won't be any waste!
backup_candles = Candle.select(
Candle.timestamp, Candle.open, Candle.close, Candle.high, Candle.low,
Candle.volume
).where(
Candle.exchange == backup_driver.name,
Candle.symbol == symbol,
Candle.timeframe == timeframe,
Candle.timestamp.between(start_timestamp, end_timestamp)
).order_by(Candle.timestamp.asc()).tuples()
already_exists = len(backup_candles) == (end_timestamp - start_timestamp) / 60_000 + 1
if already_exists:
# loop through them and set new ID and exchange
for c in backup_candles:
total_candles.append({
'id': jh.generate_unique_id(),
'exchange': exchange,
'symbol': symbol,
'timeframe': timeframe,
'timestamp': c[0],
'open': c[1],
'close': c[2],
'high': c[3],
'low': c[4],
'volume': c[5]
})
return total_candles
def _fill_absent_candles(temp_candles: List[Dict[str, Union[str, Any]]], start_timestamp: int, end_timestamp: int) -> \
List[Dict[str, Union[str, Any]]]:
if not temp_candles:
raise CandleNotFoundInExchange(
f'No candles exists in the market for this day: {jh.timestamp_to_time(start_timestamp)[:10]} \n'
'Try another start_date'
)
symbol = temp_candles[0]['symbol']
exchange = temp_candles[0]['exchange']
candles = []
first_candle = temp_candles[0]
started = False
loop_length = ((end_timestamp - start_timestamp) / 60000) + 1
for _ in range(int(loop_length)):
candle_for_timestamp = pydash.find(
temp_candles, lambda c: c['timestamp'] == start_timestamp)
if candle_for_timestamp is None:
if started:
last_close = candles[-1]['close']
candles.append({
'id': jh.generate_unique_id(),
'exchange': exchange,
'symbol': symbol,
'timeframe': '1m',
'timestamp': start_timestamp,
'open': last_close,
'high': last_close,
'low': last_close,
'close': last_close,
'volume': 0
})
else:
candles.append({
'id': jh.generate_unique_id(),
'exchange': exchange,
'symbol': symbol,
'timeframe': '1m',
'timestamp': start_timestamp,
'open': first_candle['open'],
'high': first_candle['open'],
'low': first_candle['open'],
'close': first_candle['open'],
'volume': 0
})
# candle is present
else:
started = True
candles.append(candle_for_timestamp)
start_timestamp += 60000
return candles
def store_candles_list(candles: List[Dict]) -> None:
for c in candles:
if 'timeframe' not in c:
raise Exception('Candle has no timeframe')
Candle.insert_many(candles).on_conflict_ignore().execute()
================================================
FILE: jesse/modes/import_candles_mode/drivers/Apex/ApexOmniPerpetual.py
================================================
from .ApexProMain import ApexProMain
from jesse.enums import exchanges
class ApexOmniPerpetual(ApexProMain):
def __init__(self) -> None:
super().__init__(
name=exchanges.APEX_OMNI_PERPETUAL,
rest_endpoint='https://omni.apex.exchange/api/v3'
)
================================================
FILE: jesse/modes/import_candles_mode/drivers/Apex/ApexOmniPerpetualTestnet.py
================================================
from .ApexProMain import ApexProMain
from jesse.enums import exchanges
class ApexOmniPerpetualTestnet(ApexProMain):
def __init__(self) -> None:
super().__init__(
name=exchanges.APEX_OMNI_PERPETUAL_TESTNET,
rest_endpoint='https://testnet.omni.apex.exchange/api/v3'
)
================================================
FILE: jesse/modes/import_candles_mode/drivers/Apex/ApexProMain.py
================================================
import requests
import jesse.helpers as jh
from jesse.modes.import_candles_mode.drivers.interface import CandleExchange
from typing import Union
from jesse import exceptions
from .apex_pro_utils import timeframe_to_interval
class ApexProMain(CandleExchange):
def __init__(self, name: str, rest_endpoint: str) -> None:
from jesse.modes.import_candles_mode.drivers.Binance.BinanceSpot import BinanceSpot
super().__init__(name=name, count=200, rate_limit_per_second=10, backup_exchange_class=BinanceSpot)
self.name = name
self.endpoint = rest_endpoint
def get_starting_time(self, symbol: str) -> int:
dashless_symbol = jh.dashless_symbol(symbol)
payload = {
'symbol': dashless_symbol,
'interval': 'W',
'limit': 200,
'start': 1514811660
}
response = requests.get(self.endpoint + '/klines', params=payload)
self.validate_response(response)
if 'data' not in response.json():
raise exceptions.ExchangeInMaintenance(response.json()['msg'])
elif response.json()['data'] == {}:
raise exceptions.InvalidSymbol('Exchange does not support the entered symbol. Please enter a valid symbol.')
data = response.json()['data'][dashless_symbol]
# Reverse the data list
data = data[::-1]
return int(data[1]['t'])
def fetch(self, symbol: str, start_timestamp: int, timeframe: str = '1m') -> Union[list, None]:
dashless_symbol = jh.dashless_symbol(symbol)
interval = timeframe_to_interval(timeframe)
payload = {
'symbol': dashless_symbol,
'interval': interval,
'start': int(start_timestamp / 1000),
'limit': self.count
}
response = requests.get(self.endpoint + '/klines', params=payload)
# check data exist in response.json
if 'data' not in response.json():
raise exceptions.ExchangeInMaintenance(response.json()['msg'])
elif response.json()['data'] == {}:
raise exceptions.InvalidSymbol('Exchange does not support the entered symbol. Please enter a valid symbol.')
data = response.json()['data'][dashless_symbol]
return [
{
'id': jh.generate_unique_id(),
'exchange': self.name,
'symbol': symbol,
'timeframe': timeframe,
'timestamp': int(d['t']),
'open': float(d['o']),
'close': float(d['c']),
'high': float(d['h']),
'low': float(d['l']),
'volume': float(d['v'])
} for d in data
]
def get_available_symbols(self) -> list:
response = requests.get(self.endpoint + '/symbols')
self.validate_response(response)
data = response.json()['data']
# Determine which suffix to filter based on exchange name
target_suffix = '-USDT' if self.name.startswith('Apex Omni') else '-USDC'
# For legacy API response format
if 'usdtConfig' not in data:
symbols = []
contracts = data['contractConfig']['perpetualContract']
for p in contracts:
symbol = p['symbol']
if symbol.endswith(target_suffix):
symbols.append(symbol)
return list(sorted(symbols))
# For new API response format
pairs = []
# For Omni (USDT pairs)
if target_suffix == '-USDT':
if 'usdtConfig' in data and 'perpetualContract' in data['usdtConfig']:
contracts = data['usdtConfig']['perpetualContract']
for p in contracts:
symbol = p['symbol']
if symbol.endswith(target_suffix):
pairs.append(symbol)
# For Pro (USDC pairs)
else:
if 'usdcConfig' in data and 'perpetualContract' in data['usdcConfig']:
contracts = data['usdcConfig']['perpetualContract']
for p in contracts:
symbol = p['symbol']
if symbol.endswith(target_suffix):
pairs.append(symbol)
return list(sorted(pairs))
================================================
FILE: jesse/modes/import_candles_mode/drivers/Apex/ApexProPerpetual.py
================================================
from .ApexProMain import ApexProMain
from jesse.enums import exchanges
class ApexProPerpetual(ApexProMain):
def __init__(self) -> None:
super().__init__(
name=exchanges.APEX_PRO_PERPETUAL,
rest_endpoint='https://pro.apex.exchange/api/v2'
)
================================================
FILE: jesse/modes/import_candles_mode/drivers/Apex/ApexProPerpetualTestnet.py
================================================
from .ApexProMain import ApexProMain
from jesse.enums import exchanges
class ApexProPerpetualTestnet(ApexProMain):
def __init__(self) -> None:
super().__init__(
name=exchanges.APEX_PRO_PERPETUAL_TESTNET,
rest_endpoint='https://testnet.pro.apex.exchange/api/v2'
)
================================================
FILE: jesse/modes/import_candles_mode/drivers/Apex/__init__.py
================================================
================================================
FILE: jesse/modes/import_candles_mode/drivers/Apex/apex_pro_utils.py
================================================
from jesse.enums import timeframes
def timeframe_to_interval(timeframe: str) -> str:
"""
Convert a timeframe string to an interval in seconds.
"""
if timeframe == timeframes.MINUTE_1:
return '1'
elif timeframe == timeframes.MINUTE_3:
return '3'
elif timeframe == timeframes.MINUTE_5:
return '5'
elif timeframe == timeframes.MINUTE_15:
return '15'
elif timeframe == timeframes.MINUTE_30:
return '30'
elif timeframe == timeframes.HOUR_1:
return '60'
elif timeframe == timeframes.HOUR_2:
return '120'
elif timeframe == timeframes.HOUR_4:
return '240'
elif timeframe == timeframes.HOUR_6:
return '360'
elif timeframe == timeframes.HOUR_12:
return '720'
elif timeframe == timeframes.DAY_1:
return 'D'
elif timeframe == timeframes.WEEK_1:
return 'W'
else:
raise ValueError('Invalid timeframe: {}'.format(timeframe))
def interval_to_timeframe(interval: str) -> str:
"""
Convert an interval in seconds to a timeframe string.
"""
if interval == '1':
return timeframes.MINUTE_1
elif interval == '3':
return timeframes.MINUTE_3
elif interval == '5':
return timeframes.MINUTE_5
elif interval == '15':
return timeframes.MINUTE_15
elif interval == '30':
return timeframes.MINUTE_30
elif interval == '60':
return timeframes.HOUR_1
elif interval == '120':
return timeframes.HOUR_2
elif interval == '240':
return timeframes.HOUR_4
elif interval == '360':
return timeframes.HOUR_6
elif interval == '720':
return timeframes.HOUR_12
elif interval == 'D':
return timeframes.DAY_1
elif interval == 'W':
return timeframes.WEEK_1
else:
raise ValueError('Invalid interval: {}'.format(interval))
================================================
FILE: jesse/modes/import_candles_mode/drivers/Apex/omni_files/__init__.py
================================================
================================================
FILE: jesse/modes/import_candles_mode/drivers/Apex/omni_files/zklink_sdk-arm.py
================================================
# This file was autogenerated by some hot garbage in the `uniffi` crate.
# Trust me, you don't want to mess with it!
# Common helper code.
#
# Ideally this would live in a separate .py file where it can be unittested etc
# in isolation, and perhaps even published as a re-useable package.
#
# However, it's important that the details of how this helper code works (e.g. the
# way that different builtin types are passed across the FFI) exactly match what's
# expected by the rust code on the other side of the interface. In practice right
# now that means coming from the exact some version of `uniffi` that was used to
# compile the rust component. The easiest way to ensure this is to bundle the Python
# helpers directly inline like we're doing here.
import os
import sys
import ctypes
import enum
import struct
import contextlib
import threading
import typing
import platform
# Used for default argument values
_DEFAULT = object()
class _UniffiRustBuffer(ctypes.Structure):
_fields_ = [
("capacity", ctypes.c_int32),
("len", ctypes.c_int32),
("data", ctypes.POINTER(ctypes.c_char)),
]
@staticmethod
def alloc(size):
return _rust_call(_UniffiLib.ffi_zklink_sdk_rustbuffer_alloc, size)
@staticmethod
def reserve(rbuf, additional):
return _rust_call(_UniffiLib.ffi_zklink_sdk_rustbuffer_reserve, rbuf, additional)
def free(self):
return _rust_call(_UniffiLib.ffi_zklink_sdk_rustbuffer_free, self)
def __str__(self):
return "_UniffiRustBuffer(capacity={}, len={}, data={})".format(
self.capacity,
self.len,
self.data[0:self.len]
)
@contextlib.contextmanager
def alloc_with_builder(*args):
"""Context-manger to allocate a buffer using a _UniffiRustBufferBuilder.
The allocated buffer will be automatically freed if an error occurs, ensuring that
we don't accidentally leak it.
"""
builder = _UniffiRustBufferBuilder()
try:
yield builder
except:
builder.discard()
raise
@contextlib.contextmanager
def consume_with_stream(self):
"""Context-manager to consume a buffer using a _UniffiRustBufferStream.
The _UniffiRustBuffer will be freed once the context-manager exits, ensuring that we don't
leak it even if an error occurs.
"""
try:
s = _UniffiRustBufferStream.from_rust_buffer(self)
yield s
if s.remaining() != 0:
raise RuntimeError("junk data left in buffer at end of consume_with_stream")
finally:
self.free()
@contextlib.contextmanager
def read_with_stream(self):
"""Context-manager to read a buffer using a _UniffiRustBufferStream.
This is like consume_with_stream, but doesn't free the buffer afterwards.
It should only be used with borrowed `_UniffiRustBuffer` data.
"""
s = _UniffiRustBufferStream.from_rust_buffer(self)
yield s
if s.remaining() != 0:
raise RuntimeError("junk data left in buffer at end of read_with_stream")
class _UniffiForeignBytes(ctypes.Structure):
_fields_ = [
("len", ctypes.c_int32),
("data", ctypes.POINTER(ctypes.c_char)),
]
def __str__(self):
return "_UniffiForeignBytes(len={}, data={})".format(self.len, self.data[0:self.len])
class _UniffiRustBufferStream:
"""
Helper for structured reading of bytes from a _UniffiRustBuffer
"""
def __init__(self, data, len):
self.data = data
self.len = len
self.offset = 0
@classmethod
def from_rust_buffer(cls, buf):
return cls(buf.data, buf.len)
def remaining(self):
return self.len - self.offset
def _unpack_from(self, size, format):
if self.offset + size > self.len:
raise InternalError("read past end of rust buffer")
value = struct.unpack(format, self.data[self.offset:self.offset+size])[0]
self.offset += size
return value
def read(self, size):
if self.offset + size > self.len:
raise InternalError("read past end of rust buffer")
data = self.data[self.offset:self.offset+size]
self.offset += size
return data
def read_i8(self):
return self._unpack_from(1, ">b")
def read_u8(self):
return self._unpack_from(1, ">B")
def read_i16(self):
return self._unpack_from(2, ">h")
def read_u16(self):
return self._unpack_from(2, ">H")
def read_i32(self):
return self._unpack_from(4, ">i")
def read_u32(self):
return self._unpack_from(4, ">I")
def read_i64(self):
return self._unpack_from(8, ">q")
def read_u64(self):
return self._unpack_from(8, ">Q")
def read_float(self):
v = self._unpack_from(4, ">f")
return v
def read_double(self):
return self._unpack_from(8, ">d")
def read_c_size_t(self):
return self._unpack_from(ctypes.sizeof(ctypes.c_size_t) , "@N")
class _UniffiRustBufferBuilder:
"""
Helper for structured writing of bytes into a _UniffiRustBuffer.
"""
def __init__(self):
self.rbuf = _UniffiRustBuffer.alloc(16)
self.rbuf.len = 0
def finalize(self):
rbuf = self.rbuf
self.rbuf = None
return rbuf
def discard(self):
if self.rbuf is not None:
rbuf = self.finalize()
rbuf.free()
@contextlib.contextmanager
def _reserve(self, num_bytes):
if self.rbuf.len + num_bytes > self.rbuf.capacity:
self.rbuf = _UniffiRustBuffer.reserve(self.rbuf, num_bytes)
yield None
self.rbuf.len += num_bytes
def _pack_into(self, size, format, value):
with self._reserve(size):
# XXX TODO: I feel like I should be able to use `struct.pack_into` here but can't figure it out.
for i, byte in enumerate(struct.pack(format, value)):
self.rbuf.data[self.rbuf.len + i] = byte
def write(self, value):
with self._reserve(len(value)):
for i, byte in enumerate(value):
self.rbuf.data[self.rbuf.len + i] = byte
def write_i8(self, v):
self._pack_into(1, ">b", v)
def write_u8(self, v):
self._pack_into(1, ">B", v)
def write_i16(self, v):
self._pack_into(2, ">h", v)
def write_u16(self, v):
self._pack_into(2, ">H", v)
def write_i32(self, v):
self._pack_into(4, ">i", v)
def write_u32(self, v):
self._pack_into(4, ">I", v)
def write_i64(self, v):
self._pack_into(8, ">q", v)
def write_u64(self, v):
self._pack_into(8, ">Q", v)
def write_float(self, v):
self._pack_into(4, ">f", v)
def write_double(self, v):
self._pack_into(8, ">d", v)
def write_c_size_t(self, v):
self._pack_into(ctypes.sizeof(ctypes.c_size_t) , "@N", v)
# A handful of classes and functions to support the generated data structures.
# This would be a good candidate for isolating in its own ffi-support lib.
class InternalError(Exception):
pass
class _UniffiRustCallStatus(ctypes.Structure):
"""
Error runtime.
"""
_fields_ = [
("code", ctypes.c_int8),
("error_buf", _UniffiRustBuffer),
]
# These match the values from the uniffi::rustcalls module
CALL_SUCCESS = 0
CALL_ERROR = 1
CALL_PANIC = 2
def __str__(self):
if self.code == _UniffiRustCallStatus.CALL_SUCCESS:
return "_UniffiRustCallStatus(CALL_SUCCESS)"
elif self.code == _UniffiRustCallStatus.CALL_ERROR:
return "_UniffiRustCallStatus(CALL_ERROR)"
elif self.code == _UniffiRustCallStatus.CALL_PANIC:
return "_UniffiRustCallStatus(CALL_PANIC)"
else:
return "_UniffiRustCallStatus(