📌"Перегрев стакана"🧑‍💻

🔑 Идея: 🧨

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

1. Если стена настоящая → цена отскакивает.

2. Если стена фейковая (spoofing) → цену пробивают, и движение ускоряется.

👉 Мы используем это как торговый сигнал.

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

1. Подключаемся к ордербуку.

2. Считаем суммарный объём в первых X уровнях стакана.

3. Если на одной стороне (buy/sell) объём резко > среднего (например, ×3), фиксируем «перегрев».

4. Дальше смотрим реакцию цены:

- если цена стоит и отскакивает → торгуем в сторону стены,

- если цена пробивает → торгуем в сторону пробоя.

import websocket, json

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

def on_message(ws, msg):
    data = json.loads(msg)
    bids = [(float(p), float(q)) for p, q in data["bids"]]
    asks = [(float(p), float(q)) for p, q in data["asks"]]

    total_bids = sum(q for _, q in bids[:5])
    total_asks = sum(q for _, q in asks[:5])

    imbalance = total_bids / (total_bids + total_asks)

    print(f"Buy: {total_bids:.1f} | Sell: {total_asks:.1f} | Баланс: {imbalance:.2f}")

    if total_bids > total_asks * 3:
        print("🟢 Стена покупателей — возможный отскок вверх!")
    elif total_asks > total_bids * 3:
        print("🔴 Стена продавцов — возможный слив вниз!")

def on_open(ws):
    print("✅ Стратегия 'Перегрев стакана' запущена")

ws = websocket.WebSocketApp(DEPTH_URL, on_message=on_message, on_open=on_open)
ws.run_forever()

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

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

📌"Order Replay" - (реплей ордеров в реальном времени) 🧑‍💻

🔑 Идея: 🧨

Большинство трейдеров видят только свечи и графики, но не понимают, как именно строится цена внутри свечи.
Этот инструмент позволяет «прокрутить» рынок назад и проиграть движение цены с точностью до сделки.

👉 Можно исследовать:

- как цена строила импульс,

- где были «резкие вбросы» объёма,

- как формировался диапазон свечи.

📌 Польза: 💸

- Анализ микроструктуры рынка.

- Поиск аномальных сделок и скрытых манипуляций.

- Тестирование алгоритмов, которые зависят от скорости движения цены, а не только от свечей.

import time
import random

# имитация тиков (обычно берём с биржи через websocket)
ticks = [100 + random.uniform(-0.5, 0.5) for _ in range(200)]

def replay(ticks, speed=0.05):
    print("▶ Начинаем реплей ордеров...")
    for i, price in enumerate(ticks):
        print(f"Tick {i+1}: {price:.2f}")
        time.sleep(speed)
    print("⏹ Реплей окончен.")

replay(ticks, speed=0.1)

#инструмент

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

📌"Market Stress Meter" - (измеритель рыночного стресса) 🧑‍💻

🔑 Идея: 🧨

Вместо индикаторов, мы оцениваем напряжённость рынка через поведение цены и объёмов.
Рынок в «стрессе», когда:

свечи становятся длинными,

объёмы резко растут,

спред (High–Low) увеличивается относительно среднего.

👉 Такой инструмент помогает понять, когда рынок готов к импульсу или коррекции.

📌 Что делает: 🛠️

1. Считает «стресс-индекс» как взвешенную комбинацию:

- отклонение текущего диапазона свечи от среднего,

- рост объёма,

- скорость изменения цены.

2. Выводит предупреждение, если индекс выше порога.

3. Можно использовать как фильтр для стратегий: торговать только при «высоком стрессе» или наоборот — в спокойные периоды


Интерпретация: 🚀

StressIndex > 1.5 → рынок в состоянии «стресса» (готов к импульсу).

StressIndex < 1 → рынок спокоен, можно торговать mean reversion.

import pandas as pd
import ccxt

# === параметры ===
symbol = "BTC/USDT"
timeframe = "15m"
limit = 200

binance = ccxt.binance()
ohlcv = binance.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)

df = pd.DataFrame(ohlcv, columns=["ts","Open","High","Low","Close","Volume"])
df["Range"] = df["High"] - df["Low"]

# средние значения
avg_range = df["Range"].rolling(20).mean()
avg_vol = df["Volume"].rolling(20).mean()

# стресс-индекс
df["StressIndex"] = (df["Range"]/avg_range + df["Volume"]/avg_vol) / 2

