📌 Ichimoku Cloud Strategy

Смысл стратегии:

Индикатор Ichimoku Cloud (Облако Ишимоку) помогает определять тренд и искать точки входа.
Состоит из 5 линий:

Tenkan-sen (быстрая линия, 9 периодов) – показывает краткосрочный тренд.

Kijun-sen (медленная линия, 26 периодов) – показывает долгосрочный тренд.

Senkou Span A & B (границы облака, 26 и 52 периода) – формируют "облако", показывающее тренд.

Chikou Span (задержанная линия, 26 периодов назад) – подтверждает тренд.

🔹 Основные сигналы входа:

Цена выше облака → бычий тренд (лонг).

Цена ниже облака → медвежий тренд (шорт).

Tenkan-sen пересекает Kijun-sen вверх → сигнал на покупку.

Tenkan-sen пересекает Kijun-sen вниз → сигнал на продажу.

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
TENKAN_PERIOD = 9
KIJUN_PERIOD = 26
SENKOU_A_PERIOD = 26
SENKOU_B_PERIOD = 52

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=SENKOU_B_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет индикатора Ишимоку
def calculate_ichimoku(df):
    tenkan_sen = (df["high"].rolling(window=TENKAN_PERIOD).max() + df["low"].rolling(window=TENKAN_PERIOD).min()) / 2
    kijun_sen = (df["high"].rolling(window=KIJUN_PERIOD).max() + df["low"].rolling(window=KIJUN_PERIOD).min()) / 2
    senkou_span_a = ((tenkan_sen + kijun_sen) / 2).shift(SENKOU_A_PERIOD)
    senkou_span_b = ((df["high"].rolling(window=SENKOU_B_PERIOD).max() + df["low"].rolling(window=SENKOU_B_PERIOD).min()) / 2).shift(SENKOU_A_PERIOD)
    return tenkan_sen.iloc[-1], kijun_sen.iloc[-1], senkou_span_a.iloc[-1], senkou_span_b.iloc[-1], df["close"].iloc[-1]

# Логика сигналов
def ichimoku_cloud_strategy():
    df = fetch_ohlcv(PAIR)
    tenkan, kijun, senkou_a, senkou_b, close_price = calculate_ichimoku(df)

    print(f"Цена: {close_price:.2f}, Tenkan-sen: {tenkan:.2f}, Kijun-sen: {kijun:.2f}")
    print(f"Облако: Senkou A: {senkou_a:.2f}, Senkou B: {senkou_b:.2f}")

    if close_price > max(senkou_a, senkou_b):
        print("📈 Цена выше облака → сильный восходящий тренд (лонг).")
    elif close_price < min(senkou_a, senkou_b):
        print("📉 Цена ниже облака → сильный нисходящий тренд (шорт).")
    elif tenkan > kijun:
        print("📈 Tenkan-sen пересек Kijun-sen вверх → сигнал на покупку.")
    elif tenkan < kijun:
        print("📉 Tenkan-sen пересек Kijun-sen вниз → сигнал на продажу.")
    else:
        print("⚡ Нет четкого сигнала.")

# Запуск
if __name__ == "__main__":
    while True:
        ichimoku_cloud_strategy()
        time.sleep(60)  # Проверка раз в минуту

#индикатор

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

📌 Market Making Bot – Маркет-мейкинг и обеспечение ликвидности

Смысл стратегии:

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

Размещает лимитные ордера по обе стороны спреда.

Зарабатывает на разнице между бидом и аском (спред).

Используется на флэтовом рынке или в низковолатильных активах.

🔹 Главная цель – покупать дешевле, продавать дороже, обеспечивая ликвидность.

🔹 Риск – сильный тренд может привести к накоплению убыточных позиций.

import ccxt
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
SPREAD = 0.1  # Размер спреда в процентах
ORDER_SIZE = 0.001  # Размер заявки
CHECK_INTERVAL = 10  # Частота проверки (секунды)

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение текущих цен бид/аск
def get_order_book(symbol):
    order_book = exchange.fetch_order_book(symbol)
    bid = order_book["bids"][0][0]  # Лучшая цена покупки
    ask = order_book["asks"][0][0]  # Лучшая цена продажи
    return bid, ask

# Логика маркет-мейкинга
def market_making_bot():
    bid, ask = get_order_book(PAIR)
    spread_value = (ask - bid) / bid * 100  # Спред в %

    # Рассчет уровней размещения ордеров
    buy_price = bid * (1 - SPREAD / 100)
    sell_price = ask * (1 + SPREAD / 100)

    print(f"Бид: {bid:.2f}, Аск: {ask:.2f}, Спред: {spread_value:.2f}%")
    print(f"📥 Разместить заявку на покупку по: {buy_price:.2f}")
    print(f"📤 Разместить заявку на продажу по: {sell_price:.2f}")

# Запуск
if __name__ == "__main__":
    while True:
        market_making_bot()
        time.sleep(CHECK_INTERVAL)

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

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

📌 Parabolic SAR Trend Following – стратегия на основе точек SAR

