📌Net Unrealized Profit/Loss (NUPL) Strategy – Торговля по фазам метрики NUPL🧑‍💻

Что такое NUPL:🧨

NUPL (Net Unrealized Profit/Loss) — это ончейн-метрика, показывающая соотношение нереализованной прибыли и убытков всех участников сети.

> NUPL = (Market Cap – Realized Cap) / Market Cap

Если NUPL близок к 1 → большинство в прибыли (рынок перегрет)

Если NUPL близок к 0 или < 0 → большинство в убытке (капитуляция/дно)

Принцип стратегии:🛠️

- Мониторим значение NUPL, обновляемое ежедневно (с источников вроде Glassnode)

- Действуем при смене фазы (например, когда NUPL переходит из страха в надежду)

- Вход/выход сопровождается фильтром по цене/технике (например, пересечение EMA)

import os
import requests
import pandas as pd
from datetime import datetime
from dotenv import load_dotenv

load_dotenv()
API_KEY = os.getenv("GLASSNODE_API_KEY")

def get_nupl(asset="BTC", currency="USD"):
    url = "https://api.glassnode.com/v1/metrics/market/nupl"
    params = {
        "a": asset,
        "api_key": API_KEY,
        "i": "24h"
    }

    r = requests.get(url, params=params)
    if r.status_code != 200:
        raise Exception(f"Ошибка при запросе: {r.status_code}")

    data = pd.DataFrame(r.json())
    data["t"] = pd.to_datetime(data["t"], unit="s")
    data.set_index("t", inplace=True)
    return data.rename(columns={"v": "nupl"})

def classify_phase(nupl_val: float) -> str:
    if nupl_val > 0.75:
        return "🚨 Эйфория — фиксируем прибыль или шортим"
    elif nupl_val > 0.5:
        return "⚠️ Оптимизм — держим, но осторожно"
    elif nupl_val > 0.25:
        return "🟡 Надежда — можно входить"
    elif nupl_val > 0:
        return "🔵 Страх — фаза накопления"
    else:
        return "🟢 Крайний страх — дно, агрессивная покупка"

def main():
    df = get_nupl()
    today = df.iloc[-1]
    nupl_val = today["nupl"]
    date = today.name.strftime("%Y-%m-%d")

    print(f"[{date}] NUPL: {nupl_val:.4f}")
    print(classify_phase(nupl_val))

if __name__ == "__main__":
    main()

#инструмент

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

📌Volatility Arbitrage with Options – Арбитраж на расхождении implied и realized волатильности🧑‍💻

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

Volatility Arbitrage — это рыночно-нейтральная стратегия, основанная на торговле ожиданиями волатильности.

Суть:🧨

> Покупаешь или продаёшь волатильность через опционы, если implied volatility (IV) сильно отличается от realized volatility (RV) базового актива.

Ключевые понятия:💻

Implied Volatility (IV) Ожидаемая рынком волатильность (в цене опциона)

Realized Volatility (RV) Фактическая историческая волатильность (напр. 30д)

Торговая логика:💸

IV ≫ RV (опционы переоценены) Продавать волатильность (short straddle/strangle)

RV ≫ IV (опционы недооценены) Покупать волатильность (long straddle/strangle)

import ccxt
import pandas as pd
import numpy as np

exchange = ccxt.binance()
ohlcv = exchange.fetch_ohlcv("BTC/USDT", "1d", limit=60)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])

# Реализованная волатильность (30д)
returns = df["close"].pct_change()
rv = returns.rolling(window=30).std() * np.sqrt(365)

print(f"Realized Volatility (30d): {rv.iloc[-1]:.2%}")

#арбитраж

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

📌Impulse Candle Detector – стратегия по импульсным свечам🧑‍💻

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

Импульсная свеча — это бар, который резко выделяется по длине тела и объёму.
Часто такая свеча указывает на:

- старт сильного движения,

- пробой уровня,

- ликвидации или вход крупного игрока.

Цель стратегии🚀 — обнаружить такие свечи и входить в направлении импульса или ждать отката.

Критерии импульсной свечи:💸

- Длина тела > 2× среднего за N свечей

- Объём выше среднего