# сигнал
threshold = 1.5
df["StressSignal"] = df["StressIndex"] > threshold

print(df[["ts","Close","StressIndex","StressSignal"]].tail(20))

#инструмент

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

📌"Auction Range Breakout" - (прорыв аукционного диапазона)🧑‍💻

🔑 Идея: 🧨

Рынок часто ведёт себя как аукцион:

внутри дня формируется основной диапазон справедливой цены (где проходят торги),

выход за его границы часто запускает сильное движение (импульс).

👉 Мы фиксируем «аукционный диапазон» (fair range) и торгуем пробой.

📌 Логика: 🛠️

1. Берём первые X часов (например, 4ч после открытия дня).

2. Определяем диапазон High–Low за этот период → это наша «аукционная зона».

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

4. Стоп внутри диапазона, тейк = ширина диапазона * 1.5–2.

import ccxt
import pandas as pd
from datetime import datetime, timedelta

# === ПАРАМЕТРЫ ===
symbol = "BTC/USDT"
timeframe = "1h"
lookback_days = 5       # сколько дней анализируем
session_hours = 4       # аукционный диапазон (первые 4 часа)

# === API (можно добавить ключи для реальной торговли) ===
binance = ccxt.binance({
    "enableRateLimit": True
})

# === ЗАГРУЗКА СВЕЧЕЙ ===
since = binance.parse8601((datetime.utcnow() - timedelta(days=lookback_days)).isoformat())
ohlcv = binance.fetch_ohlcv(symbol, timeframe=timeframe, since=since)

df = pd.DataFrame(ohlcv, columns=["timestamp", "Open", "High", "Low", "Close", "Volume"])
df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
df.set_index("timestamp", inplace=True)
df["hour"] = df.index.hour

# === ЛОГИКА АУКЦИОННОГО ПРОБОЯ ===
signals = []
for day, df_day in df.groupby(df.index.date):
    session = df_day[df_day["hour"] < session_hours]
    if session.empty:
        continue
    low, high = session["Low"].min(), session["High"].max()

    for i in range(session_hours, len(df_day)):
        row = df_day.iloc[i]
        if row["Close"] > high:
            signals.append((row.name, "LONG", high, (high - low) * 2))
            break
        elif row["Close"] < low:
            signals.append((row.name, "SHORT", low, (high - low) * 2))
            break

# === ВЫВОД СИГНАЛОВ ===
print("📊 Сигналы стратегии Auction Breakout:")
for ts, side, stop, target in signals:
    print(f"{ts} | {side} | Стоп: {stop:.2f} | Тейк: {target:.2f}")

# === ДЛЯ РЕАЛЬНОЙ ТОРГОВЛИ ===
# пример ордера:
# order = binance.create_order(symbol, "market", "buy", 0.001)
# print(order)

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

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

📌"Pattern Hunter" - (охотник за уникальными паттернами цены) 🧑‍💻

🔑 Идея: 🧨

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

👉 Этот инструмент автоматически ищет повторяющиеся последовательности свечей (например, 3–5 подряд), чтобы находить статистически значимые закономерности.

📌 Что делает: 🛠️

1. Берёт историю свечей.

2. Кодирует их в паттерны (например, U – рост, D – падение, N – нейтральная).

3. Считает частоту появления паттернов.

4. Строит статистику: как часто после каждого паттерна цена растёт или падает.

import ccxt
import pandas as pd

# === Параметры ===
symbol = "BTC/USDT"
timeframe = "15m"
limit = 500
pattern_len = 3

binance = ccxt.binance()
ohlcv = binance.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)

df = pd.DataFrame(ohlcv, columns=["ts","Open","High","Low","Close","Volume"])

# кодируем свечи
df["dir"] = df.apply(lambda r: "U" if r["Close"]>r["Open"] else ("D" if r["Close"]<r["Open"] else "N"), axis=1)

# формируем паттерны
patterns = []
outcomes = []
for i in range(len(df)-pattern_len):
    pat = "".join(df["dir"].iloc[i:i+pattern_len])
    next_move = "UP" if df["Close"].iloc[i+pattern_len] > df["Close"].iloc[i+pattern_len-1] else "DOWN"
    patterns.append(pat)
    outcomes.append(next_move)

stats = pd.DataFrame({"pattern":patterns,"outcome":outcomes})
result = stats.groupby(["pattern","outcome"]).size().unstack(fill_value=0)