Смысл стратегии:

Parabolic SAR (Stop and Reverse) – это индикатор, который следит за трендом и помогает определять точки входа и выхода.

Точки SAR ниже цены → восходящий тренд (лонг).

Точки SAR выше цены → нисходящий тренд (шорт).

Используется для следования за трендом и установки стоп-лоссов.

🔹 Главное правило: Если цена пробивает SAR, это сигнал к развороту.

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
SAR_ACCELERATION = 0.02  # Начальное ускорение
SAR_MAX_ACCELERATION = 0.2  # Максимальное ускорение

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=50)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет Parabolic SAR
def calculate_sar(df):
    sar = talib.SAR(df["high"], df["low"], acceleration=SAR_ACCELERATION, maximum=SAR_MAX_ACCELERATION)
    return sar.iloc[-1], df["close"].iloc[-1]

# Логика сигналов
def parabolic_sar_strategy():
    df = fetch_ohlcv(PAIR)
    sar, close_price = calculate_sar(df)

    print(f"Цена: {close_price:.2f}, SAR: {sar:.2f}")

    if close_price > sar:
        print("📈 SAR ниже цены → восходящий тренд (лонг).")
    elif close_price < sar:
        print("📉 SAR выше цены → нисходящий тренд (шорт).")
    else:
        print("⚡ Нет четкого сигнала.")

# Запуск
if __name__ == "__main__":
    while True:
        parabolic_sar_strategy()
        time.sleep(60)  # Проверка раз в минуту

#индикатор

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

📌 Arbitrage Bot – Кросс-биржевой арбитраж (Binance vs. KuCoin)

Смысл стратегии:

Арбитраж – это стратегия, при которой бот находит разницу в цене актива на разных биржах и покупает на дешевой бирже, продавая на дорогой.

Кросс-биржевой арбитраж → разница цен между Binance и KuCoin.

Спотовый арбитраж → покупка и продажа на разных биржах.

Фьючерсный арбитраж → разница между спотовой и фьючерсной ценой.

🔹 Основное правило: Разница должна покрывать комиссии и задержки транзакций.

import ccxt
import time

# Параметры
PAIR = "BTC/USDT"
SPREAD_THRESHOLD = 0.5  # Минимальная разница в % для арбитража
CHECK_INTERVAL = 10  # Проверка раз в 10 секунд

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

# Получение цены с бирж
def get_price(exchange, symbol):
    try:
        ticker = exchange.fetch_ticker(symbol)
        return ticker["last"]
    except Exception as e:
        print(f"Ошибка при получении цены с {exchange.id}: {e}")
        return None

# Логика арбитража
def arbitrage_bot():
    binance_price = get_price(binance, PAIR)
    kucoin_price = get_price(kucoin, PAIR)

    if binance_price and kucoin_price:
        spread = (abs(binance_price - kucoin_price) / min(binance_price, kucoin_price)) * 100

        print(f"Binance: {binance_price:.2f}, KuCoin: {kucoin_price:.2f}, Spread: {spread:.2f}%")

        if spread > SPREAD_THRESHOLD:
            if binance_price < kucoin_price:
                print(f"📈 Арбитраж: Покупка на Binance ({binance_price:.2f}), продажа на KuCoin ({kucoin_price:.2f})")
            else:
                print(f"📉 Арбитраж: Покупка на KuCoin ({kucoin_price:.2f}), продажа на Binance ({binance_price:.2f})")
        else:
            print("⚡ Нет арбитражных возможностей.")

# Запуск
if __name__ == "__main__":
    while True:
        arbitrage_bot()
        time.sleep(CHECK_INTERVAL)

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

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

📌 ATR Volatility Filter – Фильтрация волатильных рынков с ATR

Смысл стратегии:

Индикатор ATR (Average True Range) измеряет волатильность рынка, но не направление движения.

Высокий ATR → сильная волатильность (может быть тренд или высокая неопределенность).

Низкий ATR → слабая волатильность (рынок во флэте).

Можно использовать, как фильтр для входа.

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
ATR_PERIOD = 14  # Период ATR
VOLATILITY_THRESHOLD = 100  # Минимальное значение ATR для торговли

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=ATR_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет ATR
def calculate_atr(df):
    atr = talib.ATR(df["high"], df["low"], df["close"], timeperiod=ATR_PERIOD).iloc[-1]
    return atr

# Логика фильтрации волатильности
def atr_volatility_filter():
    df = fetch_ohlcv(PAIR)
    atr = calculate_atr(df)
    price = df["close"].iloc[-1]

    print(f"Цена: {price:.2f}, ATR: {atr:.2f}")

    if atr > VOLATILITY_THRESHOLD:
        print("📊 Высокая волатильность → торговля разрешена.")
    else:
        print("⚠️ Волатильность низкая → торговля не рекомендуется.")

# Запуск
if __name__ == "__main__":
    while True:
        atr_volatility_filter()
        time.sleep(60)  # Проверка раз в минуту

#индикатор

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

📌 Triangular Arbitrage Bot – Трехугольный арбитраж внутри одной биржи