- Тело ≥ 60% от всего диапазона (не просто хвост)

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "5m", limit=100),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Расчёт метрик
df["body"] = abs(df["close"] - df["open"])
df["range"] = df["high"] - df["low"]
df["body_ratio"] = df["body"] / df["range"]
df["body_avg"] = df["body"].rolling(20).mean()
df["vol_avg"] = df["volume"].rolling(20).mean()

# Импульс = длинное тело + высокая плотность + объём выше среднего
df["impulse"] = (df["body"] > 2 * df["body_avg"]) & \
                (df["body_ratio"] > 0.6) & \
                (df["volume"] > df["vol_avg"])

# Последние сигналы
signals = df[df["impulse"]].tail(5)
print("Импульсные свечи:")
print(signals[["ts", "open", "close", "volume"]])

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

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

📌VWAP Bounce Strategy – Отскок от VWAP в активных сессиях🧑‍💻

Суть:🛠️

VWAP (Volume Weighted Average Price) — это ключевой уровень для алгоритмической и институциональной торговли.

> Цена, приближающаяся к VWAP после импульса, часто отскакивает от него — особенно в EU и US сессии.

Условия входа:💸

- Цена приближается к VWAP менее чем на X% от VWAP
- Цена ранее отклонялась от VWAP > Y%
- Только в активные часы (например, 10:00–19:00 UTC)

import ccxt
import pandas as pd
from datetime import datetime

# Настройки
symbol = "BTC/USDT"
timeframe = "5m"
threshold_pct = 0.2  # % допустимого приближения к VWAP

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

# Расчёт VWAP
df["tp"] = (df["high"] + df["low"] + df["close"]) / 3
df["vwap_num"] = (df["tp"] * df["volume"]).cumsum()
df["vwap_den"] = df["volume"].cumsum()
df["vwap"] = df["vwap_num"] / df["vwap_den"]

# Сигнал: близость к VWAP + импульс ранее
current = df.iloc[-1]
previous = df.iloc[-10]

price = current["close"]
vwap = current["vwap"]
delta = abs(price - vwap) / vwap * 100
impulse = abs(previous["close"] - previous["vwap"]) / previous["vwap"] * 100

# Проверка времени
now_utc = datetime.utcnow().time()
is_session = now_utc >= datetime.strptime("10:00", "%H:%M").time() and \
             now_utc <= datetime.strptime("19:00", "%H:%M").time()

print("=" * 50)
print(f"[{current['ts']}] VWAP Bounce Monitor")
print(f"Цена: {price:.2f} | VWAP: {vwap:.2f} | Δ: {delta:.2f}% | Импульс до: {impulse:.2f}%")

if delta < threshold_pct and impulse > 0.5 and is_session:
    print("✅ Потенциальный отскок от VWAP! Рассмотреть вход.")
else:
    print("Нет условий для сигнала.")

print("=" * 50)

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

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

📌Session Range Breakout – стратегия на пробой диапазона торговой сессии🧑‍💻

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

Рынки часто "просыпаются" на стыке торговых сессий (Европа → США).
Если цена долгое время торговалась в узком диапазоне, пробой этого диапазона на высоком объёме — надёжный импульсный сигнал.

Цель стратегии — найти утренний флэт и входить при его пробое.🧨

Условия входа:💸

Формируется диапазон из N свечей (например, первые 3 свечи сессии)

- Объём растёт

- Цена пробивает high/low диапазона

- Вход в сторону пробоя

- Стоп — за границей диапазона, тейк — фиксированный R:R или трейлинг

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "5m", limit=100),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Формируем диапазон первых 3 свечей (например, с 07:00 UTC)
session_start = df.between_time("07:00", "07:15")
session_high = session_start["high"].max()
session_low = session_start["low"].min()
volume_avg = df["volume"].rolling(20).mean()

# Последняя свеча
current = df.iloc[-1]
signal = None

if current["volume"] > volume_avg.iloc[-1]:
    if current["close"] > session_high:
        signal = "BUY breakout"
    elif current["close"] < session_low:
        signal = "SELL breakdown"

# Алерт
print(f"Диапазон: {session_low:.2f} — {session_high:.2f}")
print(f"Цена: {current['close']:.2f}, Объём: {current['volume']:.2f}")
print("Сигнал:", signal or "нет")

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

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

📌Session Labels Generator – автоматическая разметка торговых сессий по времени🧑‍💻

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