print("🔎 Найденные паттерны и их исходы:")
print(result)

#инструмент

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

📌"Exhaustion Wick Reversal" - (разворот по свечам-выбросам)🧑‍💻

🔑 Идея: 🧨

Часто рынок делает резкий «выброс» цены — длинный хвост свечи (wick), за которым следует разворот.
Это показывает исчерпание агрессивных участников:

длинный нижний хвост = продавцы выдохлись → сигнал на лонг,

длинный верхний хвост = покупатели выдохлись → сигнал на шорт.

📌 Логика входа 💸

1. Берём свечи (например, 15m или 1h).

2. Если нижний хвост > 2× тела свечи и свеча закрылась выше середины → LONG.

3. Если верхний хвост > 2× тела и закрытие ниже середины → SHORT.

4. Стоп-лосс за хвостом.

5. Тейк-профит = 1.5–2× риск.

import pandas as pd
import ccxt

# === Параметры ===
symbol = "BTC/USDT"
timeframe = "15m"
limit = 300

binance = ccxt.binance()
ohlcv = binance.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)

df = pd.DataFrame(ohlcv, columns=["ts","Open","High","Low","Close","Volume"])

def wick_reversal(row):
    body = abs(row["Close"] - row["Open"])
    upper_wick = row["High"] - max(row["Close"], row["Open"])
    lower_wick = min(row["Close"], row["Open"]) - row["Low"]

    # long-сигнал
    if lower_wick > 2 * body and row["Close"] > (row["Open"] + row["Low"]) / 2:
        return "LONG"
    # short-сигнал
    if upper_wick > 2 * body and row["Close"] < (row["Open"] + row["High"]) / 2:
        return "SHORT"
    return None

df["Signal"] = df.apply(wick_reversal, axis=1)

print(df[["ts","Open","High","Low","Close","Signal"]].dropna())

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

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

📌"Impulse & Absorption" - (импульс и поглощение) 🧑‍💻

🔑 Идея: 🧨

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

👉 Логика:🛠️

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

- рынок «разворачивается на пустоте».

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

1. Импульсная свеча — тело больше 2× среднего за N свечей.

2. Поглощение — следующая свеча закрывается в противоположную сторону и перекрывает минимум 70% предыдущего тела.

3. Вход в направлении свечи-поглощения.

4. Стоп за экстремумом импульсной свечи.

5. Тейк-профит = 2× риск или до локального уровня.

import ccxt
import pandas as pd

# === параметры ===
symbol = "BTC/USDT"
timeframe = "15m"
limit = 300

binance = ccxt.binance()
ohlcv = binance.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
df = pd.DataFrame(ohlcv, columns=["ts","Open","High","Low","Close","Volume"])

# среднее тело свечи
df["body"] = abs(df["Close"] - df["Open"])
avg_body = df["body"].rolling(20).mean()

signals = []
for i in range(21, len(df)):
    body = df["body"].iloc[i-1]
    if body > 2 * avg_body.iloc[i-1]:
        prev_open, prev_close = df["Open"].iloc[i-1], df["Close"].iloc[i-1]
        curr_open, curr_close = df["Open"].iloc[i], df["Close"].iloc[i]

        # бычий импульс + медвежье поглощение
        if prev_close > prev_open and curr_close < curr_open and curr_close < (prev_open + 0.3*(prev_close-prev_open)):
            signals.append((df["ts"].iloc[i], "SHORT"))

        # медвежий импульс + бычье поглощение
        elif prev_close < prev_open and curr_close > curr_open and curr_close > (prev_open - 0.3*(prev_close-prev_open)):
            signals.append((df["ts"].iloc[i], "LONG"))

print("📊 Сигналы стратегии:")
for s in signals:
    print(s)

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

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

📌Order Book Resilience Index (OBRI) - (индекс устойчивости книги — насколько быстро и в каком объёме книга восстанавливается после потребления ликвидности) 🧑‍💻

📌 Идея (коротко): 🧨

Когда маркет-ордеры «съедают» уровень в книге, важно знать: заполнилась ли книга снова (resilient) или осталась пустой (vulnerable).

Быстрая регенерация — маркетмейкеры/лимитники возвращаются → движение менее рискованно.

Долгая/слабая регенерация — малый запас лимитов → пробой/импульс может продолжиться с меньшим сопротивлением.

