📌“Временные карманы” (Time Pocket Strategy)🧑‍💻

💡 Идея: 🧨

Рынок двигается неравномерно: бывают активные участки (импульсы) и “временные карманы” — периоды, где объём замедляется, но цена остаётся на одном уровне.
Часто такие зоны — это подготовка к выбросу ликвидности (breakout).

👉 Мы ищем такие “временные карманы” и входим в сторону первого мощного выхода из паузы.

⚙️ Логика:🛠️

1. Берём поток котировок или свечей (например, 1m).

2. Считаем среднюю скорость изменения цены и объёма.

3. Если цена остаётся в диапазоне <0.2% от средней 3+ минуты, но объём не исчезает — формируется “временной карман”.

4. Первый импульс (цена >0.3% за 30 секунд) — сигнал на вход.

5. Закрытие — по обратному импульсу или через фиксированный риск/прибыль.

import asyncio
import json
import websockets
import statistics
import time

SYMBOL = "btcusdt"
URL = f"wss://stream.binance.com:9443/ws/{SYMBOL}@kline_1m"

prices = []
volumes = []
window = 3  # минут

async def listen():
    async with websockets.connect(URL) as ws:
        async for msg in ws:
            data = json.loads(msg)
            k = data["k"]
            if not k["x"]:  # свеча не закрыта
                continue
            close = float(k["c"])
            vol = float(k["v"])
            prices.append(close)
            volumes.append(vol)
            if len(prices) > window:
                prices.pop(0)
                volumes.pop(0)

            rng = (max(prices) - min(prices)) / statistics.mean(prices)
            vol_mean = statistics.mean(volumes)

            if rng < 0.002 and vol_mean > 0.7 * max(volumes):
                print(f"🕰 TIME POCKET detected at {close:.2f}")
            elif rng > 0.003:
                print(f"⚡ BREAKOUT from pocket → {close:.2f}")

asyncio.run(listen())

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

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

📌“Order Heat Echo” — карта термошума ордеров🧑‍💻

💡 Концепция: 🧨

Все биржи полны микроколебаний, которые не видны на графике.
Каждая отмена или установка ордера создаёт “тепловой шум” — его можно визуализировать.

Order Heat Echo — это инструмент, который показывает где рынок «нагревается» активностью, но ещё не проявил это в цене.

🔍 Как это работает: 🛠️

1. Через Binance WebSocket собираются данные о:

лимитных ордерах (bid/ask);

их отменах и изменениях.

2. Для каждого ценового уровня в стакане рассчитывается:

скорость изменений (Δобъем/Δвремя);

плотность ордеров (объем / расстояние между уровнями);

направленность потока (в какой стороне теплее — bid или ask).

3. Все данные проецируются в тепловую карту:

красные зоны — давление продаж;

синие — скопления покупателей;

серые — нейтральные участки.

import asyncio
import json
import numpy as np
import matplotlib.pyplot as plt
import websockets

SYMBOL = "btcusdt"
URL = f"wss://stream.binance.com:9443/ws/{SYMBOL}@depth20@100ms"

heatmap = np.zeros(40)  # 20 уровней bid + 20 уровней ask

async def order_heat_echo():
    async with websockets.connect(URL) as ws:
        while True:
            data = json.loads(await ws.recv())
            bids = data["bids"]
            asks = data["asks"]

            # Расчёт изменения плотности ордеров
            for i, b in enumerate(bids[:20]):
                heatmap[i] = float(b[1])
            for i, a in enumerate(asks[:20]):
                heatmap[20 + i] = float(a[1]) * -1  # продавцы — отрицательные значения

            plt.clf()
            plt.bar(range(len(heatmap)), heatmap, color=["red" if v < 0 else "blue" for v in heatmap])
            plt.pause(0.01)

asyncio.run(order_heat_echo())

#инструмент

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

📌Market Maker Shadow🧑‍💻

💡 Идея: 🧨

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

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

import ccxt
import numpy as np
import time

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

def get_candles(symbol, tf="1m", limit=30):
    ohlcv = exchange.fetch_ohlcv(symbol, tf, limit=limit)
    return np.array(ohlcv)