Многие стратегии зависят от времени суток: азиатская консолидация, европейский импульс, американский объем.
Этот инструмент автоматически помечает для каждой свечи, в какой сессии она была сформирована.

Цель — использовать это как фильтр или визуальный маркер в стратегии/графике/анализе.🧨

Как использовать:💻

- Фильтровать сигналы: например, торговать только в US-сессии

- Выделять фазы по сессиям (флэт Азия → пробой Европа)

- Построить тепловую карту: в какие часы актив выше/ниже

- Создать отдельную стратегию "Session Breakout"

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "1h", limit=100),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")
df["hour"] = df["ts"].dt.hour

# Функция определения сессии
def label_session(hour):
    if 0 <= hour < 8:
        return "Asia"
    elif 7 <= hour < 15:
        return "Europe"
    elif 13 <= hour < 21:
        return "US"
    else:
        return "Overlap/Other"

df["session"] = df["hour"].apply(label_session)

# Пример вывода
print(df[["ts", "close", "session"]].tail(10))

#инструмент

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

📌Local Extrema Scanner – поиск локальных минимумов и максимумов в реальном времени🧑‍💻

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

Местные экстремумы — это точки, где цена останавливает тренд и временно разворачивается.

Используются для:💸

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

- фиксации прибыли,

- подтверждения дивергенций,

- входа в контртренд.

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "15m", limit=100),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Параметры
window = 3

# Поиск локальных максимумов и минимумов
df["local_max"] = df["high"][(df["high"].shift(window) < df["high"]) &
                             (df["high"].shift(-window) < df["high"])]
df["local_min"] = df["low"][(df["low"].shift(window) > df["low"]) &
                            (df["low"].shift(-window) > df["low"])]

# Последние точки
extrema = df[["ts", "local_max", "local_min"]].dropna()
print("Локальные экстремумы:")
print(extrema.tail(5))

#инструмент

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

📌Candle Pressure Strategy – стратегия на основе "давления тела свечи"🧑‍💻

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

Каждая свеча содержит скрытую информацию о силе и направлении движения — особенно, если рассчитать:

> Насколько тело свечи жёстко прижато к high или low → это и есть давление, сигнализирующее о вероятном продолжении.

Цель стратегии — входить в сторону свечей с сильным давлением и подтверждением объёма.

Условия сигнала:🧨

- Длина тела свечи ≥ 2× среднего

- Тело «прижато» к high (лонг) или low (шорт)

- Объём выше среднего

- Свеча закрылась ближе к high/low ≥ 80%

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "5m", limit=100),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

df["body"] = abs(df["close"] - df["open"])
df["range"] = df["high"] - df["low"]
df["body_avg"] = df["body"].rolling(20).mean()
df["vol_avg"] = df["volume"].rolling(20).mean()
df["pressure_long"] = (df["close"] - df["low"]) / df["range"]
df["pressure_short"] = (df["high"] - df["close"]) / df["range"]

# Условия сигнала
df["signal_long"] = (
    (df["body"] > 2 * df["body_avg"]) &
    (df["volume"] > df["vol_avg"]) &
    (df["pressure_long"] > 0.8)
)

df["signal_short"] = (
    (df["body"] > 2 * df["body_avg"]) &
    (df["volume"] > df["vol_avg"]) &
    (df["pressure_short"] > 0.8)
)

# Вывод
signals = df[(df["signal_long"] | df["signal_short"])]
signals["direction"] = signals.apply(
    lambda x: "LONG" if x["signal_long"] else "SHORT", axis=1
)
print(signals[["ts", "close", "direction"]].tail(5))

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

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

📌Daily Range Analyzer – анализ суточного диапазона актива🧑‍💻

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

Инструмент рассчитывает дневной диапазон движения (high – low) и сравнивает его:

- со средним значением за последние N дней,

- определяет, насколько день "активен" или "затухший",

помогает:🚀

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

- находить дни для пробойных стратегий,

- отслеживать приближение к границам дневного диапазона.

import ccxt
import pandas as pd

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

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

# Расчёт диапазона
df["range"] = df["high"] - df["low"]
df["avg_range"] = df["range"].rolling(14).mean()

# Текущий день (если запуск в реальном времени — заменить на 1h и группировку)
current_range = df.iloc[-1]["range"]
avg_range = df["avg_range"].iloc[-1]
activity = current_range / avg_range * 100