OBRI измеряет скорость и долю восстановления объёма в локальной зоне (±X% от mid) после искусственного (или естественного) потребления уровня. Выдаёт индекс 0..1: 1 — полностью быстрый откат/восстановление; 0 — книга «пустая».

📌 Чем полезен: 💸

Фильтр для исполнения (если OBRI низкий → дробить ордера, не давать market-impact).

Фильтр для пробойных стратегий (низкий OBRI → пробой вероятнее и продолжительнее).

Риск-метрика: высокая вероятность сломанных уровней → повышать осторожность.

#инструмент

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

📌"Time-of-Absorption" (TOA) - (стратегия на основе времени удержания цены после агрессивного удара по стакану) 🧑‍💻

🔑 Идея: 🧨

На реальном рынке важно не только то, что цену пробили, а как долго она там удержалась.

Если крупный рыночный ордер выбил уровень, но цена сразу вернулась обратно — это ложный пробой.

Если цена удерживается и объём лимитов «поглощает» последующие удары — это сигнал к продолжению движения.

То есть время поглощения (time-of-absorption) выступает главным фильтром.

⚙️ Алгоритм: 🛠️

1. Мониторим стакан и поток сделок (trades).

2. Когда цена делает импульс (съедается заметный уровень в стакане, ≥ X% локальной глубины) → фиксируем новый уровень.

3. Засекаем время удержания:

Если в течение T_hold секунд цена не возвращается за пробитый уровень → считаем уровень «поглощённым».

Если цена откатывает назад до старого диапазона быстрее T_fail → ложный пробой.

4. Торговое правило:

Лонг, если пробит уровень сверху вниз (bid side) и цена удержалась выше.

Шорт, если пробит уровень снизу вверх (ask side) и цена удержалась ниже.

5. Stop-loss = за пробитым уровнем.

6. Take-profit = риск:прибыль 1:2 или по достижении нового ближайшего кластера ликвидности.

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

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

📌"Trade Memory Tracker" - (Трекер повторяющихся ошибок и паттернов трейдера) 🧑‍💻

🔑 Идея: 🧨

Многие трейдеры совершают одни и те же ошибки:

ранний выход,

перезаход,

вход без сигнала,

завышенный риск.

👉 Инструмент автоматически ведёт журнал сделок и выявляет повторяющиеся ошибки/паттерны трейдера, которые стоят ему денег.

📌 Логика работы: 🛠️

1. После каждой сделки трейдер сохраняет результат (P/L, направление, причина входа).

2. Инструмент анализирует историю:

средний результат по типу сигнала,

где чаще всего фиксируется убыток,

какие часы/дни дают лучший результат.

3. Генерируется отчёт: «95% убыточных сделок совершаются в азиатскую сессию», или «перезаход после стопа всегда минусовой».

import pandas as pd

# История сделок трейдера
data = [
    {"time": "2025-09-01 12:00", "signal": "breakout", "result": -50},
    {"time": "2025-09-01 15:00", "signal": "retest", "result": +120},
    {"time": "2025-09-02 10:00", "signal": "impulse", "result": -30},
    {"time": "2025-09-02 18:00", "signal": "breakout", "result": -40},
    {"time": "2025-09-03 14:00", "signal": "retest", "result": +90},
]

df = pd.DataFrame(data)
df['time'] = pd.to_datetime(df['time'])
df['day'] = df['time'].dt.day_name()
df['hour'] = df['time'].dt.hour

# Анализ по сигналам
signal_stats = df.groupby('signal')['result'].agg(['count','mean','sum'])

# Анализ по времени суток
hour_stats = df.groupby('hour')['result'].mean()

# Общий вывод
print("📊 Ошибки и паттерны трейдера:\n")
print("По сигналам:\n", signal_stats)
print("\nПо часам:\n", hour_stats)

#инструмент

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

📌Grid Break Scalper - (Сеточный пробой) 🧑‍💻

📌Идея: 🧨

- Строим сетку лимитных ордеров выше и ниже текущей цены (например через каждые 0.2–0.5%).

- Когда цена «цепляет» ордер снизу (бай) → закрываем его на ближайшем возврате вверх (+0.2–0.3%).

- Когда цена «цепляет» ордер сверху (селл) → закрываем его на возврате вниз.

- Получается много мелких сделок в обе стороны.

- В отличие от классического грид-бота, тут не удерживаем «пирамиду» долго, а стараемся быстро закрывать в плюс → больше оборота, больше сделок.

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

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