Смысл стратегии:

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

🔹 Принцип работы:

1. Обмениваем валюту A на валюту B.

2. Обмениваем валюту B на валюту C.

3. Обмениваем валюту C обратно в валюту A.

4. Если конечная сумма больше начальной, фиксируем прибыль.

import ccxt
import time

# Параметры
EXCHANGE_NAME = "binance"
BASE_CURRENCY = "USDT"  # Начальная и конечная валюта
TRADE_PAIRS = [("BTC/USDT", "BTC", "USDT"), 
               ("ETH/BTC", "ETH", "BTC"), 
               ("ETH/USDT", "USDT", "ETH")]  # Трехугольный цикл
PROFIT_THRESHOLD = 0.5  # Минимальная прибыль в % для арбитража
CHECK_INTERVAL = 10  # Проверка раз в 10 секунд

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение цены пары
def get_price(pair):
    try:
        ticker = exchange.fetch_ticker(pair)
        return ticker["last"]
    except Exception as e:
        print(f"Ошибка получения цены {pair}: {e}")
        return None

# Логика арбитража
def triangular_arbitrage():
    try:
        # Получаем цены для трех пар
        price_a = get_price(TRADE_PAIRS[0][0])  # BTC/USDT
        price_b = get_price(TRADE_PAIRS[1][0])  # ETH/BTC
        price_c = get_price(TRADE_PAIRS[2][0])  # ETH/USDT

        if price_a and price_b and price_c:
            # Вычисляем итоговую прибыль
            start_amount = 1  # Допустим, начинаем с 1 USDT
            step1 = start_amount / price_a  # Покупаем BTC
            step2 = step1 / price_b  # Обмениваем BTC на ETH
            final_amount = step2 * price_c  # Обмениваем ETH обратно в USDT
            profit = ((final_amount - start_amount) / start_amount) * 100

            print(f"Цены: BTC/USDT={price_a:.2f}, ETH/BTC={price_b:.6f}, ETH/USDT={price_c:.2f}")
            print(f"Ожидаемая прибыль: {profit:.2f}%")

            if profit > PROFIT_THRESHOLD:
                print(f"📈 Возможность арбитража! Прибыль: {profit:.2f}%")
            else:
                print("⚡ Нет арбитражной возможности.")

    except Exception as e:
        print(f"Ошибка в арбитраже: {e}")

# Запуск
if __name__ == "__main__":
    while True:
        triangular_arbitrage()
        time.sleep(CHECK_INTERVAL)

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

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

📌Multi-Indi Scanner – Комплексный анализ с RSI, MACD и Bollinger Bands 🧑‍💻

Смысл стратегии:

Этот скрипт анализирует рынок сразу по трем индикаторам (RSI, MACD, Bollinger Bands) и генерирует комплексный сигнал.

Используем:

RSI → показывает перекупленность/перепроданность.

MACD → указывает на импульс тренда.

Bollinger Bands → оценивают волатильность и пробои границ.

🔹 Фильтрация сигналов → торгуем только, если все индикаторы согласуются.

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
RSI_PERIOD = 14
MACD_FAST = 12
MACD_SLOW = 26
MACD_SIGNAL = 9
BB_PERIOD = 20
BB_STD_DEV = 2

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=BB_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет индикаторов
def calculate_indicators(df):
    rsi = talib.RSI(df["close"], timeperiod=RSI_PERIOD).iloc[-1]
    macd, signal, _ = talib.MACD(df["close"], fastperiod=MACD_FAST, slowperiod=MACD_SLOW, signalperiod=MACD_SIGNAL)
    upper, middle, lower = talib.BBANDS(df["close"], timeperiod=BB_PERIOD, nbdevup=BB_STD_DEV, nbdevdn=BB_STD_DEV)

    return rsi, macd.iloc[-1], signal.iloc[-1], upper.iloc[-1], middle.iloc[-1], lower.iloc[-1], df["close"].iloc[-1]

# Логика сигналов
def multi_indi_scanner():
    df = fetch_ohlcv(PAIR)
    rsi, macd, signal, upper, middle, lower, close_price = calculate_indicators(df)

    print(f"Цена: {close_price:.2f}, RSI: {rsi:.2f}, MACD: {macd:.2f}, Signal: {signal:.2f}")
    print(f"Bollinger Bands → Верхняя: {upper:.2f}, Средняя: {middle:.2f}, Нижняя: {lower:.2f}")

    buy_signal = rsi < 30 and macd > signal and close_price < lower
    sell_signal = rsi > 70 and macd < signal and close_price > upper

    if buy_signal:
        print("📈 Сильный сигнал на покупку (LONG)!")
    elif sell_signal:
        print("📉 Сильный сигнал на продажу (SHORT)!")
    else:
        print("⚡ Нет четкого сигнала.")

# Запуск
if __name__ == "__main__":
    while True:
        multi_indi_scanner()
        time.sleep(60)  # Проверка раз в минуту

#индикатор

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