print(f"Текущий дневной диапазон: {current_range:.2f}")
print(f"Средний за 14 дней:       {avg_range:.2f}")
print(f"Активность дня:           {activity:.1f}%")

if activity > 130:
    print("⚠️ Слишком активный день — возможен откат.")
elif activity < 70:
    print("⏳ Затухший день — вероятен пробой позже.")
else:
    print("✅ День в пределах нормы — можно использовать стандартные сигналы.")

#инструмент

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

📌Spread Trap Strategy – ловушка на резкое сужение спреда🧑‍💻

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

На низколатентных биржах (Binance, Bybit и др.) спред между bid/ask почти всегда минимален.
Но иногда, перед внезапным движением, крупные участники:

> искусственно сужают спред, создавая иллюзию "тишины", после чего мгновенно проламывают рынок в одну сторону.

Цель стратегии — отследить аномальное сужение спреда + рост дельты → и войти на пробой первым.🚀

Признаки ловушки:🧨

- Спред < 0.01% (искусственно зажат)

- Объём в лимитах по обе стороны внезапно увеличивается

- После нескольких секунд → всплеск дельты или объёма → движение

Алгоритм стратегии:💻

1. Постоянно читаем стакан

2. Если спред стал очень мал (например, < 0.05%) и объём по bid/ask резко вырос

3. Ожидаем всплеска объёма или односторонней агрессии (delta > X)

4. Вход в сторону импульса (обычно туда, где слабее плотность)

import json
import websockets
import asyncio

# Настройки
symbol = "btcusdt"
spread_threshold_pct = 0.02  # макс. допустимый спред (%)
volume_threshold = 100       # суммарный объём в 5 уровнях с обеих сторон

# Подключение к Binance WebSocket depth stream
url = f"wss://stream.binance.com:9443/ws/{symbol}@depth5@100ms"

async def monitor_orderbook():
    async with websockets.connect(url) as websocket:
        print(f"Подключено к Binance. Отслеживается пара {symbol.upper()}")
        while True:
            response = await websocket.recv()
            data = json.loads(response)

            bids = [(float(p), float(q)) for p, q in data["bids"]]
            asks = [(float(p), float(q)) for p, q in data["asks"]]

            if not bids or not asks:
                continue

            top_bid = bids[0][0]
            top_ask = asks[0][0]
            spread_pct = (top_ask - top_bid) / ((top_ask + top_bid) / 2) * 100

            total_bid_vol = sum([q for _, q in bids])
            total_ask_vol = sum([q for _, q in asks])

            if spread_pct < spread_threshold_pct and total_bid_vol > volume_threshold and total_ask_vol > volume_threshold:
                print("\n=== Обнаружена ловушка ликвидности ===")
                print(f"Спред: {spread_pct:.4f}%")
                print(f"Объём BID (5 ур.): {total_bid_vol:.2f}")
                print(f"Объём ASK (5 ур.): {total_ask_vol:.2f}")
                print(f"Цена BID: {top_bid:.2f} | ASK: {top_ask:.2f}")
                print("Сигнал: возможный резкий импульс\n")

# Запуск
asyncio.run(monitor_orderbook())

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

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

📌Hourly Volatility Map – карта волатильности по часам суток🧑‍💻

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

Этот инструмент помогает определить:

> В какие часы дня актив наиболее волатилен,
и когда лучше всего входить в сделки или избегать рынка.

Актуально для внутридневных стратегий, особенно скальпинга, breakout и сессионной торговли.

Что делает инструмент:🚀

- Берёт исторические 1h-свечи

- Вычисляет диапазон (high – low) каждой свечи

- Группирует по часу (0–23 UTC)

- Строит таблицу или график волатильности по часам

import ccxt
import pandas as pd

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

ohlcv = exchange.fetch_ohlcv(symbol, "1h", limit=720)  # 30 дней по 24 часа
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")
df["hour"] = df["ts"].dt.hour
df["range"] = df["high"] - df["low"]

# Группировка по часу
vol_by_hour = df.groupby("hour")["range"].mean().reset_index()
vol_by_hour.columns = ["Hour (UTC)", "Avg Range ($)"]

print("Средняя волатильность по часу (UTC):")
print(vol_by_hour.sort_values("Avg Range ($)", ascending=False))

#инструмент

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