📌"Market Replay Console" - (реплей рынка прямо в терминале) 🧑‍💻

📌 Идея: 🧨

Большинство трейдеров анализируют рынок по истории свечей или графикам, но редко «проживают» движение в реальном времени.

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

Это даёт:💸

- тренировку реакции на движения без риска;

- тестирование стратегий «на ощущениях»;

- поиск паттернов в динамике, а не только на статичном графике.

🔑 Особенности: 🛠️

- Работает в консоли (без графики, всё текстом).

- Подгружает историю цен с Binance через ccxt.

- Симулирует «живой рынок» с задержкой между свечами.

- Можно поставить паузу или ускорить «прокрутку».

import ccxt
import time

# Настройка
exchange = ccxt.binance({'enableRateLimit': True})
symbol = "BTC/USDT"
timeframe = "1m"
limit = 100  # кол-во свечей в реплее
delay = 0.5  # секунда между свечами (можно менять для ускорения)

# Загружаем историю
ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)

print(f"▶ Реплей {symbol}, таймфрейм {timeframe}, свечей: {limit}\n")

for candle in ohlcv:
    ts, open_, high, low, close, vol = candle
    print(f"🕒 Цена {close:.2f} | O:{open_:.2f} H:{high:.2f} L:{low:.2f} V:{vol:.2f}")
    time.sleep(delay)

#инструмент

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

📌"Pattern Replay Trainer" - (тренажёр распознавания рыночных паттернов в консоли)🧑‍💻

📌 Идея: 🧨

Вместо статичных графиков трейдер получает рандомные фрагменты истории цены (например, по 30 свечей).
Он не знает, что будет дальше, и должен принять решение: лонг / шорт / пропуск.
После выбора программа «открывает» будущее (следующие свечи) и показывает, был ли трейдер прав.

Это позволяет:

- тренировать интуицию и скорость реакции;

- оттачивать свои правила входа/выхода;

- «проживать рынок» как в реальности, но без риска.

import ccxt
import pandas as pd
import random
import time

exchange = ccxt.binance({'enableRateLimit': True})
symbol = "BTC/USDT"
timeframe = "1m"
limit = 500

# Загружаем историю
ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
df = pd.DataFrame(ohlcv, columns=["ts","open","high","low","close","volume"])
df["ts"] = pd.to_datetime(df["ts"], unit="ms")

def replay_trainer(window=30, future=10):
    start = random.randint(0, len(df) - window - future - 1)
    sample = df.iloc[start:start+window]
    future_data = df.iloc[start+window:start+window+future]

    print("\n🕒 Новый фрагмент истории!")
    for _, row in sample.iterrows():
        print(f"{row['ts']} | O:{row['open']:.2f} C:{row['close']:.2f}")

    choice = input("\nТвой выбор (long/short/skip): ").strip().lower()

    print("\n📊 Будущее:")
    for _, row in future_data.iterrows():
        print(f"{row['ts']} | O:{row['open']:.2f} C:{row['close']:.2f}")
        time.sleep(0.2)

    first = sample["close"].iloc[-1]
    last = future_data["close"].iloc[-1]
    change = (last - first) / first * 100

    if choice == "long":
        print(f"\n✅ Результат LONG: {change:.2f}%")
    elif choice == "short":
        print(f"\n✅ Результат SHORT: {-change:.2f}%")
    else:
        print(f"\n⏸ Пропуск | рынок изменился на {change:.2f}%")

if __name__ == "__main__":
    while True:
        replay_trainer()
        if input("\nПродолжить? (y/n): ").strip().lower() != "y":
            break

#инструмент

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

📌"Flash Drop Catcher" - (ловим микро-обвалы и быстрые 🧑‍💻 возвраты)

📌 Идея: 🧨

На крипторынке часто происходят мгновенные резкие проливы (1–3% за минуту), после которых следует отскок.

Эта стратегия пытается поймать такие движения:

- Если цена падает слишком быстро за короткое время → входим в лонг.

- Если цена быстро отскакивает после падения → фиксируем профит.

- Если отскока нет → фиксируем небольшой стоп.

🔑 Логика входа и выхода:💸

- Берём 1-минутные свечи.

- Если цена закрывается ниже на >1% по сравнению со средней ценой последних 5 свечей → покупаем.

- Если после входа цена вырастает хотя бы на +0.6% → продаём.

- Если цена падает ещё на -0.5% → стоп-лосс.

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

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

