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

📌"Gap Fill Strategy" — торговля на закрытие гэпа после резкого открытия🧑‍💻

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

Если рынок открывается с сильным гэпом вверх или вниз (разрыв между закрытием и открытием), часто происходит возврат в зону предыдущего закрытия — особенно в первые часы.

> Это поведение связано с коррекцией цены к справедливой стоимости после ночных/внебиржевых движений.

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

1. Обнаружен гэп между закрытием предыдущего дня и открытием текущего дня

2. Размер гэпа превышает X% (например, 0.5–1%)

3. Вход в сторону закрытия гэпа — т.е. в противоположную сторону от открытия

4. Стоп — за экстремум гэпа

5. Тейк — в районе предыдущего close

import ccxt
import pandas as pd

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

# Получаем 1h данные за 2 дня
ohlcv = exchange.fetch_ohlcv(symbol, "1h", limit=48)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")
df["date"] = df["ts"].dt.date

# Последнее закрытие вчера и первое открытие сегодня
yesterday = df[df["date"] == df["date"].iloc[-2]]
today = df[df["date"] == df["date"].iloc[-1]]

if not yesterday.empty and not today.empty:
    prev_close = yesterday["close"].iloc[-1]
    today_open = today["open"].iloc[0]
    gap = today_open - prev_close
    gap_pct = gap / prev_close * 100

    print(f"📊 Вчерашний close: {prev_close:.2f}")
    print(f"🕘 Сегодняшний open: {today_open:.2f}")
    print(f"🔍 Гэп: {gap:.2f} ({gap_pct:.2f}%)")

    if gap_pct > 0.5:
        print("📉 Гэп вверх — сигнал на ШОРТ (ожидание возврата к закрытию)")
    elif gap_pct < -0.5:
        print("📈 Гэп вниз — сигнал на ЛОНГ (ожидание возврата к закрытию)")
    else:
        print("⚠️ Гэп незначителен — сигнала нет")
else:
    print("Недостаточно данных для анализа")

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

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

📌Price Level Touch Counter — счётчик касаний ценовых уровней🧑‍💻

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

Часто важные уровни сопротивления/поддержки формируются там, где цена многократно касалась определённого уровня.

> Этот инструмент ищет ценовые уровни, которые часто тестировались, и считает количество таких касаний.

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

- Загружает исторические свечи

- Округляет цену до заданного шага (например, 10 или 50$)

- Считает, сколько раз цена попадала в этот диапазон (касалась)

- Находит уровни с наибольшим количеством касаний

- Выводит их в консоль

import ccxt
import pandas as pd
from collections import Counter

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

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

# Округляем цену до ближайших уровней по шагу
step = 50  # шаг в $
levels = []

for _, row in df.iterrows():
    for price in [row["high"], row["low"]]:
        rounded = round(price / step) * step
        levels.append(rounded)

level_counts = Counter(levels)
most_touched = level_counts.most_common(10)

print("🔍 Топ 10 уровней с наибольшим количеством касаний:")
for level, count in most_touched:
    print(f"📏 Уровень: {level}$ — касаний: {count}")

#инструмент

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

📌"Acceleration Reversal" — разворот после резкого ускорения цены🧑‍💻

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

Когда цена резко ускоряется вверх или вниз (движение с ускорением), это часто неустойчивый импульс,
который может закончиться резким разворотом — особенно если нет поддержки объёмом или трендом.

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

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

1. Вычисляется скорость и ускорение изменения цены

2. Если ускорение превышает заданный порог, и следующая свеча закрывается против движения — сигнал на разворот

3. Вход — в противоположную сторону от ускорения

4. Стоп — за экстремум импульса

5. Тейк — по фиксированному R:R или возврат к среднему

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

# Скорость изменения цены
df["delta"] = df["close"].diff()
df["velocity"] = df["delta"].rolling(3).mean()
df["acceleration"] = df["velocity"].diff()

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

accel = df["acceleration"].iloc[-1]

print(f"🧮 Ускорение: {accel:.2f}")

if accel > 50 and last["close"] < last["open"]:
    print("📉 Резкое ускорение вверх и откат — сигнал на ШОРТ")
elif accel < -50 and last["close"] > last["open"]:
    print("📈 Резкое ускорение вниз и откат — сигнал на ЛОНГ")
else:
    print("⚠️ Ускорения недостаточно или нет отката — сигнала нет")

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

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

📌Range Consolidation Detector — детектор консолидации в диапазоне🧑‍💻

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

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