📌Candle Stack Breakout – стратегия пробоя "свечной стопки"🧑‍💻

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

Когда рынок несколько свечей подряд идёт вбок, но каждая свеча имеет узкое тело и почти одинаковые high/low, это называется "свечная стопка" — это признак сжатия и накопления.

> Стратегия ждёт пробой такой стопки вверх или вниз и входит в направлении выхода.

Критерии входа:🚀

Последние N свечей (например, 4–6)

- маленькие тела

- похожие high/low (разница < X%)

- Объём сжимается

- Цена пробивает high или low стопки

- Подтверждение по объёму на пробойной свече

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "15m", limit=100),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Последние 6 свечей
stack = df.iloc[-7:-1]
current = df.iloc[-1]

# Проверка "стопки"
stack_bodies = abs(stack["close"] - stack["open"])
body_cond = (stack_bodies < stack_bodies.mean() * 1.2).all()
hl_range = stack["high"].max() - stack["low"].min()
hl_cond = hl_range / stack["close"].mean() < 0.005  # < 0.5%

# Пробой
break_up = current["close"] > stack["high"].max()
break_down = current["close"] < stack["low"].min()

if body_cond and hl_cond:
    print("Сформирована свечная стопка:")
    print(f"Диапазон: {stack['low'].min():.2f} – {stack['high'].max():.2f}")
    if break_up:
        print("✅ Пробой вверх — ЛОНГ")
    elif break_down:
        print("✅ Пробой вниз — ШОРТ")
    else:
        print("Пробоя пока нет — наблюдение")
else:
    print("Нет признаков накопления")

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

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

📌Daily Bias Tracker – отслеживание дневного смещения рынка🧑‍💻

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

Инструмент оценивает:🧨

> Идёт ли день по направлению утреннего импульса (трендовый день)
или день меняет направление (контртренд, флет, ложный пробой)

Используется как фильтр для внутридневных стратегий — помогает избежать входа против дневного импульса и ловить разворот.

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
tf = "1h"

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

# Утренний диапазон (например, 07:00–10:00 UTC)
morning = df[df["hour"].between(7, 10)]
high_range = morning["high"].max()
low_range = morning["low"].min()

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

print(f"Диапазон утра: {low_range:.2f} – {high_range:.2f}")
print(f"Текущая цена: {current_price:.2f}")

if current_price > high_range:
    print("📈 Дневной импульс ВВЕРХ — избегать шортов, искать лонги")
elif current_price < low_range:
    print("📉 Дневной импульс ВНИЗ — избегать лонгов, искать шорты")
else:
    print("🔄 Цена внутри диапазона — флет, лучше подождать")

#инструмент

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

📌"Liquidity Flip Trap" – стратегия на смену плотности в стакане🧑‍💻

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

На фьючерсных рынках часто наблюдается поведение, при котором:

> Плотность в стакане резко меняется местами (bid → ask или наоборот)
Это может быть ловушкой или сигналом о переходе рыночной инициативы.

Пример:💸

Была крупная плотность на BID — поддержка.
Через 10–30 секунд она исчезает и появляется на ASK — это сигнал на разворот и шорт.

Стратегия:🚀

1. Мониторим объёмы в 3–5 верхних уровней стакана (bid/ask)

2. Ищем резкий flip:

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

- появляется аналогичная на противоположной стороне

3. Подтверждаем дельтой или первой рыночной агрессией

4. Вход в сторону flip-сигнала

import ccxt
import time

exchange = ccxt.binance()

symbol = "BTC/USDT"
depth_limit = 5  # сколько уровней стакана отслеживать
interval_sec = 5  # частота опроса
volume_threshold = 100  # минимум объёма в одной из сторон

prev_bid_volume = None
prev_ask_volume = None

print(f"Мониторинг ликвидности для {symbol} (flip trap)...")

