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

📌"Bid-Ask Flip Detector" — стратегия на смену агрессора в стакане🧑‍💻

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

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

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

1. В течение X секунд/циклов наблюдается рост объёма на стороне bid

2. Затем происходит резкий сдвиг: крупный ask появляется, а bid исчезает

3. Это "flip" — сигнал на вход в сторону нового агрессора

import ccxt
import time

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

# Порог объёма для фиксации "flip"
threshold = 1.5  # x раз превышение объёма

def get_order_book_snapshot(symbol):
    order_book = exchange.fetch_order_book(symbol, limit=5)
    top_bid = order_book['bids'][0][1] if order_book['bids'] else 0
    top_ask = order_book['asks'][0][1] if order_book['asks'] else 0
    return top_bid, top_ask

last_bid, last_ask = get_order_book_snapshot(symbol)

while True:
    try:
        current_bid, current_ask = get_order_book_snapshot(symbol)

        bid_flip = current_bid < last_bid / threshold and current_ask > last_ask * threshold
        ask_flip = current_ask < last_ask / threshold and current_bid > last_bid * threshold

        if bid_flip:
            print("🔴 Flip detected: BID -> ASK dominance. Возможный СИГНАЛ НА ШОРТ.")
        elif ask_flip:
            print("🟢 Flip detected: ASK -> BID dominance. Возможный СИГНАЛ НА ЛОНГ.")
        else:
            print("⏳ Наблюдение... Нет резкой смены доминирования.")

        last_bid, last_ask = current_bid, current_ask
        time.sleep(5)

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

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

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

📌"Candle Range Classifier" — классификатор силы свечей🧑‍💻

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

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

🔧 Что делает:

Сканирует последние свечи по выбранной паре

Вычисляет:🧨

- соотношение тела к общему диапазону

- силу закрытия (ближе к high или low)

- наличие хвостов (поглощения, до́жи)

Классифицирует:💻

- strong bullish, weak bullish,

- strong bearish, weak bearish,

- indecision / doji

import ccxt
import pandas as pd

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

ohlcv = exchange.fetch_ohlcv(symbol, '15m', limit=2)
candle = ohlcv[-2]  # предпоследняя свеча

open_, high, low, close = candle[1:5]
body = abs(close - open_)
range_ = high - low
upper_wick = high - max(open_, close)
lower_wick = min(open_, close) - low

body_ratio = body / range_ if range_ else 0

# Классификация
if body_ratio > 0.6:
    if close > open_:
        label = "strong bullish"
    else:
        label = "strong bearish"
elif body_ratio < 0.2:
    label = "indecision / doji"
else:
    label = "weak bullish" if close > open_ else "weak bearish"

print(f"🕯️ Свеча: {label.upper()} | Body: {body_ratio:.2f}")

#инструмент

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

📌"Volatility Snapshot Tool" — монитор волатильности по активам🧑‍💻

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

Инструмент показывает текущую реальную (реализованную) волатильность по выбранным активам — позволяет:

- Определить, какие пары сейчас самые активные

- Избегать торговли в слишком "глухих" зонах

- Найти возможности для волатильных стратегий (скальпинг, breakout)

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

- Скачивает свечи за последние X минут или часов

- Вычисляет реализованную волатильность (на основе std отклонения log-доходностей или ATR)

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

- Показывает топ-движущихся активов прямо в консоли

import ccxt
import pandas as pd
import numpy as np

symbols = ['BTC/USDT', 'ETH/USDT', 'SOL/USDT', 'LTC/USDT']
exchange = ccxt.binance()
volatility_data = {}

for symbol in symbols:
    ohlcv = exchange.fetch_ohlcv(symbol, '5m', limit=50)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    df['log_return'] = np.log(df['close'] / df['close'].shift(1))
    realized_vol = df['log_return'].std() * np.sqrt(12)  # за 1 час
    volatility_data[symbol] = realized_vol

sorted_vol = dict(sorted(volatility_data.items(), key=lambda x: x[1], reverse=True))

print("📊 ТОП активов по реализованной волатильности (час):")
for symbol, vol in sorted_vol.items():
    print(f"{symbol}: {vol:.4f}")

#инструмент

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