def detect_fake_move(candles):
    closes = candles[:, 4]
    opens = candles[:, 1]
    vols = candles[:, 5]
    changes = (closes - opens) / opens * 100
    vol_median = np.median(vols)
    
    signal = None
    if changes[-1] > 0.5 and vols[-1] < vol_median:
        signal = "short"
    elif changes[-1] < -0.5 and vols[-1] < vol_median:
        signal = "long"
    return signal, changes[-1], vols[-1], vol_median

while True:
    candles = get_candles(symbol)
    signal, change, vol, vmed = detect_fake_move(candles)
    
    print(f"Δ={change:.2f}% | Vol={vol:.0f}/{vmed:.0f}")
    
    if signal == "short":
        print("🔻 Обнаружен пустой импульс вверх → вход в SHORT")
    elif signal == "long":
        print("🔼 Обнаружен пустой импульс вниз → вход в LONG")
    
    time.sleep(60)

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

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

📌“Range Sentinel” — детектор консолидации по энтропии рынка🧑‍💻

💡 Концепция: 🧨

Вместо классического поиска флэта по ATR, Bollinger или объёму, Range Sentinel измеряет “рыночную энтропию” — насколько непредсказуемы изменения цены внутри окна времени.

Если энтропия низкая → цена «застряла» в рэндже.
Если энтропия резко растёт → начинается выход из консолидации.

📊 Что даёт инструмент: 💸

Показывает зоны накопления без использования объёмов.

Отлично выявляет “ложные пробои” — если энтропия не растёт, значит, это не импульс.

Может работать на любом таймфрейме (от минут до дневок).

Можно использовать в боте:

когда H < 1.0 → флэт,

когда H > 2.0 → начало импульса.

import ccxt
import numpy as np
import time

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

def entropy(series, bins=20):
    hist, _ = np.histogram(series, bins=bins, density=True)
    hist = hist[hist > 0]
    return -np.sum(hist * np.log2(hist))

def get_entropy(symbol, tf="1h", window=50):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=tf, limit=window)
    changes = [(c[4] - c[1]) / c[1] for c in ohlcv]
    return entropy(changes)

while True:
    H = get_entropy(symbol)
    print(f"Энтропия рынка: {H:.3f}")
    
    if H < 1.0:
        print("🟦 Рынок во флэте — возможна консолидация")
    elif H > 2.0:
        print("🟥 Выход из диапазона — начинается импульс")
    
    time.sleep(60)

#инструмент

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

📌Refill Predictor — прогнозер восстановления стакана (orderbook refill)🧑‍💻

Коротко — это практичный инструмент для исполнения крупных ордеров. Он в реальном-времени оценивает скорость восстановления (refill) объёма на ключевых уровнях стакана и даёт:

вероятность того, что заданный объём будет доступен на уровне за T секунд,

рекомендованный интервал дробления (delay между слайсами) и оптимальный offset лимитной заявки.

Почему полезно: статический снимок стакана мало что говорит — стакан часто рефилится за миллисекунды. Этот скрипт предсказывает рефил — даёт практические рекомендации для execution (market vs slices vs limit).

Идея / алгоритм (кратко): 🛠

1. Подключаемся к Binance depth stream (depth@100ms) по одной паре или нескольким парам.

2. На каждом уровне (например топ 10 уровней) отслеживаем изменения объёма во времени: появление/исчезновение и последующие пополнения.

3. Для каждого уровня считаем refill_rate = экспоненциальное среднее приходящего объёма в пределах ±Δцены (base/s).

4. По refill_rate моделируем вероятность появления требуемого объёма V в горизонте T как 1 - exp(-λ*T) (пуассон-приближенно) или более прямо: P = min(1, (expected_arrival * T) / V).

5. По всем уровням строим таблицу: уровень, текущий available, expected arrival per T, P(fill), рекомендованный action:

P≈1 и доступно → market / immediate limit,

P high but current small → slice with delay ≈ T_best,

P low → уменьшить долю или искать OTC.

#инструмент

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

