📌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❗️

📌Session Volume Splitter — распределение объёма по торговым сессиям🧑‍💻

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

Инструмент анализирует, в какой части суток (Азия, Европа, США) формируется основной объём.

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

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

- Делит сутки на три торговые сессии:

Азия: 00:00–08:00 UTC

Европа: 08:00–16:00 UTC

США: 16:00–00:00 UTC

- Считает объём и среднюю цену внутри каждой

- Выдаёт процентное распределение активности

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

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

- Настроить стратегии под сессию с максимальной активностью

- Избегать сессий с минимальной волатильностью (например, между 2:00–6:00 UTC)

import ccxt
import pandas as pd

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

df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "1h", limit=72),
                  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 8 <= hour < 16:
        return "Europe"
    else:
        return "US"

df["session"] = df["hour"].apply(label_session)
session_volume = df.groupby("session")["volume"].sum()
total_volume = session_volume.sum()
session_share = session_volume / total_volume * 100

print("Объём по сессиям (последние 3 дня):")
for s in ["Asia", "Europe", "US"]:
    print(f"{s}: {session_share.get(s, 0):.2f}%")

#инструмент

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

📌Relative Volume Analyzer (RVol) — сравнение объёма текущей свечи с историческим🧑‍💻

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

Объём сам по себе мало информативен — важно знать, насколько он необычный по сравнению с прошлым.

> Relative Volume (RVol) — это объём текущей свечи / средний объём за N свечей.

Инструмент показывает, когда объём резко выше нормы, что часто предшествует импульсам или разворотам.

Что делает:🚀

- Вычисляет RVol для каждой свечи

- Отмечает свечи с RVol > 2.0 (в 2+ раза выше среднего)

- Даёт сигнал: “⚠️ Аномальный объём — возможный импульс”

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 свечей
df["avg_volume"] = df["volume"].rolling(20).mean()
df["rvol"] = df["volume"] / df["avg_volume"]

# Последняя свеча
last = df.iloc[-1]
print(f"Объём: {last['volume']:.2f} | Средний: {last['avg_volume']:.2f} | RVol: {last['rvol']:.2f}")

if last["rvol"] > 2.0:
    print("⚠️ Аномальный объём — возможный сильный импульс!")
else:
    print("RVol в норме — рынок спокойный.")

#инструмент

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

📌"Stop-Hunt Reversal" — стратегия разворота после сбора ликвидаций🧑‍💻

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

Крупные игроки часто толкают рынок чуть за важные уровни, чтобы активировать:

- стоп-лоссы

- ликвидации с плечом

- отложенные ордера на импульсе

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

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

1. Цена делает резкий пробой ключевого уровня (high/low)

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

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

4. Вход в обратную сторону пробоя

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

import ccxt
import pandas as pd

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

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

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

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

# Ложный пробой вверх
hunt_up = prev["high"] > range_high and curr["close"] < range_high

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

print(f"Диапазон: {range_low:.2f} – {range_high:.2f}")
if hunt_up:
    print("🔻 Stop-hunt вверх — сигнал на ШОРТ")
elif hunt_down:
    print("🔺 Stop-hunt вниз — сигнал на ЛОНГ")
else:
    print("Нет сигнала по стратегии Stop-Hunt Reversal")

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

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

📌"Inside Bar Breakout Trap" — стратегия на ложном пробое внутренней свечи🧑‍💻

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

Внутренняя свеча ("inside bar") — это свеча, которая полностью находится в диапазоне предыдущей свечи.
Обычно это означает затишье, но:

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

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

1. Предыдущая свеча (mother bar) — широкая

2. Следующая свеча — внутри диапазона mother bar (inside bar)

3. Третья свеча пробивает high/low, но закрывается обратно в диапазон

4. Вход в обратную сторону пробоя

5. Стоп — за экстремум пробоя, тейк — 1.5×-2× риск или к opposite уровням

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")

mother = df.iloc[-3]
inside = df.iloc[-2]
curr = df.iloc[-1]

# Проверка: inside бар внутри mother
is_inside = (
    inside["high"] < mother["high"] and
    inside["low"] > mother["low"]
)

# Ложный пробой вверх
false_break_up = (
    curr["high"] > inside["high"] and
    curr["close"] < mother["high"]
)

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

if is_inside:
    print("🔎 Обнаружен Inside Bar")
    if false_break_up:
        print("🔻 Ложный пробой вверх → сигнал на ШОРТ")
    elif false_break_down:
        print("🔺 Ложный пробой вниз → сигнал на ЛОНГ")
    else:
        print("Нет подтверждения ложного пробоя")