📌"Anchored VWAP Shift Strategy" стратегия на смещение точки равновесия🧑‍💻

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

Вместо классического VWAP (который начинается с открытия дня), используется Anchored VWAP — привязка средней взвешенной цены к определённому событию:

- локальному минимуму

- сильному импульсу

- началу недели и т.п.

> Когда цена уходит выше или ниже Anchored VWAP и удерживается, это сигнал о смене баланса между покупателями и продавцами.

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

1. Зафиксировать ключевую точку привязки (например, лоу недели)

2. Рассчитать Anchored VWAP с этого момента

3. Когда цена пробивает VWAP и держится выше N свечей → сигнал на вход

4. Тейк по ATR / R:R, стоп — за точку пробоя

import ccxt
import pandas as pd

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

# Привязываем к лоу определённой свечи
anchor_index = df["low"].idxmin()
anchored = df.iloc[anchor_index:]

anchored["cum_vol"] = anchored["volume"].cumsum()
anchored["cum_vwap"] = (anchored["typical_price"] * anchored["volume"]).cumsum() / anchored["cum_vol"]

vwap = anchored["cum_vwap"].iloc[-1]
current_price = df["close"].iloc[-1]

if current_price > vwap:
    print(f"🟢 Цена выше Anchored VWAP ({vwap:.2f}) — сигнал на ЛОНГ")
else:
    print(f"🔴 Цена ниже Anchored VWAP ({vwap:.2f}) — сигнал на ШОРТ")

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

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

“Position Size Calculator CLI”
Консольный калькулятор размера позиции на Python🧑‍💻

📌 Описание🧨

Инструмент помогает рассчитать размер позиции на основе:

- величины капитала

- процента риска

- уровня входа и стоп-лосса

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

def calculate_position_size(account_balance, risk_percent, entry_price, stop_price):
    risk_amount = account_balance * (risk_percent / 100)
    stop_loss_per_unit = abs(entry_price - stop_price)
    if stop_loss_per_unit == 0:
        raise ValueError("Stop loss слишком близко к входу")
    position_size = risk_amount / stop_loss_per_unit
    return position_size

def main():
    print("=== Position Size Calculator ===")
    try:
        balance = float(input("Введите капитал ($): "))
        risk_pct = float(input("Риск на сделку (%): "))
        entry = float(input("Цена входа: "))
        stop = float(input("Цена стоп-лосса: "))

        size = calculate_position_size(balance, risk_pct, entry, stop)
        print(f"\n🔢 Рекомендуемый размер позиции: {size:.4f} единиц актива")
    except Exception as e:
        print(f"[Ошибка] {e}")

if __name__ == "__main__":
    main()

#инструмент

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

📌"Timebox Scalping Strategy" – стратегия торговли по временным блокам🧑‍💻

🧠 Описание:🧨

Эта стратегия разбивает день на фиксированные временные блоки (например, по 15 или 30 минут) и ищет локальный экстремум в прошлом блоке, а затем торгует на отскок или пробой в следующем блоке. Идея в том, что определённые паттерны повторяются в пределах фиксированных временных структур (особенно во флэте или на переломах).

⚙️ Условия входа:🚀

ЛОНГ:

- В предыдущем блоке был локальный минимум.

- Текущая цена пробила high прошлого блока.

- Объём выше среднего за 5 блоков.

ШОРТ:

- В предыдущем блоке был локальный максимум.

- Текущая цена пробила low прошлого блока.

- Объём выше среднего за 5 блоков.

import time
import pandas as pd
import requests

# Настройки
symbol = 'BTCUSDT'
interval = '15m'
limit = 50
api_url = f"https://api.binance.com/api/v3/klines?symbol={symbol}&interval={interval}&limit={limit}"

def get_klines():
    response = requests.get(api_url)
    data = response.json()
    df = pd.DataFrame(data, columns=[
        'timestamp', 'open', 'high', 'low', 'close', 'volume',
        'close_time', 'quote_asset_volume', 'trades',
        'taker_buy_base', 'taker_buy_quote', 'ignore'
    ])
    df = df.astype(float)
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    return df