📌"Latency Trap" (ловушка задержки ликвидности)🧑‍💻

💡 Концепция🧨

Когда рынок резко движется, крупные лимитные ордера не успевают обновиться в книге — они “застывают” на старых уровнях.
Это создаёт краткий момент, когда:

движение кажется сильным,

но в стакане “дырки” в ликвидности,

и маркет-мейкеры за миллисекунды “откатывают” цену обратно, чтобы залить ликвидность заново.

Именно в эти моменты (в течение 1–5 секунд) и происходят самые частые микрореверсы.
Наша задача — поймать такие “дыры” и торговать в обратную сторону движения.

🧠 Логика:🛠️

1. Подключаемся к WebSocket Binance (stream depth@100ms).

2. Для каждого обновления стакана считаем:

изменение средней плотности ордеров в верхних 5 уровнях;

скорость изменения цены (дельта между best bid/ask).

3. Если:

цена выросла/упала > 0.3% за последние 3 секунды,

а плотность ликвидности в направлении движения упала на > 50%,
→ фиксируем “ликвидностную дыру”.

4. После этого ждём откат 0.1–0.2% — и входим в противоположную сторону.

import asyncio
import json
import websockets
import numpy as np
from datetime import datetime

symbol = "btcusdt"
url = f"wss://stream.binance.com:9443/ws/{symbol}@depth5@100ms"

async def latency_trap():
    prev_asks, prev_bids = [], []
    prev_mid = None
    history = []

    async with websockets.connect(url) as ws:
        print("📡 Listening for liquidity gaps...")
        async for msg in ws:
            data = json.loads(msg)
            bids = np.array([[float(x[0]), float(x[1])] for x in data["bids"]])
            asks = np.array([[float(x[0]), float(x[1])] for x in data["asks"]])
            mid = (asks[0,0] + bids[0,0]) / 2

            # Плотность ликвидности
            bid_liq = bids[:,1].sum()
            ask_liq = asks[:,1].sum()

            history.append(mid)
            if len(history) > 30:
                history.pop(0)

            if prev_mid:
                price_change = (mid - prev_mid) / prev_mid * 100
                liq_change = (bid_liq + ask_liq) / (sum(prev_bids) + sum(prev_asks) + 1e-9)

                if abs(price_change) > 0.3 and liq_change < 0.5:
                    side = "SHORT" if price_change > 0 else "LONG"
                    print(f"⚡ {datetime.now().strftime('%H:%M:%S')} → {side} | Δ={price_change:.2f}% | Liquidity drop {liq_change:.2f}")

            prev_mid = mid
            prev_bids = bids[:,1]
            prev_asks = asks[:,1]

asyncio.run(latency_trap())

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

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

📌Моделирование проскальзывания в зависимости от ликвидности🧑‍💻

Идея: 🧨

Инструмент принимает пару, плечо и сумму в USDT,
а возвращает среднюю цену, по которой реально откроется позиция при рыночной покупке с учётом объёма в стакане Binance Futures (USDT-M).

import ccxt

def estimate_market_entry_price(symbol: str, leverage: int, balance_usdt: float, side='buy', fee_rate=0.0004, depth_limit=200):
    """
    Оценка средней цены открытия рыночной позиции с учетом ликвидности Binance Futures (USDT-M).
    
    :param symbol: Пара, например 'BTC/USDT'
    :param leverage: Плечо, например 10
    :param balance_usdt: Собственные средства (без учета плеча)
    :param side: 'buy' или 'sell'
    :param fee_rate: Комиссия Binance (по умолчанию 0.04%)
    :param depth_limit: Глубина стакана для анализа
    :return: dict с результатами
    """
    exchange = ccxt.binance({
        'options': {'defaultType': 'future'}
    })

    orderbook = exchange.fetch_order_book(symbol, limit=depth_limit)

    position_value = balance_usdt * leverage
    remaining_value = position_value
    filled_value = 0
    weighted_price = 0

    # Для покупки — считаем по аскам, для продажи — по биддам
    levels = orderbook['asks'] if side == 'buy' else orderbook['bids']
    
    for price, volume in levels:
        level_value = price * volume
        if remaining_value > level_value:
            filled_value += level_value
            weighted_price += price * volume
            remaining_value -= level_value
        else:
            filled_value += remaining_value
            weighted_price += price * (remaining_value / price)
            break

    avg_price = weighted_price / (filled_value / price)  # средняя цена
    fees = position_value * fee_rate * 2
    effective_entry = avg_price * (1 + fee_rate if side == 'buy' else 1 - fee_rate)

    return {
        'symbol': symbol,
        'side': side,
        'leverage': leverage,
        'balance_usdt': balance_usdt,
        'notional_value': position_value,
        'avg_entry_price': round(avg_price, 4),
        'effective_entry_price': round(effective_entry, 4),
        'total_fees_usdt': round(fees, 4)
    }