while True:
    orderbook = exchange.fetch_order_book(symbol, limit=depth_limit)
    bids = orderbook["bids"]
    asks = orderbook["asks"]

    total_bid_volume = sum([v for _, v in bids])
    total_ask_volume = sum([v for _, v in asks])

    # Сравнение с предыдущим состоянием
    if prev_bid_volume and prev_ask_volume:
        bid_flip = prev_bid_volume > volume_threshold and total_bid_volume < volume_threshold and total_ask_volume > volume_threshold
        ask_flip = prev_ask_volume > volume_threshold and total_ask_volume < volume_threshold and total_bid_volume > volume_threshold

        if bid_flip:
            print("⚠️ Flip: крупная ликвидность исчезла с BID и появилась на ASK → возможный ШОРТ")
        elif ask_flip:
            print("⚠️ Flip: крупная ликвидность исчезла с ASK и появилась на BID → возможный ЛОНГ")

    # Обновляем
    prev_bid_volume = total_bid_volume
    prev_ask_volume = total_ask_volume

    time.sleep(interval_sec)

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

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

📌Auto Range Box – автоматическое построение ключевых зон консолидации🧑‍💻

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

Инструмент ищет горизонтальные диапазоны, где цена долго стояла в узком коридоре.

> Эти зоны (range boxes) часто становятся базой для будущих пробоев или откатов.

Цель — автоматически определить такие зоны и использовать их:💸

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

- как фильтры для входа/выхода,

- как цели (TP) или стоп-зоны.

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "15m", limit=200),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Параметры диапазона
box_size = 12  # кол-во свечей в диапазоне
volatility_limit = 0.6  # % диапазона от цены

boxes = []

for i in range(len(df) - box_size):
    window = df.iloc[i:i + box_size]
    high = window["high"].max()
    low = window["low"].min()
    center = window["close"].mean()
    width_pct = (high - low) / center * 100

    if width_pct < volatility_limit:
        boxes.append({
            "start": window["ts"].iloc[0],
            "end": window["ts"].iloc[-1],
            "low": low,
            "high": high,
            "width_pct": width_pct
        })

# Вывод последних 3 боксов
print("Найденные консолидации (узкие диапазоны):")
for box in boxes[-3:]:
    print(f"{box['start']} → {box['end']} | {box['low']:.2f} – {box['high']:.2f} ({box['width_pct']:.2f}%)")

#инструмент

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

📌"Failed High/Low Reversal" – стратегия разворота после ложного экстремума🧑‍💻

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

Когда рынок обновляет максимум/минимум, но не удерживает уровень, это часто признак ловушки.

> Такие “неудачные” пробои дают сильные разворотные сигналы, особенно на младших ТФ (5m, 15m).

Типичный сценарий:🚀

- Цена обновляет дневной high/low

- Следующая свеча возвращается внутрь диапазона

- Вход против пробоя, стоп — за экстремум

Условия стратегии:🧨

1. Уровни: дневной high/low (или экстремум за последние N часов)

2. Свеча пробивает уровень

3. Следующая свеча закрывается обратно внутри диапазона

4. Объём на пробойной свече выше среднего (подтверждение ликвидаций/паники)

5. Вход на открытии третьей свечи в обратную сторону

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "15m", limit=100),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Диапазон последних 20 свечей
range_high = df["high"][-20:-1].max()
range_low = df["low"][-20:-1].min()

# Последние две свечи
prev = df.iloc[-2]
curr = df.iloc[-1]

long_fail = (
    prev["high"] > range_high and
    curr["close"] < range_high and
    prev["volume"] > df["volume"].rolling(20).mean().iloc[-2]
)

short_fail = (
    prev["low"] < range_low and
    curr["close"] > range_low and
    prev["volume"] > df["volume"].rolling(20).mean().iloc[-2]
)

print(f"Диапазон: {range_low:.2f} – {range_high:.2f}")
if long_fail:
    print("🔻 ЛОЖНЫЙ ПРОБОЙ ВВЕРХ → СИГНАЛ НА ШОРТ")
elif short_fail:
    print("🔺 ЛОЖНЫЙ ПРОБОЙ ВНИЗ → СИГНАЛ НА ЛОНГ")
else:
    print("Нет ложного пробоя — без сигнала")

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

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

📌Realized Range Consistency Tracker – измеритель стабильности дневного диапазона🧑‍💻

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

Многие стратегии (breakout, trend-following) работают лучше, когда у актива стабильный или расширяющийся дневной диапазон.

> Этот инструмент оценивает, насколько предсказуемо актив “ходит” каждый день, и позволяет:

- понять, когда актив теряет волатильность,

- выявить фазы сжатия перед пробоем,

- фильтровать "бесполезные" дни.

Что считает инструмент:🧨

- Средний дневной диапазон (high – low)