📌"Trade Journal AutoLogger" - (автоматический торговый дневник для сделок с Binance через ccxt) 🧑‍💻

📌 Идея: 🧨

У большинства трейдеров нет дисциплины вести дневник сделок вручную.

Этот инструмент делает всё сам:

- собирает сделки с Binance (история + новые ордера),

- сохраняет их в CSV,

- считает прибыль/убыток, комиссии, % доходности,

- формирует «дневник» трейдера.

import ccxt
import pandas as pd
from datetime import datetime
import time

# ⚠️ Укажи свои API ключи Binance
api_key = "YOUR_API_KEY"
api_secret = "YOUR_API_SECRET"

exchange = ccxt.binance({
    "apiKey": api_key,
    "secret": api_secret,
    "enableRateLimit": True
})

def fetch_trades(symbol="BTC/USDT", since=None, limit=50):
    try:
        trades = exchange.fetch_my_trades(symbol, since=since, limit=limit)
        return trades
    except Exception as e:
        print("Ошибка:", e)
        return []

def log_trades_to_csv(symbol="BTC/USDT", filename="trade_journal.csv"):
    trades = fetch_trades(symbol)
    if not trades:
        print("Нет новых сделок")
        return

    df = pd.DataFrame(trades)
    df["datetime"] = pd.to_datetime(df["timestamp"], unit="ms")
    df = df[["datetime", "symbol", "side", "price", "amount", "cost", "fee"]]

    try:
        old = pd.read_csv(filename)
        df = pd.concat([old, df]).drop_duplicates()
    except FileNotFoundError:
        pass

    df.to_csv(filename, index=False)
    print(f"💾 Журнал обновлён: {len(df)} сделок сохранено")

if __name__ == "__main__":
    print("▶ Авто-журнал сделок запущен (Ctrl+C для выхода)")
    while True:
        log_trades_to_csv("BTC/USDT")
        time.sleep(60)  # обновляем каждую минуту

#инструмент

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

📌"Impulse Reversal Hunter" - (охота на импульсные всплески и быстрый откат) 🧑‍💻

📌 Идея: 🧨

На крипторынке часто случаются короткие импульсы:

цена за 1–3 минуты выстреливает на +1–2%,

но затем так же быстро откатывается.

Большинство участников опаздывают и входят в конце импульса → мы играем против них.

🔑 Логика: 🛠️

1. Берём 1-минутные свечи.

2. Если текущая свеча закрылась выше предыдущей на ≥1%, считаем это импульсом.

3. Входим в шорт на следующей свече.

4. Закрываем при откате -0.5% от цены входа.

5. Если импульс продолжился и цена выросла ещё на +0.5% от входа → стоп-лосс.

import ccxt
import pandas as pd
import time

exchange = ccxt.binance({'enableRateLimit': True})
symbol = "BTC/USDT"
timeframe = "1m"

print(f"🚀 Старт стратегии 'Impulse Reversal Hunter' для {symbol}")

def check_impulse(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=3)
    df = pd.DataFrame(ohlcv, columns=["ts","open","high","low","close","volume"])
    prev = df.iloc[-2]["close"]
    last = df.iloc[-1]["close"]

    change = (last - prev) / prev * 100
    if change >= 1.0:
        return ("SHORT", last, change)
    return None

while True:
    signal = check_impulse(symbol)
    if signal:
        side, price, change = signal
        print(f"⚡️ Сигнал: {side} @ {price:.2f} (импульс {change:.2f}%)")
    time.sleep(60)

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

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

📌«Market Rhythm Analyzer» - (анализатор ритма рынка в реальном времени) 🧑‍💻

📌 Идея: 🧨

Рынок двигается импульсами: серия быстрых свечей → пауза → новый рывок.

Этот «ритм» можно измерить и использовать:

- для фильтрации сделок (не входить, если рынок «устал»),

- для поиска фаз накопления/импульса,

- для оценки волатильности без индикаторов.

🔑 Как работает: 🛠️

1. Считывает поток цен с Binance.

2. Измеряет средний интервал между движениями цены (например, каждые 0.1% изменения).

3. Строит в консоли или файле «пульсограмму» рынка.

4. Если ритм ускоряется → значит рынок в фазе импульса.

5. Если ритм замедляется → значит рынок в накоплении/передышке.

import ccxt
import time
from collections import deque