# 🔍 Пример использования:
result = estimate_market_entry_price('BTC/USDT', leverage=10, balance_usdt=1000, side='buy')
print(result)

#инструмент

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

📌Entropy Pulse 🧑‍💻

💡 Идея🧨

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

Мы не используем индикаторы — только поведение самих свечей.

📊 Принцип🛠️

1. Рассчитываем энтропию направления за последние N свечей:

если 50% свечей вверх, 50% вниз — энтропия максимальна (рынок хаотичен, консолидация).

если 90% вверх — энтропия низкая (тренд).

2. Рассчитываем энтропию амплитуды (разброс High-Low).

Чем больше колебания — тем выше “хаос”.

3. Когда обе энтропии достигают локального максимума, — это "пик неопределённости", и рынок обычно выстреливает в ближайшие 1–2 свечи.

📈 Сигнал: 💸

Если после максимума энтропии появляется сильная направленная свеча, входим в сторону этой свечи.

Стоп — за ближайшим локальным минимумом/максимумом диапазона хаоса.

Тейк — 1.5–2× стоп.

import ccxt
import pandas as pd
import numpy as np
import time

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

def entropy(values):
    probs = np.bincount(values) / len(values)
    probs = probs[probs > 0]
    return -np.sum(probs * np.log2(probs))

while True:
    ohlcv = exchange.fetch_ohlcv(symbol, tf, limit=50)
    df = pd.DataFrame(ohlcv, columns=['ts','open','high','low','close','vol'])
    
    df['dir'] = np.where(df['close'] > df['open'], 1, 0)
    df['range'] = df['high'] - df['low']
    
    ent_dir = entropy(df['dir'].values)
    ent_amp = entropy(pd.qcut(df['range'], 5, labels=False).values)
    
    if ent_dir > 0.9 and ent_amp > 0.9:
        print(f"[⚡] Пик энтропии! {symbol} — рынок готов к импульсу.")
        
    time.sleep(60)

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

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

📌Sweep Reaction 🧑‍💻

💡 Идея: 🧨

Когда цена делает резкий прокол (sweep) локального минимума или максимума и мгновенно возвращается обратно в диапазон, это признак того, что:

ликвидность была собрана (сняли стопы),

крупный игрок взял объём против толпы,

импульс в противоположную сторону только начинается.

Мы ловим реакцию на этот сбор ликвидности, а не сам момент прокола.

📊 Логика стратегии: 🛠️

1. Определяем последние N свечей (например, 50) и находим локальный high/low.

2. Если текущая цена:

делает прокол локального экстремума (на X% или пунктов),

и закрывается обратно внутрь диапазона,
то это sweep.

3. После sweep:

Если был прокол низа → открываем лонг при возврате цены внутрь диапазона.

Если прокол верха → открываем шорт при возврате вниз.

4. Стоп — за хвостом свечи, тейк — середина диапазона или 2× стоп.

import ccxt
import pandas as pd
import time

exchange = ccxt.binance({
    'options': {'defaultType': 'future'}
})

symbol = "BTC/USDT"
tf = "5m"
sweep_threshold = 0.001  # 0.1%