- Отклонение диапазона от среднего

- Коэффициент вариации: std / mean, как показатель стабильности

- Дни с экстремально узким или широким диапазоном (аномалии)

import ccxt
import pandas as pd

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

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

# Расчёт диапазонов
df["range"] = df["high"] - df["low"]

# Статистика
mean_range = df["range"].mean()
std_range = df["range"].std()
cv = std_range / mean_range * 100

print(f"Средний дневной диапазон: {mean_range:.2f}")
print(f"Отклонение: {std_range:.2f}")
print(f"Коэффициент вариации: {cv:.2f}%")

if cv < 20:
    print("✅ Стабильный диапазон — стратегия на диапазонах будет надёжной")
elif cv > 40:
    print("⚠️ Повышенная нестабильность — стоит использовать гибкие стопы или избегать входов")
else:
    print("ℹ️ Средняя волатильность — возможны фазы перехода")

#инструмент

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

📌"Mid-Bar Rejection Strategy" – стратегия по реакции в середине свечи🧑‍💻

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

Во время сильного движения трейдеры часто заходят "в догонку", но рынок:

> достигает середины предыдущей импульсной свечи и разворачивается.
Это зона, где часто находятся отложенные ордера или срабатывают контртрендовые заявки.

Цель стратегии — входить при отскоке от середины предыдущей сильной свечи.🧨

Условия входа:💸

1. Предыдущая свеча — импульсная (длинное тело, высокий объём)

2. Цена возвращается к её середине (midpoint)

3. В текущей свече — отбой от этой зоны (пинбар, хвост, слабый объём)

4. Вход в сторону первоначального импульса

5. Стоп — за хвост текущей свечи, тейк — по R:R или ближайшему уровню

import ccxt
import pandas as pd

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

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

# Предыдущая свеча
prev = df.iloc[-2]
curr = df.iloc[-1]

# Импульсная свеча: длинное тело и высокий объём
body = abs(prev["close"] - prev["open"])
range_ = prev["high"] - prev["low"]
vol_ok = prev["volume"] > df["volume"].rolling(20).mean().iloc[-2]
body_ok = body > range_ * 0.6

midpoint = (prev["open"] + prev["close"]) / 2

# Условия отката к середине и реакция
touched = curr["low"] <= midpoint <= curr["high"]
rejected = (curr["close"] > midpoint) if prev["close"] > prev["open"] else (curr["close"] < midpoint)

if body_ok and vol_ok and touched and rejected:
    direction = "LONG" if prev["close"] > prev["open"] else "SHORT"
    print(f"🔁 Отбой от середины импульсной свечи → Сигнал на {direction}")
    print(f"Уровень входа (midpoint): {midpoint:.2f}")
else:
    print("Нет сигнала по Mid-Bar Rejection")

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

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

📌"Open Range Fakeout" – стратегия на ложный пробой утреннего диапазона🧑‍💻

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

Первые 30–60 минут торговой сессии формируют утренний диапазон (Open Range).

> Часто рынок имитирует пробой вверх или вниз, привлекая трейдеров в ловушку,
а затем разворачивается в противоположную сторону — туда, где реальная ликвидность.

Цель стратегии — войти в разворот после ложного пробоя утреннего диапазона💸

Условия:🚀

1. Строим диапазон по первым 2–4 свечам (например, 5m × 4 = 20 минут)

2. Ждём пробоя вверх или вниз

3. Следующая свеча закрывается обратно внутрь диапазона

4. Входим в противоположную сторону пробоя

5. Стоп — за экстремум ложного пробоя, тейк — внутрь диапазона или в 1.5× ширину

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
tf = "5m"

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

# Формируем Open Range по первым 4 свечам (пример — 20 минут)
open_range = df.iloc[:4]
high_range = open_range["high"].max()
low_range = open_range["low"].min()

# Последние 2 свечи
prev = df.iloc[4]
curr = df.iloc[5]

# Условия ложного пробоя вверх
fake_up = (
    prev["high"] > high_range and
    curr["close"] < high_range
)

# Ложный пробой вниз
fake_down = (
    prev["low"] < low_range and
    curr["close"] > low_range
)

print(f"Open Range: {low_range:.2f} – {high_range:.2f}")
if fake_up:
    print("🔻 Ложный пробой вверх — сигнал на ШОРТ")