else:
    print("Нет Inside Bar — условий нет")

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

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

📌ATR Squeeze Detector — детектор фаз сжатия волатильности по ATR🧑‍💻

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

Когда рынок входит в фазу низкой волатильности, это часто предшествует взрывному движению (breakout).

> Индикатор ATR (Average True Range) показывает, насколько активно движется цена.
Сжатие ATR относительно его среднего — надёжный сигнал приближающегося импульса.

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

- Считает ATR на заданном таймфрейме (например, 15m или 1h)

- Сравнивает его с историческим средним ATR

- Выдаёт алерт, если текущий ATR ниже X% от среднего (например, < 60%)

- Опционально — логирует “зоны сжатия”

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")

# Расчёт ATR вручную
df["tr"] = df["high"] - df["low"]
df["tr"] = df["tr"].combine_first((df["high"] - df["close"].shift()).abs())
df["tr"] = df["tr"].combine_first((df["low"] - df["close"].shift()).abs())
df["atr"] = df["tr"].rolling(14).mean()

current_atr = df["atr"].iloc[-1]
mean_atr = df["atr"].mean()
ratio = current_atr / mean_atr * 100

print(f"Текущий ATR: {current_atr:.2f} | Средний ATR: {mean_atr:.2f} | Отношение: {ratio:.1f}%")

if ratio < 60:
    print("📉 Внимание: Сжатие волатильности (ATR Squeeze) — возможен скорый breakout!")
else:
    print("✅ Волатильность в норме")

#инструмент

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

📌Candle Strength Scanner — сканер силы свечей по телу и тени🧑‍💻

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

Сила и структура свечей (длина тела и тени) могут подсказать:

- Продолжится ли импульс

- Насколько уверенно прошёл пробой

- Есть ли давление покупателей или продавцов

> Инструмент сканирует последние свечи и оценивает преобладание одной стороны (быков/медведей).

📋 Что делает:🚀

- Анализирует последние N свечей на заданном таймфрейме

- Вычисляет долю тела от всей свечи

- Определяет "импульсные" свечи (большое тело, малая тень)

- Выводит вывод: "бычье давление", "медвежье давление", "баланс"

import ccxt
import pandas as pd

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

# Расчёт силы свечей
df["body"] = abs(df["close"] - df["open"])
df["range"] = df["high"] - df["low"]
df["body_ratio"] = df["body"] / df["range"]

# Считаем количество бычьих и медвежьих сильных свечей
threshold = 0.6
bulls = ((df["close"] > df["open"]) & (df["body_ratio"] > threshold)).sum()
bears = ((df["close"] < df["open"]) & (df["body_ratio"] > threshold)).sum()

print(f"🟩 Сильные бычьи свечи: {bulls}")
print(f"🟥 Сильные медвежьи свечи: {bears}")

if bulls > bears:
    print("📈 Преобладает покупательское давление")
elif bears > bulls:
    print("📉 Преобладает продавец")
else:
    print("⚖️ Баланс между сторонами")

#инструмент

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

📌"VWAP Magnet Reversal" — возврат к VWAP после экстремального отклонения🧑‍💻

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

Цена нередко резко отклоняется от VWAP (объёмно-взвешенной средней цены),
но затем "притягивается" обратно — как к магниту, особенно во флэтовом или балансном рынке.

> Эта стратегия ловит момент разворота обратно к VWAP, после сильного импульса в одну сторону.

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

1. Цена отклоняется от VWAP более чем на X% (например, 1.5%)

2. Последующая свеча не подтверждает движение (ослабление тренда)

3. Объём не растёт — отсутствие продолжения

4. Вход в сторону возврата к VWAP

5. Стоп — за локальный экстремум, тейк — на VWAP или чуть раньше

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")

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

# Последняя цена и отклонение
price = df["close"].iloc[-1]
vwap = df["vwap"].iloc[-1]
deviation = (price - vwap) / vwap * 100

print(f"Цена: {price:.2f} | VWAP: {vwap:.2f} | Отклонение: {deviation:.2f}%")

if deviation > 1.5:
    print("🔻 Сигнал на возврат к VWAP — ШОРТ (перекупленность)")
elif deviation < -1.5:
    print("🔺 Сигнал на возврат к VWAP — ЛОНГ (перепроданность)")