📌 VWAP Trading Bot – бот, торгующий по объему взвешенной цене 🧑‍💻

Смысл стратегии:

VWAP (Volume Weighted Average Price) – это индикатор, показывающий среднюю цену сделки с учетом объема.
Используется крупными игроками (фондами, институциональными инвесторами) для определения справедливой цены.

Как торговать по VWAP?

Цена выше VWAP → рынок в бычьем тренде (ищем покупки).

Цена ниже VWAP → рынок в медвежьем тренде (ищем продажи).

Стратегия входа:

Лонг: цена возвращается к VWAP в восходящем тренде.

Шорт: цена возвращается к VWAP в нисходящем тренде.

⚠️ Важно: VWAP работает лучше на флэтовых или умеренно трендовых рынках. 🚀

import ccxt
import pandas as pd
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1m"  # Торговля на коротких таймфреймах
VWAP_PERIOD = 20  # Количество свечей для расчета VWAP
CHECK_INTERVAL = 10  # Проверка раз в 10 секунд

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=VWAP_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет VWAP
def calculate_vwap(df):
    typical_price = (df["high"] + df["low"] + df["close"]) / 3
    vwap = (typical_price * df["volume"]).cumsum() / df["volume"].cumsum()
    return vwap.iloc[-1]

# Логика торговли по VWAP
def vwap_trading_bot():
    df = fetch_ohlcv(PAIR)
    vwap = calculate_vwap(df)
    close_price = df["close"].iloc[-1]

    print(f"Цена: {close_price:.2f}, VWAP: {vwap:.2f}")

    if close_price > vwap:
        print("📈 Цена выше VWAP → рынок бычий (лонг при откатах).")
    elif close_price < vwap:
        print("📉 Цена ниже VWAP → рынок медвежий (шорт при откатах).")
    else:
        print("⚡ Цена у VWAP, неопределенность.")

# Запуск
if __name__ == "__main__":
    while True:
        vwap_trading_bot()
        time.sleep(CHECK_INTERVAL)

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

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

📌DCA (Dollar Cost Averaging) Bot – Покупка актива равными долями

Смысл стратегии:

DCA (Dollar Cost Averaging) – это стратегия усреднения цены покупки.

Покупка актива равными долями через регулярные интервалы.

Уменьшает влияние волатильности.

Полезна для долгосрочного инвестирования.

⚠️ Важно: DCA – долгосрочная стратегия. Она лучше всего работает при регулярных инвестициях в актив с потенциалом роста 🚀

import ccxt
import time
from datetime import datetime, timedelta

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
DCA_AMOUNT = 100  # Сумма покупки в USDT
DCA_INTERVAL = 7  # Количество дней между покупками
CHECK_INTERVAL = 86400  # Проверка раз в день (86400 секунд)

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# История покупок
dca_history = []

# Получение текущей цены
def get_current_price(symbol):
    ticker = exchange.fetch_ticker(symbol)
    return ticker["last"]

# Логика DCA
def dca_bot():
    global dca_history
    current_price = get_current_price(PAIR)
    now = datetime.now()

    # Проверяем, когда была последняя покупка
    if not dca_history or (now - dca_history[-1]["time"]).days >= DCA_INTERVAL:
        dca_history.append({"time": now, "price": current_price, "amount": DCA_AMOUNT})
        print(f"📥 DCA покупка: {DCA_AMOUNT} USDT по цене {current_price:.2f}")

    # Вывод истории покупок
    print("📊 История DCA-покупок:")
    for entry in dca_history:
        print(f"{entry['time'].strftime('%Y-%m-%d %H:%M')} → {entry['amount']} USDT по {entry['price']:.2f}")

# Запуск
if __name__ == "__main__":
    while True:
        dca_bot()
        time.sleep(CHECK_INTERVAL)  # Проверка раз в день

#индикатор

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

📌 Powered Trading Bot – Бот с машинным обучением (XGBoost) 🧑‍💻

Смысл стратегии:

Используем XGBoost – одну из самых мощных библиотек машинного обучения для анализа ценовых данных.
Модель обучается на исторических данных, используя RSI, MACD, Bollinger Bands, Volume, ATR и другие индикаторы для предсказания направлений рынка (лонг / шорт).

Этапы работы:

1. Сбор данных (Binance, CCXT).

2. Формирование признаков (features) – технические индикаторы.

3. Обучение модели XGBoost на исторических данных.

4. Применение модели на новых данных для прогнозирования сигналов.

⚠️ Важно: Модель нуждается в постоянном обновлении данных и тестировании перед торговлей! 🚀

import ccxt
import pandas as pd
import talib
import time
import xgboost as xgb
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
TRAIN_SIZE = 200  # Количество свечей для обучения
FEATURES = ["rsi", "macd", "boll_upper", "boll_lower", "volume", "atr"]

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение исторических данных
def fetch_ohlcv(symbol, limit=TRAIN_SIZE + 50):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=limit)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Генерация признаков
def generate_features(df):
    df["rsi"] = talib.RSI(df["close"], timeperiod=14)
    macd, signal, _ = talib.MACD(df["close"], fastperiod=12, slowperiod=26, signalperiod=9)
    df["macd"] = macd - signal
    upper, _, lower = talib.BBANDS(df["close"], timeperiod=20, nbdevup=2, nbdevdn=2)
    df["boll_upper"] = upper
    df["boll_lower"] = lower
    df["atr"] = talib.ATR(df["high"], df["low"], df["close"], timeperiod=14)
    df.dropna(inplace=True)
    return df