elif fake_down:
    print("🔺 Ложный пробой вниз — сигнал на ЛОНГ")
else:
    print("Нет сигнала — диапазон не пробит или пробой подтверждён")

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

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

📌Intraday Range Compression Detector – детектор внутридневного сжатия волатильности🧑‍💻

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

Перед сильными движениями рынок часто "сжимается" — диапазон между high/low уменьшается,
объём падает, волатильность падает. Это состояние часто предшествует импульсу или пробою.

> Этот инструмент отслеживает внутридневное сжатие диапазона и даёт сигнал,
когда оно достигает аномально низких значений по сравнению с предыдущими днями.

Что делает инструмент:💻

- Сравнивает текущий дневной диапазон с историческим (например, 10–20 последних дней)

- Считает % сжатия относительно среднего

- Выдаёт сигнал, если сжатие сильное (например, < 50% нормы)

import ccxt
import pandas as pd

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

# Получаем 1h свечи, группируем по дню
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "1h", limit=240),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")
df["date"] = df["ts"].dt.date

daily = df.groupby("date").agg({
    "high": "max",
    "low": "min"
})
daily["range"] = daily["high"] - daily["low"]

# Анализ последнего дня
current_range = daily["range"].iloc[-1]
avg_range = daily["range"].iloc[:-1].mean()
compression = current_range / avg_range * 100

print(f"Сегодняшний диапазон: {current_range:.2f}")
print(f"Средний диапазон:     {avg_range:.2f}")
print(f"Сжатие диапазона:     {compression:.1f}%")

if compression < 50:
    print("⚠️ Внутридневное сжатие! Возможен пробой или сильный импульс.")
else:
    print("Диапазон в норме — рынок активен.")

#инструмент

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

📌"Liquidity Gap Sniper" — стратегия входа в незаполненные ценовые разрывы🧑‍💻

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

Иногда в течение дня возникает резкое движение, оставляющее после себя
“пустую” область в стакане (или на графике) — почти без касания цен.

> Такие зоны рынок часто возвращается закрыть, особенно на умеренной волатильности.

Цель стратегии — войти в сторону “заполнения” этой зоны,
ориентируясь на структуру предыдущих свечей и объёмов.

Что считается "gap":🚀

- 2 свечи подряд, где минимум текущей свечи выше максимума предыдущей (или наоборот)

- Расстояние между свечами больше X% (например, 0.3%)

- Отсутствие свечей, перекрывающих этот диапазон в течение N свечей

Условия входа:🧨

1. Обнаружен gap (разрыв между свечами)

2. Цена приближается к gap, но ещё не закрыла его полностью

3. Вход на возврат в gap, с целью закрытия

4. Стоп — за границу gap или за ближайший экстремум

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = "BTC/USDT"
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "5m", limit=100),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

gaps = []

for i in range(1, len(df)):
    prev = df.iloc[i - 1]
    curr = df.iloc[i]

    # Проверка на gap вверх
    if curr["low"] > prev["high"]:
        gap_size = curr["low"] - prev["high"]
        gap_pct = gap_size / prev["high"] * 100
        if gap_pct > 0.3:
            gaps.append({
                "type": "up",
                "from": prev["high"],
                "to": curr["low"],
                "timestamp": curr["ts"]
            })

    # Gap вниз
    if curr["high"] < prev["low"]:
        gap_size = prev["low"] - curr["high"]
        gap_pct = gap_size / prev["low"] * 100
        if gap_pct > 0.3:
            gaps.append({
                "type": "down",
                "from": curr["high"],
                "to": prev["low"],
                "timestamp": curr["ts"]
            })

# Последний gap и текущая цена
if gaps:
    last_gap = gaps[-1]
    price = df.iloc[-1]["close"]

    print(f"Обнаружен GAP ({last_gap['type']}) от {last_gap['from']:.2f} до {last_gap['to']:.2f}")
    if last_gap["type"] == "up" and price < last_gap["from"]:
        print("📉 Возможен ретест GAP снизу → Сигнал на ЛОНГ")
    elif last_gap["type"] == "down" and price > last_gap["to"]:
        print("📈 Возможен ретест GAP сверху → Сигнал на ШОРТ")
    else:
        print("Цена ещё не вернулась в зону GAP")
else:
    print("GAP не найден")

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

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