def detect_sweep(df):
    high_range = df['high'].iloc[:-1].max()
    low_range = df['low'].iloc[:-1].min()

    last = df.iloc[-1]
    prev_close = df['close'].iloc[-2]

    # Прокол низа
    if last['low'] < low_range * (1 - sweep_threshold) and last['close'] > low_range:
        return 'long', low_range
    
    # Прокол верха
    if last['high'] > high_range * (1 + sweep_threshold) and last['close'] < high_range:
        return 'short', high_range
    
    return None, None

while True:
    ohlcv = exchange.fetch_ohlcv(symbol, tf, limit=100)
    df = pd.DataFrame(ohlcv, columns=['ts','open','high','low','close','vol'])

    signal, level = detect_sweep(df)
    if signal:
        print(f"[⚡ SWEEP DETECTED] {symbol} → {signal.upper()} | уровень: {round(level,2)}")

    time.sleep(60)

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

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

📌“Liquidity Map Generator” — Карта ликвидности в реальном времени 🧑‍💻

💡 Суть: 🧨

Этот инструмент анализирует стакан Binance Futures (USDT-M) и визуализирует уровни, где сосредоточена наибольшая ликвидность (крупные лимитные ордера).

Он помогает видеть, куда “притягивается” цена — к скоплению ликвидности (магниту).

⚙️ Что делает функция: 🛠️

1. Получает стакан ордеров (Order Book) в реальном времени.

2. Группирует ордера по диапазонам цены (например, каждые 0.1% от текущей).

3. Находит топ-зоны концентрации объёма.

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

import ccxt
import numpy as np
import pandas as pd
import time
from rich import print
from rich.table import Table

def liquidity_map(symbol="BTC/USDT", bins=20, limit=200):
    """
    Генератор карты ликвидности Binance Futures (USDT-M).
    
    :param symbol: Торговая пара (пример: 'BTC/USDT')
    :param bins: Кол-во диапазонов вокруг текущей цены
    :param limit: Глубина стакана
    """
    exchange = ccxt.binance({'options': {'defaultType': 'future'}})
    orderbook = exchange.fetch_order_book(symbol, limit=limit)
    last_price = exchange.fetch_ticker(symbol)['last']

    asks = np.array(orderbook['asks'])
    bids = np.array(orderbook['bids'])

    df_asks = pd.DataFrame(asks, columns=['price', 'volume'])
    df_bids = pd.DataFrame(bids, columns=['price', 'volume'])

    df_asks['type'] = 'ask'
    df_bids['type'] = 'bid'
    df = pd.concat([df_asks, df_bids])

    df['dist_%'] = 100 * (df['price'] - last_price) / last_price
    df['dist_bin'] = pd.cut(df['dist_%'], bins=bins)

    grouped = df.groupby(['dist_bin', 'type'])['volume'].sum().reset_index()

    # Визуализация
    table = Table(title=f"💧 Карта ликвидности {symbol} (цена: {round(last_price,2)})")
    table.add_column("Диапазон %", justify="right")
    table.add_column("Bid объём", justify="right")
    table.add_column("Ask объём", justify="right")

    for dist_bin in grouped['dist_bin'].unique():
        bid_vol = grouped[(grouped['dist_bin'] == dist_bin) & (grouped['type'] == 'bid')]['volume'].sum()
        ask_vol = grouped[(grouped['dist_bin'] == dist_bin) & (grouped['type'] == 'ask')]['volume'].sum()
        if bid_vol + ask_vol > 0:
            table.add_row(str(dist_bin), f"{bid_vol:.2f}", f"{ask_vol:.2f}")

    print(table)

# 🔍 Пример вызова
if __name__ == "__main__":
    while True:
        liquidity_map("BTC/USDT")
        time.sleep(15)

#инструмент

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

📌“Liquidity Gravity Map” - (Карта гравитации ликвидности) 🧑‍💻

💡 Идея: 🧨

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

Инструмент визуализирует “гравитационные центры цены” в реальном времени: где находится основная масса ликвидности и насколько сильно она “тянет” цену.

🧠 Применение: 💸

Определить, куда с большей вероятностью пойдёт цена (в сторону сильной ликвидности).

Найти “магниты цены” — уровни, где часто происходят отскоки или ложные пробои.