# Создание метки для предсказания
def generate_labels(df):
    df["target"] = np.where(df["close"].shift(-1) > df["close"], 1, 0)  # 1 = рост, 0 = падение
    return df

# Обучение модели
def train_model(df):
    X = df[FEATURES]
    y = df["target"]
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)
    
    model = xgb.XGBClassifier(use_label_encoder=False, eval_metric="logloss")
    model.fit(X_train, y_train)
    
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"🔹 Точность модели: {accuracy:.2f}")
    
    return model

# Логика прогнозирования
def ai_trading_bot(model):
    df = fetch_ohlcv(PAIR)
    df = generate_features(df)
    X_live = df[FEATURES].iloc[-1:].values
    prediction = model.predict(X_live)[0]
    
    print(f"🔹 Прогноз: {'📈 Лонг' if prediction == 1 else '📉 Шорт'}")

# Запуск
if __name__ == "__main__":
    df = fetch_ohlcv(PAIR)
    df = generate_features(df)
    df = generate_labels(df)
    model = train_model(df)

    while True:
        ai_trading_bot(model)
        time.sleep(60)  # Проверка раз в минуту

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

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

📌 OBV Divergence Detector – Поиск дивергенций OBV

Смысл стратегии:

OBV (On-Balance Volume) – индикатор, анализирующий объем, чтобы предсказать будущие движения цены.

Бычья дивергенция → цена падает, но OBV растет → сигнал на покупку (лонг).

Медвежья дивергенция → цена растет, но OBV падает → сигнал на продажу (шорт).

🔹 Применение:

Используется для раннего определения разворотов.

Работает лучше в сочетании с трендовыми индикаторами (например, MACD, RSI).

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
LOOKBACK_PERIOD = 10  # Количество свечей для анализа дивергенции
CHECK_INTERVAL = 60  # Проверка раз в минуту

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=LOOKBACK_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет OBV
def calculate_obv(df):
    obv = talib.OBV(df["close"], df["volume"])
    return obv

# Проверка дивергенций
def detect_obv_divergence():
    df = fetch_ohlcv(PAIR)
    df["obv"] = calculate_obv(df)

    # Анализ цен и OBV на последних 10 свечах
    price_min = df["close"].iloc[-LOOKBACK_PERIOD:].min()
    price_max = df["close"].iloc[-LOOKBACK_PERIOD:].max()
    obv_min = df["obv"].iloc[-LOOKBACK_PERIOD:].min()
    obv_max = df["obv"].iloc[-LOOKBACK_PERIOD:].max()
    current_price = df["close"].iloc[-1]
    current_obv = df["obv"].iloc[-1]

    print(f"Цена: {current_price:.2f}, OBV: {current_obv:.2f}")

    if price_min < current_price and obv_min > current_obv:
        print("📈 Бычья дивергенция! Возможен рост (лонг).")
    elif price_max > current_price and obv_max < current_obv:
        print("📉 Медвежья дивергенция! Возможен спад (шорт).")
    else:
        print("⚡ Нет четкого сигнала.")

# Запуск
if __name__ == "__main__":
    while True:
        detect_obv_divergence()
        time.sleep(CHECK_INTERVAL)

#индикатор

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

📌 Trailing Stop Order Manager – Автоматическое управление стоп-лоссами

Смысл стратегии:

Trailing Stop (скользящий стоп-лосс) автоматически перемещает стоп-лосс за ценой, фиксируя прибыль, если цена идет в благоприятном направлении.

При росте цены → стоп-лосс поднимается.

При падении цены → стоп-лосс остается (пока не сработает)🧑‍💻

import ccxt
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TRAILING_PERCENT = 2  # На сколько % ниже максимальной цены ставится стоп-лосс
CHECK_INTERVAL = 10  # Проверка раз в 10 секунд

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Текущее состояние
max_price = None
stop_loss = None

# Получение текущей цены
def get_current_price(symbol):
    ticker = exchange.fetch_ticker(symbol)
    return ticker["last"]

# Логика Trailing Stop
def trailing_stop_manager():
    global max_price, stop_loss
    current_price = get_current_price(PAIR)

    # Обновляем максимум цены
    if max_price is None or current_price > max_price:
        max_price = current_price
        stop_loss = max_price * (1 - TRAILING_PERCENT / 100)
        print(f"🔼 Новый максимум: {max_price:.2f}, стоп-лосс обновлен: {stop_loss:.2f}")

    # Проверяем, сработал ли стоп-лосс
    if stop_loss and current_price <= stop_loss:
        print(f"❌ Цена {current_price:.2f} достигла стоп-лосса {stop_loss:.2f} – сигнал на выход.")
        max_price, stop_loss = None, None  # Сбрасываем после срабатывания

