📌 Detrended Price Oscillator (DPO) – Циклические сигналы без влияния тренда🧑‍💻

Суть индикатора:🚀

DPO (Detrended Price Oscillator) — осциллятор, созданный для выявления циклических колебаний цены, игнорируя долгосрочный тренд.

В отличие от большинства осцилляторов, DPO не используется для генерации сигналов тренда, а фокусируется на короткосрочной перекупленности/перепроданности.

import ccxt
import pandas as pd

# Настройки
exchange = ccxt.binance()
symbol = "BTC/USDT"
timeframe = "1h"
period = 14

# Загрузка исторических данных
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=200)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Расчёт DPO
shift = int(period / 2 + 1)
df["sma"] = df["close"].rolling(window=period).mean()
df["dpo"] = df["close"].shift(shift) - df["sma"]

# Пример последних значений
print(df[["ts", "close", "dpo"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌 Whale Wallet Tracking Strategy – Реакция на перемещения с крупных кошельков🧑‍💻

Суть стратегии:🚀

Крупные кошельки ("whales") часто принадлежат биржам, фондам, институционалам или ранним инвесторам.

Мониторинг их активности позволяет:

- Предугадывать возможную продажу или покупку,

- Реагировать на переводы на биржи (продажа) или с выводом с бирж (накопление),

- Использовать в стратегиях как фильтр или триггер.

Источники данных:💸

Whale Alert API

Glassnode – аналитика перемещений

Arkham Intelligence – адреса по именам

Onchain API (например, через etherscan, blockchair, bitquery, chainbase)

import requests
import time

API_KEY = "YOUR_WHALE_ALERT_API_KEY"
MIN_VALUE = 500000  # USD
INTERVAL = 60  # сек

def fetch_transfers():
    url = "https://api.whale-alert.io/v1/transactions"
    params = {
        "api_key": API_KEY,
        "min_value": MIN_VALUE,
        "currency": "btc",
        "limit": 10
    }
    r = requests.get(url, params=params)
    data = r.json()
    return data.get("transactions", [])

def parse_transfer(tx):
    direction = "→ EXCHANGE" if tx["to"]["owner_type"] == "exchange" else "← FROM EXCHANGE"
    print(f"[{tx['timestamp']}] {tx['amount']} BTC {direction} | From: {tx['from']['owner']} → {tx['to']['owner']}")

if __name__ == "__main__":
    while True:
        txs = fetch_transfers()
        for tx in txs:
            parse_transfer(tx)
        time.sleep(INTERVAL)

#индикатор

📌 Подпишись  Crypto Python❗️

📌 Volatility Regime Classifier – Классификация рынка на флет и тренд🧑‍💻

Суть идеи:🚀

Рынок постоянно переходит между двумя основными режимами:

Тренд — направленное движение (вверх или вниз),

Флет — боковик, консолидация, низкая волатильность.

Цель стратегии:🛠️
автоматически определить текущий режим рынка, чтобы:

- применять подходящую стратегию (например, трендовая/флетовая),

- фильтровать ложные сигналы,

- управлять рисками.

import ccxt
import pandas as pd
import talib

# Параметры
exchange = ccxt.binance()
symbol = "BTC/USDT"
timeframe = "1h"
atr_period = 14
lookback = 150
volatility_threshold = 100  # например, 100 USDT по BTC

# Получение данных
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=lookback)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Расчёт ATR (волатильности)
df["atr"] = talib.ATR(df["high"], df["low"], df["close"], timeperiod=atr_period)

# Классификация режима
df["regime"] = "flat"
df.loc[df["atr"] > volatility_threshold, "regime"] = "trend"

# Последнее состояние
last = df.iloc[-1]
print(f"Последний режим рынка: {last['regime'].upper()} (ATR = {last['atr']:.2f})")

#индикатор

📌 Подпишись  Crypto Python❗️

📌 Trade Execution Optimizer – Оптимизация входа с учётом комиссий и проскальзывания🧑‍💻

Суть идеи:🚀

Цель Trade Execution Optimizer — минимизировать издержки при входе/выходе в позицию за счёт:

- правильного выбора типа ордера (market / limit / TWAP / VWAP),

- учёта комиссий и проскальзывания,

- адаптации к ликвидности и объёму актива,

- разбиения крупных ордеров на части (execution slicing).

Факторы, которые учитываются:🛠️

1. Тип ордера:

Market – быстро, но с проскальзыванием

Limit – без проскальзывания, но не факт что исполнится

TWAP/VWAP – равномерное исполнение во времени/объёму

2. Комиссия биржи (taker/maker fees)

3. Глубина стакана (Order Book)

- влияет на проскальзывание при рыночных ордерах

4. Объём сделки относительно ликвидности

- если объём слишком большой → разбивать на части

import ccxt

# Параметры
exchange = ccxt.binance()
symbol = "BTC/USDT"
trade_amount_usdt = 10000
maker_fee = 0.0001
taker_fee = 0.0004

# Получение стакана
order_book = exchange.fetch_order_book(symbol, limit=20)

def estimate_market_execution_cost(order_book, amount_usdt):
    total_cost = 0
    remaining = amount_usdt
    for price, volume in order_book['asks']:  # покупка по market
        vol_usdt = price * volume
        if vol_usdt >= remaining:
            total_cost += price * (remaining / price)
            break
        else:
            total_cost += vol_usdt
            remaining -= vol_usdt
    avg_price = total_cost / amount_usdt
    return avg_price

def estimate_limit_execution_cost(price, amount_usdt):
    return price  # если исполнится – цена фиксированная

# Расчёты
market_price = estimate_market_execution_cost(order_book, trade_amount_usdt)
limit_price = order_book['asks'][0][0]  # best ask

cost_market = market_price * (1 + taker_fee)
cost_limit = limit_price * (1 + maker_fee)

print(f"Market исполнение: {market_price:.2f} USDT (с учётом комиссии: {cost_market:.2f})")
print(f"Limit исполнение:  {limit_price:.2f} USDT (с учётом комиссии: {cost_limit:.2f})")

if cost_market < cost_limit:
    print("✅ Выгоднее использовать MARKET ордер")
else:
    print("✅ Выгоднее использовать LIMIT ордер")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌 Donchian Channel Reversal – Стратегия разворота от границ канала Дончиана🧑‍💻

Суть стратегии:🚀

Канал Дончиана (Donchian Channel) строится по максимуму и минимуму за определённое количество баров (обычно 20).
Вместо пробойной логики, в этой стратегии используется отскок от границ канала, что подходит для флетового рынка или контртрендовой торговли.

Правила стратегии:💸

- Покупка, когда цена коснулась нижней границы и начинает отскакивать

- Продажа, когда цена достигла верхней границы и начинает разворачиваться вниз

import ccxt
import pandas as pd

# Настройки
exchange = ccxt.binance()
symbol = "BTC/USDT"
timeframe = "1h"
lookback = 100
channel_period = 20

# Получение данных
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=lookback)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Канал Дончиана
df["donchian_high"] = df["high"].rolling(window=channel_period).max()
df["donchian_low"] = df["low"].rolling(window=channel_period).min()

# Сигналы разворота
df["signal"] = 0
df.loc[
    (df["low"] <= df["donchian_low"]) & (df["close"] > df["open"]),
    "signal"
] = 1  # Покупка после отскока от нижней границы

df.loc[
    (df["high"] >= df["donchian_high"]) & (df["close"] < df["open"]),
    "signal"
] = -1  # Продажа после отскока от верхней границы

# Последний сигнал
last = df.iloc[-1]
print(f"Последняя свеча: {last['ts']}")
print(f"Donchian High: {last['donchian_high']:.2f} | Low: {last['donchian_low']:.2f}")
print(f"Цена закрытия: {last['close']:.2f}")
print(f"Сигнал: {'BUY' if last['signal'] == 1 else 'SELL' if last['signal'] == -1 else 'NONE'}")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌 Risk-Reward Ratio Analyzer – Анализ соотношения риска к прибыли (R:R) по открытым сделкам🧑‍💻

Суть идеи:🛠️

Risk-Reward Ratio (R:R) — это ключевой показатель в управлении капиталом.
Он показывает, сколько потенциальной прибыли вы можете получить на каждый единичный риск (стоп-лосс).

Для чего нужен Risk-Reward Analyzer:🛠️

- Оценить качество сделок, а не только результат

- Отфильтровывать сигналы с плохим соотношением (например, R:R < 1.5)

- Помогать трейдеру принимать осознанные входы

# Пример параметров сделки
entry_price = 27000       # точка входа
stop_loss = 26500         # стоп-лосс
take_profit = 28000       # тейк-профит
position_side = "long"    # или "short"

# Расчёт риска и прибыли
if position_side == "long":
    risk = entry_price - stop_loss
    reward = take_profit - entry_price
else:
    risk = stop_loss - entry_price
    reward = entry_price - take_profit

# Проверка на ноль
if risk <= 0 or reward <= 0:
    print("Некорректные значения (TP и SL должны быть на разных сторонах от входа)")
else:
    rr_ratio = reward / risk
    print(f"Сделка: {position_side.upper()} | R:R = {rr_ratio:.2f}")
    if rr_ratio >= 2:
        print("✅ Отличное соотношение")
    elif rr_ratio >= 1:
        print("⚠️ Приемлемо")
    else:
        print("❌ Низкое соотношение (нежелательная сделка)")

#инструмент

📌 Подпишись  Crypto Python❗️

📌 Ehler’s Fisher Transform – Определение экстремумов через нормализацию🧑‍💻

Суть индикатора:🛠️

Fisher Transform от Джона Эйлерса — это математическая трансформация, которая переводит данные в псевдо-нормальное распределение, усиливая крайние значения (экстремумы).
Он помогает точнее выявлять разворотные точки, особенно в сочетании с другими осцилляторами.

Типовые сигналы:💸

- Пересечение нуля: возможный разворот

- Выход за уровни ±1.5 или ±2: перекупленность/перепроданность

import ccxt
import pandas as pd
import numpy as np

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
tf = "1h"
limit = 300

ohlcv = exchange.fetch_ohlcv(symbol, timeframe=tf, limit=limit)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Fisher Transform
length = 10
price = (df["high"] + df["low"]) / 2
min_low = price.rolling(length).min()
max_high = price.rolling(length).max()
value = 2 * ((price - min_low) / (max_high - min_low + 1e-9) - 0.5)

# Ограничим значения от -0.999 до 0.999
value = value.clip(-0.999, 0.999)

# Применим трансформацию
fisher = 0.5 * np.log((1 + value) / (1 - value))
df["fisher"] = fisher.rolling(3).mean()

# Последние значения
print(df[["ts", "close", "fisher"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌Synthetic Asset Arbitrage – Арбитраж между синтетическими и реальными активами🧑‍💻

Суть стратегии:🚀

Синтетические активы (например, sBTC, sETH, cETH, ibBTC) — это токены, которые отражают цену другого актива, но торгуются на других платформах (DeFi-протоколах, мостах, деривативах).

Synthetic Arbitrage предполагает:🛠️

- Покупку актива там, где он дешевле,

- Продажу эквивалентного реального или синтетического актива там, где он дороже,

- Получение прибыли из-за временных дисбалансов в цене между синтетическим и базовым активом.

❗На что обращать внимание:

- Комиссии за своп, газ, мосты

- Время подтверждения (можно проскочить окно арбитража)

- Лимит ликвидности в пуле

- Возможность обратного обмена (exit liquidity)

import ccxt
import requests

def get_binance_btc_price():
    binance = ccxt.binance()
    ticker = binance.fetch_ticker("BTC/USDT")
    return ticker['last']

def get_synthetix_sbtc_price():
    # Пример: через API 1inch или Coingecko (тут демонстрация через Coingecko)
    url = "https://api.coingecko.com/api/v3/simple/price"
    params = {"ids": "sbtc", "vs_currencies": "usd"}
    r = requests.get(url, params=params)
    return r.json()["sbtc"]["usd"]

real_btc = get_binance_btc_price()
synthetic_btc = get_synthetix_sbtc_price()

spread = synthetic_btc - real_btc
spread_pct = spread / real_btc * 100

print(f"BTC (Binance):     ${real_btc:.2f}")
print(f"sBTC (Synthetix):  ${synthetic_btc:.2f}")
print(f"Спред:             ${spread:.2f} ({spread_pct:.2f}%)")

if abs(spread_pct) > 0.5:
    print("⚠️ Обнаружена возможность арбитража")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌 Fractal Adaptive Moving Average (FRAMA) – Адаптивная скользящая средняя на фрактальной основе🧑‍💻

Суть индикатора:🛠️

FRAMA — это усовершенствованная скользящая средняя, предложенная Джоном Эйлерсом, которая:

- адаптируется к рыночной волатильности,

- становится гладкой во флете и быстрой в тренде,

- основана на оценке фрактальной размерности цены (измерение "неровности").

import ccxt
import pandas as pd
import numpy as np

# Настройки
symbol = "BTC/USDT"
timeframe = "1h"
n = 16  # длина окна FRAMA
w = 5   # размер сегмента внутри окна

exchange = ccxt.binance()
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=300)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

def frama(close, n=16, w=5):
    alpha_min = 0.01
    alpha_max = 1.0
    frama = [close[0]]

    for i in range(1, len(close)):
        if i < n:
            frama.append(close[i])
            continue

        hl = close[i - n + 1:i + 1]
        hl1 = close[i - n + 1:i - n//2 + 1]
        hl2 = close[i - n//2 + 1:i + 1]

        n1 = (hl1.max() - hl1.min()) / (n // 2)
        n2 = (hl2.max() - hl2.min()) / (n // 2)
        n3 = (hl.max() - hl.min()) / n

        if n1 > 0 and n2 > 0 and n3 > 0:
            D = (np.log(n1 + n2) - np.log(n3)) / np.log(2)
            alpha = np.exp(-4.6 * (D - 1))
            alpha = min(max(alpha, alpha_min), alpha_max)
        else:
            alpha = alpha_min

        frama_val = alpha * close[i] + (1 - alpha) * frama[-1]
        frama.append(frama_val)

    return pd.Series(frama, index=close.index)

# Применение
df["frama"] = frama(df["close"])

# Вывод последних значений
print(df[["ts", "close", "frama"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌 Order Book Depth Shift Detector – Реакция на сдвиг в плотности стакана🧑‍💻

Суть стратегии:🚀

Стакан заявок (Order Book) отражает текущие уровни спроса и предложения.
Depth Shift Detector отслеживает внезапные изменения в плотности ордеров — например:

- Появление/исчезновение крупных стен (bid/ask walls)

- Смещение объёмов ближе/дальше от текущей цены

- Неожиданное перевешивание стороны (ask >> bid или наоборот)

Зачем отслеживать:💸

- Это может быть сигналом к движению цены в сторону "разгрузки"

- Крупные лимитные ордера влияют на ликвидность и исполнение

- В High Frequency Trading и скальпинге — ключевая информация

import ccxt
import time

exchange = ccxt.binance()
symbol = "BTC/USDT"
depth_limit = 20
poll_interval = 3  # секунд

def get_depth_snapshot():
    ob = exchange.fetch_order_book(symbol, limit=depth_limit)
    bids = {round(price, 2): size for price, size in ob['bids']}
    asks = {round(price, 2): size for price, size in ob['asks']}
    return bids, asks

prev_bids, prev_asks = get_depth_snapshot()

while True:
    time.sleep(poll_interval)
    bids, asks = get_depth_snapshot()

    for price in bids:
        prev_size = prev_bids.get(price, 0)
        curr_size = bids[price]
        if curr_size > prev_size * 2 and curr_size > 10:
            print(f"🔵 Увеличение BID на {price}: {prev_size:.2f} → {curr_size:.2f}")
        elif curr_size < prev_size * 0.5 and prev_size > 10:
            print(f"⚠️ Снятие BID на {price}: {prev_size:.2f} → {curr_size:.2f}")

    for price in asks:
        prev_size = prev_asks.get(price, 0)
        curr_size = asks[price]
        if curr_size > prev_size * 2 and curr_size > 10:
            print(f"🔴 Увеличение ASK на {price}: {prev_size:.2f} → {curr_size:.2f}")
        elif curr_size < prev_size * 0.5 and prev_size > 10:
            print(f"⚠️ Снятие ASK на {price}: {prev_size:.2f} → {curr_size:.2f}")

    prev_bids, prev_asks = bids, asks

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌 Hull Moving Average Crossover – Cтратегия пересечения HMA🧑‍💻

Суть индикатора:🚀

Hull Moving Average (HMA) — это гладкая и быстро реагирующая скользящая средняя, разработанная Аланом Халлом.
Она снижает запаздывание обычных MA (например, EMA) и при этом остаётся плавной.

Пересечение двух HMA с разными периодами может использоваться как сигнал к входу или выходу.

Сигналы стратегии:🛠️

- Buy: HMA_fast пересекает HMA_slow снизу вверх

- Sell: HMA_fast пересекает HMA_slow сверху вниз

import ccxt
import pandas as pd
import numpy as np

def wma(series, period):
    weights = np.arange(1, period + 1)
    return series.rolling(period).apply(lambda prices: np.dot(prices, weights)/weights.sum(), raw=True)

def hma(series, period):
    half = int(period / 2)
    sqrt_p = int(np.sqrt(period))

    wma_half = wma(series, half)
    wma_full = wma(series, period)
    raw = 2 * wma_half - wma_full
    return wma(raw, sqrt_p)

# Данные с Binance
exchange = ccxt.binance()
symbol = "BTC/USDT"
tf = "1h"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=tf, limit=200)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# HMA
df["hma_fast"] = hma(df["close"], 14)
df["hma_slow"] = hma(df["close"], 55)

# Сигналы пересечения
df["signal"] = 0
df.loc[(df["hma_fast"] > df["hma_slow"]) & (df["hma_fast"].shift() <= df["hma_slow"].shift()), "signal"] = 1  # BUY
df.loc[(df["hma_fast"] < df["hma_slow"]) & (df["hma_fast"].shift() >= df["hma_slow"].shift()), "signal"] = -1  # SELL

# Вывод последних сигналов
print(df[["ts", "close", "hma_fast", "hma_slow", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌 Adaptive Stop-Loss Adjuster – Автоматическая адаптация стоп-лосса🧑‍💻

Суть идеи:🛠️

Adaptive Stop-Loss Adjuster — инструмент, который динамически перемещает стоп-лосс в зависимости от:

- волатильности (ATR)

- текущей прибыли

- тренда (EMA, FRAMA и др.)

- времени в сделке

- структуры рынка (локальные минимумы/максимумы)

Цель: 💸 максимизировать удержание прибыли и минимизировать убытки, не выходя слишком рано.

import ccxt
import pandas as pd
import talib

# Настройки
symbol = "BTC/USDT"
timeframe = "1h"
exchange = ccxt.binance()
risk_multiplier = 2.0
entry_price = 27000
position_type = "long"  # или "short"

# Данные
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=100)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["atr"] = talib.ATR(df["high"], df["low"], df["close"], timeperiod=14)

# Последние значения
atr = df["atr"].iloc[-1]
current_price = df["close"].iloc[-1]

# Начальный стоп
if position_type == "long":
    stop = entry_price - risk_multiplier * atr
    new_stop = max(stop, current_price - risk_multiplier * atr)
else:
    stop = entry_price + risk_multiplier * atr
    new_stop = min(stop, current_price + risk_multiplier * atr)

print(f"ATR: {atr:.2f}")
print(f"Начальный стоп: {stop:.2f}")
print(f"Адаптивный стоп: {new_stop:.2f}")

#инструмент

📌 Подпишись  Crypto Python❗️

📌 Chande Momentum Oscillator Strategy – Фильтрация силы движения🧑‍💻

Суть индикатора:🛠️

Chande Momentum Oscillator (CMO) — осциллятор, разработанный Тушаром Чандом, отражает силу направленного движения цены.
Он похож на RSI, но:

- Использует абсолютные значения приростов и спадов

- Колеблется от −100 до +100

- Быстро реагирует на смену импульса

Типовые сигналы:💸

- CMO > +50 → сильный восходящий импульс (возможность входа в лонг)

- CMO < −50 → сильный нисходящий импульс (шорт или избегать лонга)

- CMO между −20 и +20 → флет / слабое движение

- Пересечения нуля → смена направления

import ccxt
import pandas as pd
import talib

# Настройки
exchange = ccxt.binance()
symbol = "BTC/USDT"
timeframe = "1h"
limit = 200

# Получение данных
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Расчёт CMO
df["cmo"] = talib.CMO(df["close"], timeperiod=14)

# Сигналы
df["signal"] = 0
df.loc[df["cmo"] > 50, "signal"] = 1   # Buy
df.loc[df["cmo"] < -50, "signal"] = -1  # Sell

# Вывод последних значений
print(df[["ts", "close", "cmo", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌Volume Profile Range Reversion – Возврат к зоне наибольшей ликвидности (Value Area)🧑‍💻

Суть стратегии:🛠️

Volume Profile отображает, где за определённый период было проторговано наибольшее количество объёма по ценам.
Зона с наибольшей активностью (называемая POC — Point of Control) часто выступает как магнит для цены, особенно в отсутствии тренда.

Стратегия Range Reversion предполагает:🛠️

- Если цена отклонилась от POC, вероятен возврат

- Вход осуществляется на возврат к зоне ликвидности

- Часто используется внутри дня и в боковике

import ccxt
import pandas as pd
import numpy as np

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="15m", limit=300)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Построение volume profile (по ценам close)
bins = np.linspace(df["close"].min(), df["close"].max(), 50)
df["price_bin"] = pd.cut(df["close"], bins)
vp = df.groupby("price_bin")["volume"].sum()
poc_bin = vp.idxmax()
poc_center = poc_bin.mid

# Сигнал: если цена >1% выше или ниже POC — ждать возврат
last_price = df["close"].iloc[-1]
distance = (last_price - poc_center) / poc_center * 100

print(f"POC (центр зоны): {poc_center:.2f}")
print(f"Последняя цена:  {last_price:.2f}")
print(f"Отклонение от POC: {distance:.2f}%")

if abs(distance) > 1:
    print("⚠️ Цена далеко от зоны объёма — возможно возвращение к POC (вход против движения)")
else:
    print("Цена вблизи ликвидности — сигналов нет")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌 ETF vs Futures Arbitrage – Арбитраж между ETF и фьючерсами🧑‍💻

Суть стратегии:🚀

ETF (биржевые фонды) отражают стоимость базового актива (например, BTC через $BITO, ETH через $ETHE), но торгуются на фондовом рынке,
в то время как фьючерсы — на срочном.

В силу разных механизмов ценообразования, между ними может возникать временной дисбаланс, который можно использовать для арбитража.

Риски и особенности:🛠️

- ETF может не совпадать 1:1 с базовым активом

- Комиссии и издержки по шорту (в ETF особенно)

- Требуется доступ к фондовому и фьючерсному рынку одновременно

-Задержки в исполнении или отклонения ликвидности

# Предположим, вы получаете цены из двух источников:
etf_price = 84.00     # цена BITO
futures_price = 84500 # цена BTC фьючерса

# Переводим ETF в "BTC-эквивалент"
btc_per_etf = 0.001   # условно 1 ETF = 0.001 BTC (зависит от структуры фонда)
etf_price_btc = etf_price / btc_per_etf

spread_pct = (etf_price_btc - futures_price) / futures_price * 100

print(f"BITO в BTC: ${etf_price_btc:.2f}")
print(f"BTC Futures: ${futures_price:.2f}")
print(f"Спред: {spread_pct:.2f}%")

if abs(spread_pct) > 1.0:
    print("⚠️ Возможность арбитража между ETF и фьючерсом")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Order Flow Delta Spike Strategy – Стратегия по резким всплескам дельты ордеров🧑‍💻

Суть стратегии:🚀

Delta ордеров — это разница между рыночными ордерами на покупку и продажу за определённый интервал времени.

Delta Spike Strategy строится на обнаружении резких всплесков этой дельты, которые могут свидетельствовать о:

- агрессивных входах крупного игрока,

- начале импульсного движения,

- либо ложном вбросе ликвидности (фейковый импульс).

Ключевые сигналы:💸

- Резкий положительный спайк дельты → сигнал на лонг

-Резкий отрицательный спайк → сигнал на шорт

Подтверждение можно получать от:🧨

- увеличенного объёма

- свечной формации (например, пробой)

- давления из стакана

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
limit = 500

# Получение тиковых сделок
trades = exchange.fetch_trades(symbol, limit=limit)
df = pd.DataFrame(trades)

# Определяем сторону сделки: True = buy, False = sell
df["side"] = df["side"].apply(lambda x: 1 if x == 'buy' else -1)
df["delta"] = df["amount"] * df["side"]

# Агрегируем дельту по минутам
df["ts"] = pd.to_datetime(df["timestamp"], unit="ms")
df.set_index("ts", inplace=True)
delta_per_min = df["delta"].resample("1min").sum()

# Выявляем спайки дельты
z_score = (delta_per_min - delta_per_min.rolling(20).mean()) / delta_per_min.rolling(20).std()
signals = z_score[abs(z_score) > 2]  # только резкие всплески

print(signals.tail())

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Meta-Learning for Strategy Selection – Выбор стратегии под текущий режим рынка с помощью мета-обучения🧑‍💻

Суть идеи:🚀

Meta-learning (мета-обучение) — это подход, при котором модель обучается выбирать или адаптировать другую модель/стратегию в зависимости от контекста.

В трейдинге это используется для:🛠️

- автоматического выбора наиболее эффективной стратегии

- подстраивания под текущий рыночный режим (тренд, флет, высокая волатильность и т.д.)

- повышения устойчивости и адаптивности системы

Как это работает:💸

1. Собирается пул стратегий:

2. Собираются фичи текущего рынка:

3. Модель-маршрутизатор (meta-model):

Обучается по истории, какая стратегия работает в каких условиях

Выдаёт предсказание, какую стратегию применять сейчас

import pandas as pd
from sklearn.ensemble import RandomForestClassifier

# Допустим, у нас есть:
# - данные о рынке (X)
# - и лучшая стратегия, которая дала максимальный профит (y)

# X — фичи рынка
# y — лучшая стратегия (0 = trend, 1 = mean-reversion, 2 = breakout)
df = pd.read_csv("market_regime_features.csv")
X = df[["atr", "volatility", "trend_strength", "rsi", "slope_ema"]]
y = df["best_strategy"]

# Обучение meta-модели
clf = RandomForestClassifier(n_estimators=100)
clf.fit(X, y)

# Текущие рыночные условия
current = pd.DataFrame([{
    "atr": 120,
    "volatility": 0.018,
    "trend_strength": 0.7,
    "rsi": 65,
    "slope_ema": 0.04
}])

# Предсказание
strategy_id = clf.predict(current)[0]
strategies = ["trend", "mean-reversion", "breakout"]
print(f"Рекомендуемая стратегия: {strategies[strategy_id]}")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️

📌Liquidity Heatmap Generator – Генератор тепловой карты ликвидности по ценовым уровням🧑‍💻

Суть инструмента:🛠️

Liquidity Heatmap визуализирует, где в стакане сконцентрирована ликвидность — крупные лимитные заявки на покупку и продажу.

Это позволяет:💸

- Видеть уровни поддержки/сопротивления,

- Предугадывать реакцию цены на крупные кластеры ликвидности,

- Использовать визуально для входов, выходов или фильтра сигналов.

import ccxt
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import time

exchange = ccxt.binance()
symbol = "BTC/USDT"
depth_limit = 100
interval_sec = 2
snapshots = []

print("Сбор snapshot данных стакана...")

for _ in range(30):  # ~1 минута
    depth = exchange.fetch_order_book(symbol, limit=depth_limit)
    bids = {round(price): amount for price, amount in depth["bids"]}
    asks = {round(price): amount for price, amount in depth["asks"]}
    
    combined = bids.copy()
    combined.update(asks)
    snapshots.append(combined)
    
    time.sleep(interval_sec)

# Объединяем данные
all_prices = sorted(set().union(*[snap.keys() for snap in snapshots]))
heatmap_data = []

for snap in snapshots:
    row = []
    for price in all_prices:
        row.append(snap.get(price, 0))
    heatmap_data.append(row)

heatmap = np.array(heatmap_data).T  # строки — цены, столбцы — время

# Построение тепловой карты
plt.figure(figsize=(12, 6))
plt.imshow(heatmap, aspect="auto", cmap="hot", origin="lower")
plt.yticks(ticks=np.arange(len(all_prices))[::10], labels=all_prices[::10])
plt.xlabel("Время (шаги)")
plt.ylabel("Цена")
plt.title("Тепловая карта ликвидности BTC/USDT")
plt.colorbar(label="Объём")
plt.tight_layout()
plt.show()

#инструмент

📌 Подпишись  Crypto Python❗️

📌SuperTrend Indicator Strategy – Следование за трендом с динамическим уровнем🧑‍💻

Суть индикатора:🛠️

SuperTrend — трендовый индикатор, который строится на основе:

- ATR (среднего истинного диапазона) — измеряет волатильность,

- цены закрытия — для направления сигнала.

Он рисует динамический уровень поддержки/сопротивления, который перерисовывается при смене тренда.

Используется для:🧨

- входа в направлении тренда,
- удержания позиции,
- выставления трейлинг-стопа.

Сигналы:💸

- Цена пересекает SuperTrend снизу вверх → сигнал на покупку

- Цена пересекает SuperTrend сверху вниз → сигнал на продажу

import ccxt
import pandas as pd
import ta

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=200)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Параметры SuperTrend
atr_period = 10
multiplier = 3.0

# Расчёт ATR
atr = ta.volatility.AverageTrueRange(high=df["high"], low=df["low"], close=df["close"], window=atr_period).average_true_range()
hl2 = (df["high"] + df["low"]) / 2
df["upperband"] = hl2 + (multiplier * atr)
df["lowerband"] = hl2 - (multiplier * atr)

# Логика SuperTrend
supertrend = []
direction = []
for i in range(len(df)):
    if i == 0:
        supertrend.append(df["upperband"][i])
        direction.append(1)
    else:
        if df["close"][i] > supertrend[i-1]:
            supertrend.append(df["lowerband"][i])
            direction.append(1)
        elif df["close"][i] < supertrend[i-1]:
            supertrend.append(df["upperband"][i])
            direction.append(-1)
        else:
            supertrend.append(supertrend[i-1])
            direction.append(direction[i-1])

df["supertrend"] = supertrend
df["trend"] = direction

# Сигналы
df["signal"] = 0
df.loc[(df["trend"] == 1) & (df["trend"].shift(1) == -1), "signal"] = 1   # Покупка
df.loc[(df["trend"] == -1) & (df["trend"].shift(1) == 1), "signal"] = -1  # Продажа

# Вывод последних сигналов
print(df[["ts", "close", "supertrend", "trend", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️

📌Schaff Trend Cycle Strategy – Быстрые сигналы на основе MACD и рыночных циклов🧑‍💻

Суть индикатора:🛠️

Schaff Trend Cycle (STC) — это модифицированная версия MACD, разработанная Дугом Шаффом, которая сочетает:

- трендовые свойства MACD,

- фильтрацию через цикличность рынка (с помощью двойного применения стохастика).

В результате получается более быстрый и точный индикатор, чем MACD, с меньшим запаздыванием.

Основные сигналы STC:💸

- STC поднимается выше 25 или 50 → сигнал на покупку

- STC опускается ниже 75 или 50 → сигнал на продажу

- Также используются пересечения порогов и дивергенции как подтверждение

import ccxt
import pandas as pd
import numpy as np
import ta

# Получение данных
exchange = ccxt.binance()
symbol = "BTC/USDT"
ohlcv = exchange.fetch_ohlcv(symbol, timeframe="1h", limit=200)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Шаг 1: MACD
macd_line = ta.trend.macd(df["close"], window_slow=26, window_fast=12)
macd_signal = ta.trend.macd_signal(df["close"], window_slow=26, window_fast=12, window_sign=9)
macd_hist = macd_line - macd_signal

# Шаг 2: Стохастик от MACD
lowest = macd_hist.rolling(window=10).min()
highest = macd_hist.rolling(window=10).max()
stoch = 100 * (macd_hist - lowest) / (highest - lowest + 1e-9)

# Шаг 3: Стохастик от стохастика (фильтр циклов)
stc = stoch.rolling(window=3).mean()

df["stc"] = stc

# Генерация сигналов
df["signal"] = 0
df.loc[(df["stc"] > 25) & (df["stc"].shift() <= 25), "signal"] = 1  # Buy
df.loc[(df["stc"] < 75) & (df["stc"].shift() >= 75), "signal"] = -1 # Sell

# Вывод последних сигналов
print(df[["ts", "close", "stc", "signal"]].tail(10))

#индикатор

📌 Подпишись  Crypto Python❗️