> Обнаружив такие участки, трейдер может подготовиться к пробою или использовать стратегии внутри флэта.

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

- Анализирует последние N свечей (например, 20–50)

- Сравнивает текущий диапазон (High - Low) со средним за период

- Оценивает сжатие (волатильность падает)

- Выдаёт алерт при обнаружении узкого флэта

import ccxt
import pandas as pd

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

# Вычисляем диапазон свечей
df["range"] = df["high"] - df["low"]
avg_range = df["range"].rolling(20).mean().iloc[-1]
curr_range = df["range"].iloc[-1]

compression = curr_range < avg_range * 0.5  # текущий диапазон меньше 50% среднего

print(f"📏 Средний диапазон: {avg_range:.2f}")
print(f"📉 Текущий диапазон: {curr_range:.2f}")

if compression:
    print("🔍 Обнаружена консолидация — рынок во флэте (возможен пробой)")
else:
    print("📈 Волатильность в норме — флет не зафиксирован")

#инструмент

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

📌"Session Fade Strategy" — контртренд в конце торговой сессии🧑‍💻

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

Многие активы (особенно BTC, индексы, золото) имеют поведение, при котором в последние 1–2 часа сессии происходит разворот от основного внутридневного тренда — т.н. "fade".

> Особенно часто это наблюдается при перегретом движении в течение дня:
трейдеры фиксируют прибыль, ликвидность снижается → коррекция.

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

1. Определяется тренд дня (например, сравнивается текущая цена с open дня)

2. Если дневной тренд +1% или больше, и цена начинает разворачиваться в последнем часу — шорт

3. Если дневной тренд -1% или больше (сильное падение), и появляется разворот — лонг

4. Время входа — за 1 час до окончания основной сессии (например, 22:00 UTC)

import ccxt
import pandas as pd
from datetime import datetime

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

# Определяем open дня и текущую цену
today = df[df["date"] == df["date"].iloc[-1]]
if len(today) < 4:
    print("Недостаточно данных за сегодня")
else:
    open_price = today["open"].iloc[0]
    current_price = today["close"].iloc[-1]
    day_change = (current_price - open_price) / open_price * 100

    current_hour = datetime.utcnow().hour
    print(f"📅 Изменение за день: {day_change:.2f}% | Сейчас: {current_hour}:00 UTC")

    if 21 <= current_hour <= 23:  # ближе к закрытию дня
        if day_change > 1.0:
            print("📉 Сильный рост за день — сигнал на шорт (контртренд)")
        elif day_change < -1.0:
            print("📈 Сильное падение — сигнал на лонг (отскок)")
        else:
            print("⚠️ Изменение в пределах нормы — сигнала нет")
    else:
        print("⏳ Не конец сессии — стратегия не активна")

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

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

📌"Time-Decay Reversion" — стратегия возврата после новостного импульса🧑‍💻

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

После выхода новостей или всплеска волатильности рынок часто делает импульс в одну сторону,
а затем в течение 30–90 минут постепенно возвращается к точке равновесия — особенно если движение было эмоциональным.

> Стратегия использует время как фактор: если цена не продолжает рост/падение в течение определённого времени — открывается позиция на возврат.

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

1. Обнаружен сильный импульс по цене и объёму (например, свеча > 1.5x среднего диапазона)

2. Следующие 2–3 свечи показывают затухание — отсутствие продолжения

3. Вход в противоположную сторону импульса (на возврат к MA, VWAP или центру диапазона)

4. Стоп — за хай/лоу импульса

5. Тейк — VWAP, MA, midpoint свечи импульса

import ccxt
import pandas as pd

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

# Средний диапазон и последняя свеча
avg_range = df["range"].rolling(20).mean().iloc[-4]
impulse = df.iloc[-4]

# Условия: свеча больше 1.5x среднего и следующие свечи слабые
is_impulse = impulse["range"] > avg_range * 1.5
no_follow_through = all(df["range"].iloc[-3:] < avg_range * 0.7)

if is_impulse and no_follow_through:
    direction = "short" if impulse["close"] > impulse["open"] else "long"
    print(f"⚠️ Импульс зафиксирован без продолжения — сигнал на {direction.upper()}")
else:
    print("⏳ Импульсного сигнала или затухания не обнаружено")

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

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

📌Auto Support & Resistance Mapper — автоматическое определение уровней поддержки и сопротивления🧑‍💻

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

Инструмент анализирует исторические данные и находит ценовые уровни,
где часто происходили развороты или остановки движения — потенциальные зоны поддержки/сопротивления (S/R).

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

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