# Запуск
if name == "main":
    while True:
        trailing_stop_manager()
        time.sleep(CHECK_INTERVAL)

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

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

📌 OCO Orders Script–Установка связанных ордеров (Take Profit/Stop Loss)🧑‍💻

Смысл стратегии:

OCO (One Cancels the Other) – это метод установки двух связанных ордеров:

1. Take Profit (фиксируем прибыль).

2. Stop Loss (ограничиваем убытки).
Когда один из ордеров срабатывает, второй автоматически отменяется.


⚠️ Важно: OCO ордера доступны не на всех биржах – проверьте API биржи перед использованием! 🚀

import ccxt

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TRADE_AMOUNT = 0.001  # Количество актива для торговли
ENTRY_PRICE = 50000  # Цена покупки (можно заменить на реальную рыночную)
TAKE_PROFIT = 52000  # Цель по прибыли
STOP_LOSS = 48500  # Уровень стоп-лосса

# API-ключи (замените своими)
API_KEY = "your_api_key"
API_SECRET = "your_api_secret"

# Инициализация биржи
exchange = ccxt.binance({
    "apiKey": API_KEY,
    "secret": API_SECRET,
    "enableRateLimit": True,
})

# Установка OCO ордера
def place_oco_order():
    try:
        # Размещение OCO ордера (Take Profit + Stop Loss)
        order = exchange.create_order(
            symbol=PAIR,
            type="OCO",
            side="sell",
            amount=TRADE_AMOUNT,
            params={
                "stopPrice": STOP_LOSS,  # Уровень Stop Loss
                "price": TAKE_PROFIT,  # Уровень Take Profit
                "stopLimitPrice": STOP_LOSS - 50,  # Stop Limit (чуть ниже Stop Loss)
                "stopLimitTimeInForce": "GTC"  # Ордер действует до исполнения
            }
        )
        print("✅ OCO ордер успешно установлен:", order)
    except Exception as e:
        print("❌ Ошибка установки OCO ордера:", e)

# Запуск
if __name__ == "__main__":
    place_oco_order()

#ордера

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

📌 VWAP Trend Analyzer – Анализ трендов с учетом VWAP

Смысл стратегии:

VWAP (Volume Weighted Average Price) – это индикатор, который показывает среднюю цену сделки с учетом объема.

Используется для оценки тренда:

Цена выше VWAP → бычий тренд (поиск покупок).

Цена ниже VWAP → медвежий тренд (поиск продаж).

VWAP в боковом движении → рынок во флэте.

🔹 Применение:

- Подтверждение тренда → если цена выше VWAP, лучше искать покупки.

- Оценка откатов → если цена падает к VWAP в бычьем тренде, можно искать вход.

- Анализ краткосрочного тренда для скальпинга.

import ccxt
import pandas as pd
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "5m"  # Анализ краткосрочного тренда
VWAP_PERIOD = 20  # Количество свечей для расчета VWAP
CHECK_INTERVAL = 60  # Проверка раз в минуту

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=VWAP_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет VWAP
def calculate_vwap(df):
    typical_price = (df["high"] + df["low"] + df["close"]) / 3
    vwap = (typical_price * df["volume"]).cumsum() / df["volume"].cumsum()
    return vwap.iloc[-1]

# Анализ тренда с VWAP
def vwap_trend_analyzer():
    df = fetch_ohlcv(PAIR)
    vwap = calculate_vwap(df)
    close_price = df["close"].iloc[-1]

    print(f"Цена: {close_price:.2f}, VWAP: {vwap:.2f}")

    if close_price > vwap:
        print("📈 Цена выше VWAP → бычий тренд (лонг при откатах).")
    elif close_price < vwap:
        print("📉 Цена ниже VWAP → медвежий тренд (шорт при откатах).")
    else:
        print("⚡ Цена у VWAP, возможный флэт.")

# Запуск
if __name__ == "__main__":
    while True:
        vwap_trend_analyzer()
        time.sleep(CHECK_INTERVAL)

#индикатор

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

📌 Smart Order Execution – Умное исполнение ордеров (разбитие на части)🧑‍💻

Смысл стратегии:

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

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

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

Оптимизирует исполнение за счет анализа ликвидности.

import ccxt
import time
import random

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TOTAL_AMOUNT = 1  # Общий объем покупки (BTC)
SPLIT_ORDERS = 10  # Количество частей
MIN_WAIT = 5  # Минимальная задержка между ордерами (сек)
MAX_WAIT = 15  # Максимальная задержка между ордерами (сек)

# API-ключи (замените своими)
API_KEY = "your_api_key"
API_SECRET = "your_api_secret"

# Инициализация биржи
exchange = ccxt.binance({
    "apiKey": API_KEY,
    "secret": API_SECRET,
    "enableRateLimit": True,
})

# Получение текущей цены
def get_current_price(symbol):
    ticker = exchange.fetch_ticker(symbol)
    return ticker["last"]