symbol = "BTC/USDT"
price_step = 0.001   # 0.1% шаг для фиксации изменения
window = 10          # усреднение по N шагам
exchange = ccxt.binance()

last_price = None
last_event_time = None
intervals = deque(maxlen=window)

while True:
    try:
        ticker = exchange.fetch_ticker(symbol)
        price = ticker['last']

        if last_price is None:
            last_price = price
            last_event_time = time.time()
            continue

        # проверяем шаг
        if abs(price - last_price) / last_price >= price_step:
            now = time.time()
            interval = now - last_event_time
            intervals.append(interval)
            last_event_time = now
            last_price = price

            if len(intervals) == window:
                avg_interval = sum(intervals) / len(intervals)
                print(f"📊 {symbol} | Средний ритм: {avg_interval:.2f} сек/шаг")

                if avg_interval < 5:
                    print("⚡ Рынок в импульсе!")
                elif avg_interval > 15:
                    print("😴 Рынок в накоплении...")
                else:
                    print("📈 Нормальный ритм.")
        time.sleep(1)

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

#инструмент

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

📌«Фазовый импульс»🧑‍💻

🔑 Идея: 🧨

Цена на рынке не двигается равномерно — она идёт фазами:

1. Периоды тихого накопления (малый диапазон, сжатие).

2. Резкий импульс (вверх или вниз).

3. Затухание и коррекция, после чего цикл повторяется.

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

📜 Правила стратегии: 🛠️

📌Вход: 💸

1. Следим за ценой на 1m или 5m таймфрейме.

2. Если диапазон за последние N свечей (например 20) меньше X% от средней дневной волатильности → значит, идёт накопление.

3. Ставим два стоп-ордера:

Buy Stop чуть выше накопления,

Sell Stop чуть ниже.

📌Выход: 💸

Если активирован Buy → цель = 1.5–2× ширина накопления.

Если активирован Sell → то же самое.

Второй ордер автоматически отменяется (OCO-логика).

import ccxt
import time
import statistics

# === Настройки ===
symbol = "BTC/USDT"
timeframe = "5m"
lookback = 20         # кол-во свечей для поиска накопления
accum_threshold = 0.004  # порог узости (0.4% от цены)
take_profit_mult = 2     # цель в x ширины диапазона
sleep_time = 30          # задержка между проверками (сек)

exchange = ccxt.binance()

def fetch_candles():
    candles = exchange.fetch_ohlcv(symbol, timeframe, limit=lookback)
    return candles

def analyze(candles):
    highs = [c[2] for c in candles]
    lows = [c[3] for c in candles]

    max_h = max(highs)
    min_l = min(lows)
    rng = max_h - min_l
    mid = (max_h + min_l) / 2
    last_close = candles[-1][4]

    # проверка на "накопление"
    if rng / last_close < accum_threshold:
        buy_level = max_h * 1.001  # чуть выше
        sell_level = min_l * 0.999 # чуть ниже
        target_up = buy_level + rng * take_profit_mult
        target_down = sell_level - rng * take_profit_mult

        return {
            "accumulation": True,
            "range": rng,
            "buy": buy_level,
            "sell": sell_level,
            "target_up": target_up,
            "target_down": target_down,
            "last_close": last_close
        }
    return {"accumulation": False}

def main():
    while True:
        try:
            candles = fetch_candles()
            signal = analyze(candles)

            if signal["accumulation"]:
                print(f"\n📊 Найдено накопление по {symbol}")
                print(f"   Диапазон: {signal['range']:.2f} USDT")
                print(f"   Цена сейчас: {signal['last_close']:.2f}")
                print(f"   👉 Buy Stop: {signal['buy']:.2f}, цель: {signal['target_up']:.2f}")
                print(f"   👉 Sell Stop: {signal['sell']:.2f}, цель: {signal['target_down']:.2f}")
            else:
                print(f"{symbol}: нет накопления...")

        except Exception as e:
            print("Ошибка:", e)

        time.sleep(sleep_time)

if __name__ == "__main__":
    main()

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

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

📌«Spread Pulse Monitor» - (мониторинг пульса спреда в реальном времени) 🧑‍💻

📌 Идея: 🧨

Спред (разница между bid и ask) — живой индикатор ликвидности и настроения рынка.
Чем спред:

уже → выше ликвидность, часто перед сильным движением,

шире → паника/низкая ликвидность, высокий риск.

Инструмент отслеживает «дыхание» спреда и выводит сигналы.