- Загружает исторические свечи (например, 4h или 1d)

- Ищет локальные экстремумы — swing high / low

- Считает, какие уровни встречаются чаще

- Выводит список сильных уровней с возможностью сохранить в файл

import ccxt
import pandas as pd
import numpy as np
from scipy.signal import argrelextrema

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

# Загрузка дневных свечей
df = pd.DataFrame(exchange.fetch_ohlcv(symbol, "1d", limit=300),
                  columns=["ts", "open", "high", "low", "close", "volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

# Ищем локальные экстремумы
df["min"] = df["low"].iloc[argrelextrema(df["low"].values, np.less_equal, order=3)[0]]
df["max"] = df["high"].iloc[argrelextrema(df["high"].values, np.greater_equal, order=3)[0]]

# Собираем уровни
levels = list(df["min"].dropna()) + list(df["max"].dropna())
rounded_levels = [round(level, -1) for level in levels]  # округление до 10
level_counts = pd.Series(rounded_levels).value_counts().sort_values(ascending=False)

print("🔍 Топ уровней поддержки/сопротивления:")
for lvl, cnt in level_counts.head(10).items():
    print(f"📏 Уровень {lvl:.0f}$ — касаний: {cnt}")

#инструмент

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

📌Market Regime Classifier — классификатор типа рынка (тренд / флет)🧑‍💻

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

Автоматически определяет, находится ли рынок в тренде или боковике,
что позволяет фильтровать сигналы и включать нужные стратегии (например, trend-following vs. mean-reversion).

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

- Анализирует волатильность, направление и угол наклона скользящей средней

- Классифицирует текущую фазу как trend, range или chop

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

import ccxt
import pandas as pd
import numpy as np

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["ma20"] = df["close"].rolling(20).mean()
df["ma_slope"] = df["ma20"].diff()
avg_slope = df["ma_slope"].tail(20).mean()

# Амплитуда движения
df["range"] = df["high"] - df["low"]
avg_range = df["range"].rolling(20).mean().iloc[-1]
last_range = df["range"].iloc[-1]

# Правила классификации
if abs(avg_slope) > 10 and last_range > avg_range * 1.2:
    regime = "trend"
elif last_range < avg_range * 0.8:
    regime = "range"
else:
    regime = "chop"

print(f"🔍 Режим рынка: {regime.upper()}")

#инструмент

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

📌"Relative Volume Ignition" — стратегия на основе резкого всплеска объёма по сравнению со средним🧑‍💻

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

Резкое увеличение объёма (relative volume spike) может сигнализировать о начале импульсного движения — часто это закупка крупных участников или выход из флэта.

> Если объём превышает среднее значение в несколько раз, и при этом цена пробивает диапазон — можно входить в сторону движения.

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

1. Объём текущей свечи > X раз средний объём за последние N свечей

2. Одновременно происходит пробой ближайшего экстремума (high/low)

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

# Параметры
vol_window = 20
vol_multiplier = 3

avg_volume = df["volume"].rolling(vol_window).mean()
df["rvol"] = df["volume"] / avg_volume

last = df.iloc[-1]
prev_highs = df["high"].iloc[-(vol_window+1):-1]
prev_lows = df["low"].iloc[-(vol_window+1):-1]

is_break_up = last["high"] > prev_highs.max()
is_break_down = last["low"] < prev_lows.min()

if last["rvol"] > vol_multiplier:
    print(f"🔥 Обнаружен резкий всплеск объёма: {last['rvol']:.2f}x")
    if is_break_up:
        print("📈 Пробой вверх на повышенном объёме — сигнал на ЛОНГ")
    elif is_break_down:
        print("📉 Пробой вниз на повышенном объёме — сигнал на ШОРТ")
    else:
        print("⚠️ Объём есть, но пробоя нет — ожидание подтверждения")
else:
    print("🔕 Объём в пределах нормы — сигнала нет")

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

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

📌Grid Spot Bot (Signal Only) — шаблон скрипта🧑‍💻

🔧 Идея:🚀

- Строится сетка цен вверх и вниз от текущей цены

- Когда цена касается уровня — генерируется сигнал на "Buy" или "Sell"

- Работает только на спотовом рынке, без вебсокетов

🛠 Возможные расширения:💸

- Добавить фиксацию прибыли и баланс позиции

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

- Добавить таймфрейм-фильтр или объёмные условия

import ccxt
import time

# Параметры
symbol = "BTC/USDT"
grid_size = 100         # Расстояние между уровнями, $
num_levels = 5          # Кол-во уровней вверх и вниз
base_order_side = "buy" # Базовое направление

# Инициализация биржи
exchange = ccxt.binance()
exchange.load_markets()

# Построение уровней
def build_grid(center_price, size, levels):
    return [round(center_price + i * size, 2) for i in range(-levels, levels + 1)]

# Отслеживание касания уровней
def grid_signal(price, grid_levels, triggered):
    for lvl in grid_levels:
        if abs(price - lvl) < grid_size * 0.05 and lvl not in triggered:
            side = "buy" if lvl < price else "sell"
            triggered.add(lvl)
            print(f"📡 Сигнал: {side.upper()} | Уровень: {lvl} | Цена: {price}")
            break

# Основной цикл
triggered_levels = set()

while True:
    ticker = exchange.fetch_ticker(symbol)
    current_price = ticker["last"]

    # Построение грид-уровней от текущей цены
    grid = build_grid(current_price, grid_size, num_levels)
    
    # Проверка на касание
    grid_signal(current_price, grid, triggered_levels)

    time.sleep(10)

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

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

📌"Volatility Heat Scanner" — сканер всплесков волатильности по множеству пар🧑‍💻

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

Сканирует выбранные торговые пары и находит те, где за последние X минут/часов произошёл резкий рост волатильности. Это может сигнализировать:

- о начале движения

- об окончании флэта

- о потенциальной возможности входа

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

- Загружает свечные данные по множеству пар

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

- Находит пары, где волатильность резко превышает норму

- Сортирует пары по силе всплеска

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbols = ['BTC/USDT', 'ETH/USDT', 'SOL/USDT', 'BNB/USDT', 'XRP/USDT']
timeframe = '15m'
vol_window = 20
results = []

for symbol in symbols:
    try:
        ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=vol_window + 5)
        df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
        df["range"] = df["high"] - df["low"]
        avg_range = df["range"].rolling(vol_window).mean().iloc[-2]
        current_range = df["range"].iloc[-1]
        ratio = current_range / avg_range if avg_range else 0

        results.append((symbol, ratio))
    except Exception as e:
        print(f"⚠️ Ошибка по {symbol}: {e}")

# Вывод топов по всплеску волатильности
sorted_results = sorted(results, key=lambda x: x[1], reverse=True)
print("\n🔥 Пары с наибольшим всплеском волатильности:")
for symbol, r in sorted_results:
    if r > 1.5:
        print(f"{symbol}: волатильность +{r:.2f}x выше нормы")

#инструмент

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

📌"News Latency Detector" — определение отставания реакции рынка на новости🧑‍💻

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

Многие активы запаздывают с реакцией на важные новости (например, альткойны после движения BTC).
Инструмент ищет те пары, которые не отреагировали или движутся с задержкой, что даёт шанс войти до основного импульса.

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

- Мониторит реакцию ключевого актива (например, BTC)

- Сравнивает процентное изменение других активов за последние X минут

- Ищет отстающих слабо реагирующих токенов

- Выдаёт список потенциальных "догоняющих"

import ccxt
import time

exchange = ccxt.binance()
symbols = ["BTC/USDT", "ETH/USDT", "SOL/USDT"]
lookback_minutes = 15

def get_price_change(symbol):
    candles = exchange.fetch_ohlcv(symbol, '1m', limit=lookback_minutes)
    open_price = candles[0][1]
    close_price = candles[-1][4]
    return (close_price - open_price) / open_price * 100

btc_change = get_price_change("BTC/USDT")
print(f"🚀 BTC изменился на {btc_change:.2f}% за {lookback_minutes} мин")

for symbol in symbols[1:]:
    alt_change = get_price_change(symbol)
    delta = btc_change - alt_change
    print(f"{symbol} реагирует на {delta:.2f}% слабее")

    if delta > 1.0:
        print(f"⚡ {symbol} может быть догоняющим кандидатом!")

#инструмент

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

📌Grid Rebalancer между BTC и USDT🧑‍💻

- Бот хранит активы в BTC и USDT

- Когда цена BTC падает и касается уровня — USDT обменивается на BTC

- Когда цена растёт — часть BTC продаётся за USDT

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

import ccxt
import pandas as pd
import time

# --- Настройки ---
symbol = "BTC/USDT"
grid_step = 100       # расстояние между уровнями
grid_levels = 5       # уровни вверх/вниз от центра
btc_balance = 0.01
usdt_balance = 300
last_price = None
grid = []
rebalanced = set()

exchange = ccxt.binance()

# --- Построение сетки ---
def create_grid(center_price):
    return [round(center_price + i * grid_step, 2) for i in range(-grid_levels, grid_levels + 1)]

# --- Симуляция перераспределения ---
def rebalance(price):
    global btc_balance, usdt_balance
    for level in grid:
        if price <= level and level not in rebalanced:
            # Покупка BTC (добавляем в позицию)
            buy_amount = usdt_balance * 0.1 / price
            btc_balance += buy_amount
            usdt_balance -= buy_amount * price
            print(f"🟢 BUY @ {level} | BTC: {btc_balance:.5f} | USDT: {usdt_balance:.2f}")
            rebalanced.add(level)
        elif price >= level and level not in rebalanced:
            # Продажа BTC (уменьшаем позицию)
            sell_amount = btc_balance * 0.1
            btc_balance -= sell_amount
            usdt_balance += sell_amount * price
            print(f"🔴 SELL @ {level} | BTC: {btc_balance:.5f} | USDT: {usdt_balance:.2f}")
            rebalanced.add(level)

# --- Основной цикл ---
while True:
    try:
        ticker = exchange.fetch_ticker(symbol)
        current_price = ticker['last']
        if last_price is None:
            grid = create_grid(current_price)
            print("📊 Сетка создана:", grid)

        rebalance(current_price)
        last_price = current_price
        time.sleep(10)

    except Exception as e:
        print(f"Ошибка: {e}")
        time.sleep(5)

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

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

📌"Correlation Shock Strategy" — вход при внезапном разрушении корреляции🧑‍💻

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

Многие активы (например, ETH и BTC, или LDO и LSD-токены) часто движутся в сильной корреляции.
В моменты, когда один актив резко уходит в сторону, а другой — остаётся на месте, возникает временной дисбаланс.
Стратегия использует это как возможность на вход: покупать "отстающий" актив до восстановления синхронности.

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

1. Выбрать две коррелированные пары (например, ETH/USDT и LDO/USDT)

2. Рассчитать изменение цены за последние N минут

3. Если расхождение между изменениями превышает X%, генерируется сигнал

4. Вход в позицию по "отстающему" активу, выход — при восстановлении корреляции

import ccxt
import pandas as pd

exchange = ccxt.binance()
pairs = {"ETH/USDT": None, "LDO/USDT": None}

lookback = 15  # минут
threshold = 2.0  # % расхождение для сигнала

for symbol in pairs.keys():
    candles = exchange.fetch_ohlcv(symbol, '1m', limit=lookback)
    df = pd.DataFrame(candles, columns=["ts", "open", "high", "low", "close", "volume"])
    pairs[symbol] = df["close"].iloc[-1] / df["close"].iloc[0] - 1

eth_move = pairs["ETH/USDT"] * 100
ldo_move = pairs["LDO/USDT"] * 100
delta = eth_move - ldo_move

print(f"📊 ETH: {eth_move:.2f}%, LDO: {ldo_move:.2f}% | Δ: {delta:.2f}%")

if abs(delta) >= threshold:
    lagging = "LDO" if delta > 0 else "ETH"
    print(f"📡 Сигнал: {lagging} отстаёт — потенциал входа на возврат")
else:
    print("✅ Корреляция стабильна — сигнала нет")

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

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

📌"Rolling Correlation Matrix Viewer" — инструмент анализа взаимосвязей активов во времени🧑‍💻

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

Позволяет отслеживать, как меняется корреляция между активами во времени. Это важно для:

- Определения диверсификации

- Поиска новых пар для парного трейдинга

- Обнаружения "разрывов" в синхронности

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

- Загружает исторические цены по выбранным активам

- Считает скользящую корреляцию (например, 30 свечей)

- Выводит матрицу корреляций, которую можно анализировать или визуализировать

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbols = ['BTC/USDT', 'ETH/USDT', 'BNB/USDT', 'SOL/USDT']
timeframe = '1h'
window = 30

price_data = {}

# Получаем данные
for symbol in symbols:
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=window + 10)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    price_data[symbol] = df["close"].pct_change().dropna().reset_index(drop=True)

# Собираем DataFrame с доходностями
returns_df = pd.DataFrame(price_data)

# Считаем корреляционную матрицу
corr_matrix = returns_df.corr()

print("🔍 Текущая корреляция между активами:")
print(corr_matrix.round(2))

#инструмент

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