# Умное исполнение ордера
def smart_order_execution():
    part_size = TOTAL_AMOUNT / SPLIT_ORDERS  # Размер одной сделки

    for i in range(SPLIT_ORDERS):
        price = get_current_price(PAIR)
        print(f"📥 Размещение ордера {i+1}/{SPLIT_ORDERS}: Покупка {part_size:.4f} BTC по {price:.2f} USDT")

        try:
            order = exchange.create_market_buy_order(PAIR, part_size)
            print(f"✅ Ордер исполнен: {order}")
        except Exception as e:
            print(f"❌ Ошибка при исполнении ордера: {e}")

        wait_time = random.randint(MIN_WAIT, MAX_WAIT)
        print(f"⏳ Ждем {wait_time} секунд перед следующим ордером...")
        time.sleep(wait_time)

# Запуск
if __name__ == "__main__":
    smart_order_execution()

#ордера

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

📌 Liquidity Pool Scanner – Поиск ликвидных активов🧑‍💻

Смысл стратегии:

Ликвидность – это ключевой фактор успешной торговли. Скрипт анализирует объем торгов и глубину стакана, чтобы найти самые ликвидные активы.

Используется для:

📍Поиска монет с высоким объемом и узким спредом.

📍Выбора лучших активов для скальпинга или арбитража.

📍Избегания неликвидных активов с высоким спредом.

import ccxt
import pandas as pd

# Параметры
EXCHANGE_NAME = "binance"
TOP_N = 10  # Количество лучших активов по ликвидности

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

# Получение ликвидных активов
def scan_liquidity():
    tickers = exchange.fetch_tickers()
    liquidity_data = []

    for symbol, data in tickers.items():
        if "/USDT" in symbol and "quoteVolume" in data:
            bid = data.get("bid", None)
            ask = data.get("ask", None)
            spread = (ask - bid) / ask * 100 if bid and ask else None

            liquidity_data.append({
                "pair": symbol,
                "volume_24h": data["quoteVolume"],
                "spread_%": spread
            })

    df = pd.DataFrame(liquidity_data)
    df = df.dropna().sort_values(by=["volume_24h"], ascending=False).head(TOP_N)

    print("📊 Топ ликвидных активов:")
    print(df.to_string(index=False))

# Запуск
if __name__ == "__main__":
    scan_liquidity()

#индикатор

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

📌 Market Impact Calculator – Оценка влияния крупных сделок на цену 🧑‍💻

Смысл стратегии:

При размещении крупных ордеров на покупку/продажу цена может измениться, особенно на рынках с низкой ликвидностью.
Этот скрипт анализирует глубину стакана и оценивает, насколько цена изменится при исполнении ордера.

🔹 Метрики влияния:

Объем стакана – сколько ликвидности доступно.

Проскальзывание (Slippage) – насколько изменится цена после сделки.

Рассчет на основе Order Book Depth.

import ccxt

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
ORDER_SIZE = 1  # Объем сделки (в BTC)

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение стакана ордеров
def get_order_book(symbol):
    order_book = exchange.fetch_order_book(symbol, limit=50)
    return order_book

# Оценка влияния сделки
def calculate_market_impact():
    order_book = get_order_book(PAIR)
    bids = order_book["bids"]  # Покупки
    asks = order_book["asks"]  # Продажи

    # Расчет проскальзывания на покупку
    buy_impact = 0
    sell_impact = 0
    buy_volume = ORDER_SIZE
    sell_volume = ORDER_SIZE

    for price, volume in asks:
        if buy_volume > volume:
            buy_impact += volume * price
            buy_volume -= volume
        else:
            buy_impact += buy_volume * price
            break

    for price, volume in bids:
        if sell_volume > volume:
            sell_impact += volume * price
            sell_volume -= volume
        else:
            sell_impact += sell_volume * price
            break

    avg_buy_price = buy_impact / ORDER_SIZE
    avg_sell_price = sell_impact / ORDER_SIZE
    mid_price = (asks[0][0] + bids[0][0]) / 2

    buy_slippage = ((avg_buy_price - mid_price) / mid_price) * 100
    sell_slippage = ((mid_price - avg_sell_price) / mid_price) * 100

    print(f"📊 Средняя цена покупки: {avg_buy_price:.2f}, проскальзывание: {buy_slippage:.4f}%")
    print(f"📉 Средняя цена продажи: {avg_sell_price:.2f}, проскальзывание: {sell_slippage:.4f}%")

# Запуск
if __name__ == "__main__":
    calculate_market_impact()

#ордера

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

📌 Delta Volume Analyzer – Анализ дельты объемов для фьючерсов🧑‍💻

Смысл стратегии:

Дельта объема – это разница между объемами покупок по рынку (market buy) и продаж по рынку (market sell).

Положительная дельта (ΔV > 0) → больше рыночных покупок → сильный спрос.

Отрицательная дельта (ΔV < 0) → больше рыночных продаж → сильное предложение.

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


🔹 Применение:

Если цена растет, но дельта объема падает → вероятен ложный пробой.

Если цена падает, но дельта объема растет → возможный разворот.

Используется в скальпинге и фьючерсной торговле.

import ccxt
import pandas as pd
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1m"  # Используем низкие таймфреймы для анализа потоков объема
CHECK_INTERVAL = 10  # Обновление каждые 10 секунд

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных по ленте сделок
def fetch_trades(symbol):
    trades = exchange.fetch_trades(symbol, limit=100)
    df = pd.DataFrame(trades)
    return df

# Рассчет дельты объемов
def calculate_delta_volume():
    df = fetch_trades(PAIR)

    # Фильтруем рыночные покупки и продажи
    buy_volume = df[df["side"] == "buy"]["amount"].sum()
    sell_volume = df[df["side"] == "sell"]["amount"].sum()

    delta_volume = buy_volume - sell_volume  # Разница между рыночными покупками и продажами

    print(f"📊 Дельта объема за последние 100 сделок: {delta_volume:.4f} BTC")
    print(f"📈 Покупки: {buy_volume:.4f} BTC, 📉 Продажи: {sell_volume:.4f} BTC")

    if delta_volume > 0:
        print("🔼 Преобладают рыночные покупки → возможный бычий импульс.")
    elif delta_volume < 0:
        print("🔽 Преобладают рыночные продажи → возможное снижение.")
    else:
        print("⚡ Баланс спроса и предложения.")

# Запуск
if __name__ == "__main__":
    while True:
        calculate_delta_volume()
        time.sleep(CHECK_INTERVAL)

#индикатор

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

📌 Dynamic Position Sizing – Адаптивный размер позиций на основе ATR 🧑‍💻

Смысл стратегии:

Adaptive Position Sizing помогает избежать излишней волатильности, регулируя размер позиции в зависимости от ATR (Average True Range).

Высокий ATR → рынок волатильный → уменьшаем размер позиции.

Низкий ATR → рынок спокойный → увеличиваем размер позиции.

Используется в фьючерсной и риск-менеджмент стратегии.

import ccxt
import pandas as pd
import talib
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
ATR_PERIOD = 14  # Период ATR
RISK_PER_TRADE = 100  # Максимальный риск на сделку (в $)
RISK_MULTIPLIER = 1.5  # Коэффициент риска (K)

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение данных
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=ATR_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет ATR и размера позиции
def calculate_position_size():
    df = fetch_ohlcv(PAIR)
    atr = talib.ATR(df["high"], df["low"], df["close"], timeperiod=ATR_PERIOD).iloc[-1]
    current_price = df["close"].iloc[-1]

    # Рассчитываем размер позиции в BTC
    position_size = RISK_PER_TRADE / (atr * RISK_MULTIPLIER)

    print(f"📊 Цена: {current_price:.2f} USDT, ATR: {atr:.2f}")
    print(f"🔹 Оптимальный размер позиции: {position_size:.4f} BTC")

# Запуск
if __name__ == "__main__":
    while True:
        calculate_position_size()
        time.sleep(60)  # Проверка раз в минуту

#ордера

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

📌 Order Book Imbalance Detector – Выявление дисбаланса заявок 🧑‍💻

Смысл стратегии:

Дисбаланс стакана заявок – это ситуация, когда в стакане больше лимитных ордеров на покупку (бидов) или продажу (асков).

Дисбаланс в сторону бидов → рынок может пойти вверх (сильный спрос).

Дисбаланс в сторону асков → рынок может упасть (сильное предложение).

Используется в скальпинге, арбитраже и HFT-торговле.

import ccxt
import time

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
ORDER_BOOK_DEPTH = 20  # Глубина анализа (количество уровней в стакане)
CHECK_INTERVAL = 5  # Проверка раз в 5 секунд

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()

# Получение стакана заявок
def get_order_book(symbol):
    order_book = exchange.fetch_order_book(symbol, limit=ORDER_BOOK_DEPTH)
    return order_book

# Анализ дисбаланса
def detect_order_book_imbalance():
    order_book = get_order_book(PAIR)
    
    bids = order_book["bids"]  # Лимитные покупки (цена, объем)
    asks = order_book["asks"]  # Лимитные продажи (цена, объем)

    # Рассчитываем общий объем заявок
    bid_volume = sum([volume for price, volume in bids])
    ask_volume = sum([volume for price, volume in asks])

    # Дисбаланс стакана
    imbalance = (bid_volume - ask_volume) / (bid_volume + ask_volume)

    print(f"📊 Дисбаланс заявок: {imbalance:.4f} | Биды: {bid_volume:.2f} | Аски: {ask_volume:.2f}")

    if imbalance > 0.1:
        print("📈 Преобладание бидов → возможный рост.")
    elif imbalance < -0.1:
        print("📉 Преобладание асков → возможное падение.")
    else:
        print("⚡ Баланс спроса и предложения.")

# Запуск
if __name__ == "__main__":
    while True:
        detect_order_book_imbalance()
        time.sleep(CHECK_INTERVAL)

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

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