🔑 Функции: 🛠️

1. Подключается к Binance (через ccxt).

2. Каждую секунду берёт order_book по выбранной паре.

3. Считает:

текущий спред в %

средний спред за последние N минут

«пульс» (расширяется или сужается).

4. Печатает сигналы:

⚡ «Спред резко сжался — возможен импульс!»

🚨 «Спред расширился — осторожно, низкая ликвидность».

import ccxt
import time
from collections import deque

symbol = "BTC/USDT"
exchange = ccxt.binance()
window = 20  # усреднение по N точкам
spread_history = deque(maxlen=window)

def get_spread():
    order_book = exchange.fetch_order_book(symbol, limit=5)
    bid = order_book['bids'][0][0]
    ask = order_book['asks'][0][0]
    spread = (ask - bid) / bid
    return spread, bid, ask

while True:
    try:
        spread, bid, ask = get_spread()
        spread_history.append(spread)
        avg_spread = sum(spread_history) / len(spread_history)

        print(f"{symbol} | Bid: {bid:.2f} Ask: {ask:.2f} | Спред: {spread*100:.3f}% (средн: {avg_spread*100:.3f}%)")

        if spread < avg_spread * 0.5:
            print("⚡ Спред резко сжался — возможен импульс!")
        elif spread > avg_spread * 2:
            print("🚨 Спред расширился — осторожно, низкая ликвидность!")
        
        time.sleep(1)
    except Exception as e:
        print("Ошибка:", e)
        time.sleep(5)

#инструмент

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

📌«Перехват агрессора»🧑‍💻

📌 Идея: 🧨

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

Мы ловим момент, когда агрессор «перегнал цену», и зарабатываем на откате.

🔑 Правила: ❗

Условие входа (шорт):

1. Находим серию из 3+ свечей подряд в одну сторону.

2. Суммарное движение ≥ 0.8–1.2% за короткое время (1–5m).

3. После серии ждём маленькую свечу или паузу.

4. Входим в противоположную сторону (шорт).

Условие для лонга:

Зеркальные правила (сильное падение, затем откат вверх).

Выход:💸

Take Profit = 0.5–0.7 от движения агрессора.

Stop Loss = за экстремумом серии.

import ccxt
import time

# === Настройки ===
symbol = "BTC/USDT"
timeframe = "1m"
lookback = 20              # сколько свечей загружаем
min_series = 3             # минимальное число свечей подряд
impulse_threshold = 0.01   # суммарное движение (1%)
sleep_time = 30            # задержка проверки (сек)

exchange = ccxt.binance()

def fetch_candles():
    return exchange.fetch_ohlcv(symbol, timeframe, limit=lookback)

def detect_aggressor(candles):
    closes = [c[4] for c in candles]
    opens = [c[1] for c in candles]

    # определяем направление каждой свечи
    directions = [1 if c > o else -1 for o, c in zip(opens, closes)]
    last_dir = directions[-1]

    # считаем подряд идущие свечи
    streak = 1
    for d in directions[-2::-1]:
        if d == last_dir:
            streak += 1
        else:
            break

    if streak >= min_series:
        total_move = (closes[-1] - opens[-streak]) / opens[-streak]
        if abs(total_move) >= impulse_threshold:
            return {
                "direction": "long" if last_dir > 0 else "short",
                "streak": streak,
                "move_pct": total_move * 100,
                "entry": closes[-1],
                "tp": closes[-1] - (total_move / 2) * closes[-1] if last_dir > 0 else closes[-1] + (abs(total_move) / 2) * closes[-1],
                "sl": max(closes[-streak:]) if last_dir > 0 else min(closes[-streak:])
            }
    return None

def main():
    while True:
        try:
            candles = fetch_candles()
            signal = detect_aggressor(candles)
            if signal:
                print("\n🚀 Найден паттерн 'Перехват агрессора'")
                print(f"Направление агрессора: {signal['direction']}")
                print(f"Серия свечей: {signal['streak']} | Движение: {signal['move_pct']:.2f}%")
                print(f"👉 Вход против тренда: {signal['entry']:.2f}")
                print(f"🎯 TP: {signal['tp']:.2f} | 🛑 SL: {signal['sl']:.2f}")
            else:
                print(f"{symbol}: агрессор не найден...")
        except Exception as e:
            print("Ошибка:", e)

        time.sleep(sleep_time)

if __name__ == "__main__":
    main()

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

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