def check_signal(df):
    # Берём последние 2 блока
    prev_block = df.iloc[-2]
    curr_block = df.iloc[-1]

    prev_high = prev_block['high']
    prev_low = prev_block['low']
    curr_price = curr_block['close']
    curr_vol = curr_block['volume']

    avg_vol = df['volume'].iloc[-6:-1].mean()

    if curr_price > prev_high and curr_vol > avg_vol:
        print(f"[ALERT] LONG сигнал: цена пробила хай блока | Цена: {curr_price}")
    elif curr_price < prev_low and curr_vol > avg_vol:
        print(f"[ALERT] SHORT сигнал: цена пробила лоу блока | Цена: {curr_price}")
    else:
        print("[INFO] Нет сигнала.")

def run_monitor():
    print("⏳ Запуск Timebox Scalping Monitor...")
    while True:
        try:
            df = get_klines()
            check_signal(df)
            time.sleep(60)  # каждые 60 сек, чтобы не спамить
        except Exception as e:
            print(f"[ERROR] {e}")
            time.sleep(30)

if __name__ == "__main__":
    run_monitor()

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

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

📌Стратегия: Price Ladder Climb🧑‍💻

“Лестница цены” — стратегия по поэтапному закреплению на ключевых уровнях

📌 Идея🛠️

Представь, что цена — это альпинист, поднимающийся по склону. Каждый уровень сопротивления — это новая ступень. Если альпинист успешно закрепляется (удерживается) на ступени в течение N минут — он готов лезть выше.

⚙️ Правила входа💸

1. Обнаружение "ступени": цена пробивает локальное сопротивление (high за последние X минут).

2. Закрепление: если в течение следующих 3 свечей цена не опускается ниже пробитого уровня — это "закрепление".

3. Вход: после закрепления — вход в направлении пробоя.

4. Выход: по цели (например, фиксированное расстояние или следующая ступень).

import requests
import time

symbol = "BTCUSDT"
interval = "1m"
limit = 10

def get_ohlcv():
    url = "https://api.binance.com/api/v3/klines"
    params = {"symbol": symbol, "interval": interval, "limit": limit}
    res = requests.get(url, params=params).json()
    return [[float(x[2]), float(x[3]), float(x[4])] for x in res]  # high, low, close

print("[*] Лестница цены: начало мониторинга")

while True:
    try:
        data = get_ohlcv()
        highs = [x[0] for x in data[:-3]]  # до последних 3 свечей
        recent = data[-3:]
        level = max(highs)

        above_level = all(x[2] > level for x in recent)
        if above_level:
            print(f"[!] Закрепление выше {level:.2f}, возможный ЛОНГ")
        else:
            print(f"[ ] Нет закрепления: последний high={level:.2f}")

        time.sleep(30)
    except Exception as e:
        print("[Ошибка]", e)
        time.sleep(10)

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

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

📌 Инструмент: Multi-Asset Correlation Tracker 🧑‍💻

Онлайн-монитор корреляций между активами с динамикой за последние N часов/дней

📌 Описание 🧨

Этот инструмент отслеживает корреляции между активами (например, BTC/ETH, BTC/SP500, золото/фондовые индексы и т.д.) и показывает, как они меняются во времени. Это помогает:

- Понимать перекосы в поведении активов

- Выявлять дивергенции

- Искать неэффективности и сигналы для парного трейдинга

- Адаптировать стратегию под текущую макро-среду

import requests
import numpy as np
import pandas as pd
from scipy.stats import pearsonr
import time

symbols = ["BTCUSDT", "ETHUSDT"]
interval = "1h"
limit = 100

def get_closes(symbol):
    url = "https://api.binance.com/api/v3/klines"
    params = {"symbol": symbol, "interval": interval, "limit": limit}
    data = requests.get(url, params=params).json()
    return [float(x[4]) for x in data]

print("[*] Запуск мониторинга корреляций...")

while True:
    try:
        series = {s: get_closes(s) for s in symbols}
        df = pd.DataFrame(series)
        corr = df.corr().iloc[0, 1]
        print(f"[📈] Корреляция {symbols[0]} / {symbols[1]} = {corr:.3f}")
        time.sleep(3600)
    except Exception as e:
        print("[Ошибка]", e)
        time.sleep(60)

#инструмент

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