else:
    print("Отклонение в норме — сигнала нет")

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

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

📌Trade Setup Snapshot Logger — логгер рыночных условий при сигнале🧑‍💻

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

Во время входа по стратегии важно сохранять не только цену, но и контекст:

> какие были объёмы, волатильность, тренд, RSI, положение цены к VWAP и т.д.

Этот инструмент автоматически делает снимок рыночной ситуации при возникновении сигнала и сохраняет его в CSV.
→ Это позволяет потом анализировать эффективность сетапов.

🔧 Что сохраняется:

- Время сигнала

- Цена актива

- RSI, ATR, объём, отклонение от VWAP

- Направление сигнала (лонг/шорт)

- Доп. индикаторы (MACD, MA cross и т.п.)

- Результат (позже — win/loss)

import ccxt
import pandas as pd
from datetime import datetime

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

# Загрузка последних 100 свечей
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")

# Простейшая логика сигнала — RSI ниже 30 (перепроданность)
df["rsi"] = df["close"].rolling(14).apply(
    lambda x: 100 - (100 / (1 + (x.diff().clip(lower=0).sum() / abs(x.diff().clip(upper=0).sum() or 1e-5))))
)

signal = df.iloc[-1]
if signal["rsi"] < 30:
    print("🔔 Сигнал: перепроданность — ЛОНГ")

    snapshot = {
        "timestamp": datetime.utcnow().strftime("%Y-%m-%d %H:%M"),
        "symbol": symbol,
        "price": signal["close"],
        "rsi": signal["rsi"],
        "volume": signal["volume"],
        "direction": "long"
    }

    df_log = pd.DataFrame([snapshot])
    df_log.to_csv("trade_snapshot_log.csv", mode="a", header=False, index=False)
    print("✅ Снимок условий записан в журнал trade_snapshot_log.csv")
else:
    print("Нет сигнала — запись не выполняется.")

#инструмент

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

📌"Time-of-Day Momentum Bias" — стратегия по статистике силы движения в определённые часы🧑‍💻

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

На многих активах (особенно криптовалютах и индексах) наблюдаются повторяющиеся ценовые движения в определённые часы суток.

> Например, в 16:00 UTC часто начинается импульс (пересечение сессий, выход данных и т.д.)

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

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

1. Для каждого часа дня рассчитывается средний результат свечи за N дней

2. Строится профиль: в какие часы чаще идёт рост или падение

3. При наступлении "часа с положительным сдвигом" — вход в сторону этого смещения

4. Стоп и тейк — фиксированные (например, 0.5%/1%) или по ATR

import ccxt
import pandas as pd

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

# Получаем 1h свечи за последние 14 дней
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "1h", limit=24*14),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")
df["hour"] = df["ts"].dt.hour
df["delta"] = df["close"] - df["open"]

# Средняя направленность по каждому часу
hour_bias = df.groupby("hour")["delta"].mean()

# Последний час
now_hour = pd.Timestamp.utcnow().hour
bias = hour_bias.get(now_hour, 0)

print("🔍 Среднее смещение по часу:")
print(hour_bias.round(2))
print(f"\n🕐 Сейчас: {now_hour}:00 | Средняя направленность: {bias:.2f}")

if bias > 20:
    print("📈 Час обычно бычий → сигнал на ЛОНГ")
elif bias < -20:
    print("📉 Час обычно медвежий → сигнал на ШОРТ")
else:
    print("⚖️ Смещение нейтральное — сигнала нет")

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

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

📌Real-Time Risk Calculator — калькулятор риска и размера позиции🧑‍💻

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

Перед каждой сделкой важно точно рассчитать:

Сколько можно потерять при стоп-лоссе (в $ или %)

Какой объём позиции соответствует допустимому риску

Где должен быть стоп, чтобы уложиться в параметры

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

🔧 Что делает:🚀

Принимает:

- Капитал (в USDT)

- Размер стопа (в $ или % от входа)

- Процент риска на сделку (например, 1%)

Выдаёт:

- Размер позиции

- Кол-во монет

- Уровень ликвидации при использовании плеча (опционально)

def risk_calculator(capital_usdt, entry_price, stop_price, risk_percent):
    risk_usdt = capital_usdt * (risk_percent / 100)
    stop_size = abs(entry_price - stop_price)
    if stop_size == 0:
        raise ValueError("Stop size cannot be zero.")
    
    position_size = risk_usdt / stop_size
    cost = position_size * entry_price

    print(f"💰 Капитал: {capital_usdt}$")
    print(f"🎯 Вход: {entry_price} | Стоп: {stop_price}")
    print(f"⚖️ Риск на сделку: {risk_percent}% → {risk_usdt:.2f}$")
    print(f"📊 Размер позиции: {position_size:.4f} монет")
    print(f"💵 Стоимость позиции: {cost:.2f}$")