Использовать для входа в направлении притяжения или для контр-трейдов от зон концентрации ордеров.

import ccxt
import numpy as np
import time

def liquidity_gravity(symbol="BTC/USDT", depth_limit=100):
    exchange = ccxt.binance({'options': {'defaultType': 'future'}})
    orderbook = exchange.fetch_order_book(symbol, limit=depth_limit)

    bids = np.array(orderbook['bids'])
    asks = np.array(orderbook['asks'])
    mid_price = (asks[0, 0] + bids[0, 0]) / 2

    def gravity_side(side, direction):
        g_total = 0
        for price, volume in side:
            distance = abs(price - mid_price)
            if distance == 0: 
                continue
            g_total += volume / (distance ** 2)
        if direction == "up":
            return g_total, np.average([p for p, _ in side], weights=[v for _, v in side])
        else:
            return g_total, np.average([p for p, _ in side], weights=[v for _, v in side])

    g_bids, bid_center = gravity_side(bids, "up")
    g_asks, ask_center = gravity_side(asks, "down")

    bias = "UP" if g_bids > g_asks else "DOWN"
    gravity_center = (bid_center * g_bids + ask_center * g_asks) / (g_bids + g_asks)

    print(f"\n📊 {symbol}")
    print(f"Текущая цена: {mid_price:.2f}")
    print(f"Центр гравитации: {gravity_center:.2f}")
    print(f"Сила гравитации BID: {g_bids:.2f}")
    print(f"Сила гравитации ASK: {g_asks:.2f}")
    print(f"👉 Преобладание: {bias}")

if __name__ == "__main__":
    while True:
        try:
            liquidity_gravity("BTC/USDT", 100)
            time.sleep(5)
        except Exception as e:
            print("Ошибка:", e)
            time.sleep(2)

#инструмент

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

📌“Micro-Rebound Hunter” - (Охотник за микровозвратами) 🧑‍💻

💡 Идея: 🧨

Цена на спотовом рынке Binance часто делает быстрые ложные пробои (wicks) при повышенной волатильности, особенно на младших таймфреймах.

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

⚙️ Логика входа: 🛠️

1. Находим свечу, где:

диапазон high - low ≥ X% (например, 0.5%)

цена закрытия находится в нижних 20% диапазона (для лонга)

либо в верхних 20% диапазона (для шорта)

2. Входим в противоположную сторону импульса, если следующая свеча подтверждает слабость (не обновляет экстремум).

3. Тейк фиксированный (например, +0.2%), стоп за экстремумом предыдущей свечи.

import ccxt
import pandas as pd
import time

def micro_rebound_hunter(symbol="BTC/USDT", timeframe="1m", percent_range=0.5, tp=0.25, sl=0.2):
    exchange = ccxt.binance()
    bars = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=200)
    df = pd.DataFrame(bars, columns=['time','open','high','low','close','vol'])
    df['time'] = pd.to_datetime(df['time'], unit='ms')
    
    last = df.iloc[-1]
    prev = df.iloc[-2]
    body_range = (last['high'] - last['low']) / last['low'] * 100

    if body_range >= percent_range:
        # Потенциальный лонг
        if last['close'] <= last['low'] + 0.2 * (last['high'] - last['low']):
            print(f"🟢 [{symbol}] Потенциальный ЛОНГ на {last['close']}")
            print(f"Стоп: {last['low']:.2f}, Тейк: {last['close']*(1+tp/100):.2f}")
        
        # Потенциальный шорт
        elif last['close'] >= last['high'] - 0.2 * (last['high'] - last['low']):
            print(f"🔴 [{symbol}] Потенциальный ШОРТ на {last['close']}")
            print(f"Стоп: {last['high']:.2f}, Тейк: {last['close']*(1-tp/100):.2f}")

# 🔁 Запуск цикла сканера
if __name__ == "__main__":
    while True:
        try:
            micro_rebound_hunter("BTC/USDT")
            time.sleep(30)
        except Exception as e:
            print("Ошибка:", e)
            time.sleep(5)

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

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