# Пример вызова:
risk_calculator(
    capital_usdt=1000,
    entry_price=27000,
    stop_price=26700,
    risk_percent=1
)

#инструмент

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

📌"Volume Dry-Up Breakout" — стратегия на прорыв после падения объёма🧑‍💻

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

Когда рынок долго стоит во флэте и объёмы высыхают, это часто предшествует мощному выходу в одну сторону.

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

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

1. Объём падает и остаётся ниже 50% среднего за последние N свечей

2. Цена сужается в узком диапазоне

3. Происходит всплеск объёма + выход за локальный high/low

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

5. Стоп — за противоположной границей флэта

6. Тейк — по фиксированному 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")

# Расчёт среднего объёма и диапазона
df["avg_volume"] = df["volume"].rolling(20).mean()
df["range"] = df["high"] - df["low"]

# Проверка условий
last = df.iloc[-1]
low_vol = last["volume"] < df["avg_volume"].iloc[-1] * 0.5
tight_range = df["range"].iloc[-5:].mean() < df["range"].mean() * 0.7

# Предыдущий high/low
local_high = df["high"].iloc[-6:-1].max()
local_low = df["low"].iloc[-6:-1].min()

break_up = last["high"] > local_high
break_down = last["low"] < local_low

print(f"Объём: {last['volume']:.2f} | Средний: {df['avg_volume'].iloc[-1]:.2f}")
print(f"Диапазон последних свечей сжат: {tight_range}")

if low_vol and tight_range:
    if break_up:
        print("📈 Всплеск объёма и пробой вверх — сигнал на ЛОНГ")
    elif break_down:
        print("📉 Всплеск объёма и пробой вниз — сигнал на ШОРТ")
    else:
        print("⚠️ Сжатие есть, но пробоя пока нет")
else:
    print("Условия сжатия объёма/диапазона не выполнены")

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

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

📌Historical Strategy Validator — тестер торговых правил на исторических данных🧑‍💻

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

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

> Особенно полезен для тестирования простых идей:
«что если покупать, когда RSI < 30 и цена выше MA100»?

import ccxt
import pandas as pd

def test_strategy(symbol="BTC/USDT", timeframe="1h", limit=500, rsi_period=14, rsi_entry=30, rsi_exit=50):
    exchange = ccxt.binance()
    df = pd.DataFrame(exchange.fetch_ohlcv(symbol, timeframe, limit=limit),
                      columns=["ts", "open", "high", "low", "close", "volume"])
    df["ts"] = pd.to_datetime(df["ts"], unit="ms")

    # RSI
    delta = df["close"].diff()
    gain = delta.clip(lower=0).rolling(rsi_period).mean()
    loss = (-delta.clip(upper=0)).rolling(rsi_period).mean()
    rs = gain / (loss + 1e-9)
    df["rsi"] = 100 - (100 / (1 + rs))

    # Торговая логика
    position = False
    entry_price = 0
    trades = []

    for i in range(rsi_period, len(df)):
        row = df.iloc[i]
        if not position and row["rsi"] < rsi_entry:
            position = True
            entry_price = row["close"]
            entry_time = row["ts"]
        elif position and row["rsi"] > rsi_exit:
            position = False
            exit_price = row["close"]
            exit_time = row["ts"]
            profit_pct = (exit_price - entry_price) / entry_price * 100
            trades.append({
                "entry_time": entry_time, "exit_time": exit_time,
                "entry": entry_price, "exit": exit_price,
                "profit_pct": round(profit_pct, 2)
            })

    # Результаты
    results = pd.DataFrame(trades)
    if not results.empty:
        print(f"📊 Совершено сделок: {len(results)}")
        print(f"✅ Win-rate: {(results['profit_pct'] > 0).mean() * 100:.2f}%")
        print(f"📈 Средняя доходность: {results['profit_pct'].mean():.2f}%")
        print(f"📉 Max просадка: {results['profit_pct'].min():.2f}%")
        results.to_csv("strategy_backtest_log.csv", index=False)
    else:
        print("Нет сработавших условий")

# Пример вызова:
test_strategy()

#инструмент

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