Python_Scripts

pip install peewee

import time
import ccxt

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 main():
    bybit = ccxt.bybit()
    binance = ccxt.binance()
    symbol = 'BTC/USDT'

    while True:
        price_bybit = get_price(bybit, symbol)
        price_binance = get_price(binance, symbol)

        if price_bybit and price_binance:
            spread = abs(price_bybit - price_binance)
            print(f"Цена Bybit: {price_bybit}, Цена Binance: {price_binance}, Спред: {spread}")
            
            if spread > 200:  # Порог арбитражной возможности
                print("Арбитражная возможность найдена!")
            else:
                print("Нет арбитражных возможностей на данный момент.")
        
        time.sleep(5)  # Пауза перед следующим запросом

if __name__ == "__main__":
    main()

pip install pygraphviz

import requests
from collections import defaultdict

# Актуальный эндпоинт API Bybit
TRADES_URL = "https://api.bybit.com/v5/market/recent-trade"
SYMBOL = "BTCUSDT"
TRADE_LIMIT = 1000  # Количество сделок для анализа
BIN_SIZE = 50  # Группировка цен (шаг 50 USDT)

def fetch_trades():
    """Получает последние сделки"""
    for category in ["spot", "linear", "inverse"]:
        params = {"category": category, "symbol": SYMBOL, "limit": TRADE_LIMIT}
        response = requests.get(TRADES_URL, params=params)
        
        if response.status_code == 200:
            data = response.json()
            if "result" in data and "list" in data["result"]:
                trades = data["result"]["list"]
                if trades:
                    return trades
    return []

def analyze_volume_clusters():
    """Анализирует кластеры объёма и выводит топ-10 уровней"""
    trades = fetch_trades()
    if not trades:
        print("Нет данных о сделках.")
        return

    volume_clusters = defaultdict(float)

    for trade in trades:
        price = float(trade.get("price", trade.get("p", 0)))
        volume = float(trade.get("size", trade.get("v", 0)))
        
        if price == 0 or volume == 0:
            continue

        price_bin = round(price / BIN_SIZE,4) * BIN_SIZE
        volume_clusters[price_bin] += volume

    sorted_clusters = sorted(volume_clusters.items(), key=lambda x: x[1], reverse=True)

    print("Топ-10 уровней с наибольшим объёмом:")
    for i, (price_level, volume) in enumerate(sorted_clusters[:10]):
        print(f"{i+1}. Цена: {price_level} USDT | Объём: {volume:.2f} BTC")

if __name__ == "__main__":
    analyze_volume_clusters()

pip install lark-parser

import requests
import time

# API Bybit (глубина стакана)
ORDER_BOOK_URL = "https://api.bybit.com/v5/market/orderbook"
SYMBOL = "BTCUSDT"
DEPTH = 50  # Берём топ-50 заявок

def get_order_book():
    """Получает стакан заявок"""
    params = {"category": "spot", "symbol": SYMBOL, "limit": DEPTH}
    response = requests.get(ORDER_BOOK_URL, params=params)
    if response.status_code == 200:
        data = response.json().get("result", {})
        bids = [(float(price), float(size)) for price, size in data.get("b", [])]
        asks = [(float(price), float(size)) for price, size in data.get("a", [])]
        return bids, asks
    else:
        print(f"Ошибка API: {response.status_code}")
        return None, None

def detect_iceberg_orders():
    """Выявляет скрытые Iceberg-заявки"""
    prev_bids, prev_asks = get_order_book()
    if not prev_bids or not prev_asks:
        print("❌ Ошибка получения стакана.")
        return

    print("📡 Начинаем мониторинг Iceberg-заявок...")
    while True:
        time.sleep(2)  # Ждём обновления стакана
        bids, asks = get_order_book()
        if not bids or not asks:
            continue

        # Анализ заявок (BID - покупатели)
        for i in range(min(len(bids), len(prev_bids))):
            if bids[i][0] == prev_bids[i][0] and bids[i][1] > prev_bids[i][1] * 1.5:
                print(f"❄️ Iceberg-заявка в BID: {bids[i][0]} - новый объём {bids[i][1]} BTC (было {prev_bids[i][1]} BTC)")

        # Анализ заявок (ASK - продавцы)
        for i in range(min(len(asks), len(prev_asks))):
            if asks[i][0] == prev_asks[i][0] and asks[i][1] > prev_asks[i][1] * 1.5:
                print(f"❄️ Iceberg-заявка в ASK: {asks[i][0]} - новый объём {asks[i][1]} BTC (было {prev_asks[i][1]} BTC)")

        prev_bids, prev_asks = bids, asks  # Обновляем стакан

if __name__ == "__main__":
    detect_iceberg_orders()

pip install falkon

import requests
import numpy as np

# Настройки
SYMBOL = "BTCUSDT"
KLINE_URL = "https://api.bybit.com/v5/market/kline"
INTERVAL = "15"  # 15-минутные свечи
LIMIT = 50  # Количество свечей для анализа
RANGE_THRESHOLD = 0.002  # Порог для консолидации (0.2% от цены)

def get_kline_data():
    """Получает исторические свечи"""
    params = {"category": "spot", "symbol": SYMBOL, "interval": INTERVAL, "limit": LIMIT}
    response = requests.get(KLINE_URL, params=params)

    if response.status_code == 200:
        return response.json().get("result", {}).get("list", [])
    else:
        print(f"Ошибка API: {response.status_code}")
        return None

def detect_consolidation():
    """Определяет консолидацию цены"""
    candles = get_kline_data()
    if not candles:
        print("❌ Не удалось получить данные.")
        return

    closes = np.array([float(c[4]) for c in candles])
    highs = np.array([float(c[2]) for c in candles])
    lows = np.array([float(c[3]) for c in candles])

    min_price = np.min(lows[-10:])  # Минимальная цена за 10 свечей
    max_price = np.max(highs[-10:])  # Максимальная цена за 10 свечей
    price_range = (max_price - min_price) / closes[-1]

    # 🔍 Добавляем отладку:
    print(f"🔍 Анализируем последние 10 свечей...")
    print(f"🔹 Min цена: {min_price:.2f}, Max цена: {max_price:.2f}")
    print(f"🔹 Текущий диапазон: {price_range:.5f}, Порог: {RANGE_THRESHOLD}")

    if price_range < RANGE_THRESHOLD:
        print(f"📉 Консолидация: {min_price:.2f} - {max_price:.2f}, возможный пробой!")
    else:
        print("⏳ Нет консолидации. Ждем сигнала...")

if __name__ == "__main__":
    detect_consolidation()

pip install kedro

import requests

# Настройки
SYMBOL = "BTCUSDT"
KLINE_URL = "https://api.bybit.com/v5/market/kline"
INTERVAL = "15"  # 15-минутные свечи
LIMIT = 50  # Количество свечей для анализа

def get_kline_data():
    """Получает исторические свечи"""
    params = {"category": "spot", "symbol": SYMBOL, "interval": INTERVAL, "limit": LIMIT}
    response = requests.get(KLINE_URL, params=params)

    if response.status_code == 200:
        return response.json().get("result", {}).get("list", [])
    else:
        print(f"Ошибка API: {response.status_code}")
        return None

def is_doji(open_price, close_price, high, low):
    """Паттерн Доджи (разворотный сигнал)"""
    body = abs(close_price - open_price)
    range_ = high - low
    return body < 0.1 * range_

def is_hammer(open_price, close_price, high, low):
    """Паттерн Молот (бычий разворот)"""
    body = abs(close_price - open_price)
    lower_shadow = open_price - low if close_price > open_price else close_price - low
    return lower_shadow > 2 * body and (high - max(open_price, close_price)) < body

def is_engulfing(prev_open, prev_close, open_price, close_price):
    """Паттерн Поглощение (разворот тренда)"""
    return (close_price > open_price and open_price < prev_close and close_price > prev_open) or \
           (close_price < open_price and open_price > prev_close and close_price < prev_open)

def analyze_patterns():
    """Анализ свечных паттернов"""
    candles = get_kline_data()
    if not candles:
        return

    for i in range(1, len(candles)):  # Начинаем со 2-й свечи
        prev_open, prev_close = float(candles[i-1][1]), float(candles[i-1][4])
        open_price, close_price = float(candles[i][1]), float(candles[i][4])
        high, low = float(candles[i][2]), float(candles[i][3])

        if is_doji(open_price, close_price, high, low):
            print(f"⚠️ Доджи на {i}-й свече: возможный разворот!")

        if is_hammer(open_price, close_price, high, low):
            print(f"✅ Молот на {i}-й свече: возможный рост!")

        if is_engulfing(prev_open, prev_close, open_price, close_price):
            print(f"🔥 Поглощение на {i}-й свече: возможный разворот тренда!")

if __name__ == "__main__":
    analyze_patterns()

pip install scalene

import requests
import numpy as np

# Настройки
SYMBOL = "BTCUSDT"
KLINE_URL = "https://api.bybit.com/v5/market/kline"
INTERVAL = "15"  # 15-минутные свечи
LIMIT = 100  # Количество свечей

def get_kline_data():
    """Получает исторические свечи"""
    params = {"category": "spot", "symbol": SYMBOL, "interval": INTERVAL, "limit": LIMIT}
    response = requests.get(KLINE_URL, params=params)

    if response.status_code == 200:
        return response.json().get("result", {}).get("list", [])
    else:
        print(f"Ошибка API: {response.status_code}")
        return None

def detect_anomalies():
    """Анализ аномальных движений"""
    candles = get_kline_data()
    if not candles:
        return

    closes = np.array([float(c[4]) for c in candles])
    returns = np.diff(closes)  # Вычисляем разницу между свечами

    mean = np.mean(returns)
    std = np.std(returns)
    z_scores = (returns - mean) / std  # Z-оценка для каждого изменения

    threshold = 3  # Граница аномалий
    anomalies = np.where(abs(z_scores) > threshold)[0]

    for idx in anomalies:
        move = "🚀 Резкий рост" if z_scores[idx] > 0 else "⚠️ Резкое падение"
        print(f"{move}: Свеча {idx+1}, Изменение: {returns[idx]:.2f}, Z-Score: {z_scores[idx]:.2f}")

if __name__ == "__main__":
    detect_anomalies()

pip install pyinfra

import requests
import numpy as np

# Настройки
SYMBOL = "BTCUSDT"
KLINE_URL = "https://api.bybit.com/v5/market/kline"
INTERVAL = "15"  # 15-минутные свечи
LIMIT = 100  # Количество свечей для анализа (для ATR)
ATR_PERIOD = 14  # Период ATR
BREAKOUT_MULTIPLIER = 1.5  # Насколько цена должна превысить ATR для подтвержденного пробоя

def get_kline_data():
    """Получает исторические свечи"""
    params = {"category": "spot", "symbol": SYMBOL, "interval": INTERVAL, "limit": LIMIT}
    response = requests.get(KLINE_URL, params=params)

    if response.status_code == 200:
        return response.json().get("result", {}).get("list", [])
    else:
        print(f"Ошибка API: {response.status_code}")
        return None

def calculate_atr(candles, period=ATR_PERIOD):
    """Рассчитывает ATR (средний истинный диапазон)"""
    highs = np.array([float(c[2]) for c in candles])
    lows = np.array([float(c[3]) for c in candles])
    closes = np.array([float(c[4]) for c in candles])

    prev_closes = np.roll(closes, shift=1)  # Смещаем массив на 1 (добавится дубликат первого элемента)
    prev_closes[0] = closes[0]  # Убираем лишнее смещение

    tr = np.maximum(highs - lows, np.maximum(abs(highs - prev_closes), abs(lows - prev_closes)))
    atr = np.convolve(tr, np.ones(period) / period, mode='valid')

    return atr[-1]  # Берем последнее значение ATR

def find_support_resistance(candles):
    """Определяет уровни поддержки и сопротивления"""
    highs = np.array([float(c[2]) for c in candles])
    lows = np.array([float(c[3]) for c in candles])

    support = np.min(lows)
    resistance = np.max(highs)

    return support, resistance

def detect_breakout():
    """Проверяет пробой уровней с фильтрацией по ATR"""
    candles = get_kline_data()
    if not candles:
        return

    support, resistance = find_support_resistance(candles[-50:])  # Берем последние 50 свечей
    last_close = float(candles[-1][4])
    atr = calculate_atr(candles)

    breakout_threshold = atr * BREAKOUT_MULTIPLIER  # Минимальный разрыв для подтверждения пробоя

    if last_close >= resistance + breakout_threshold:
        print(f"🚀 Подтвержденный пробой вверх! Цена {last_close:.2f} выше сопротивления {resistance:.2f} (ATR {atr:.2f})")
    elif last_close <= support - breakout_threshold:
        print(f"⚠️ Подтвержденный пробой вниз! Цена {last_close:.2f} ниже поддержки {support:.2f} (ATR {atr:.2f})")
    else:
        print(f"📊 Цена {last_close:.2f}, диапазон: {support:.2f} - {resistance:.2f} (без пробоя)")

if __name__ == "__main__":
    detect_breakout()

pip install pint

import requests
import numpy as np

# Настройки
SYMBOL = "BTCUSDT"
KLINE_URL = "https://api.bybit.com/v5/market/kline"
INTERVAL = "15"  # 15-минутные свечи
LIMIT = 50  # Количество свечей для анализа
TOLERANCE = 0.002  # Допустимый разрыв (0.2%)

def get_kline_data():
    """Получает исторические свечи"""
    params = {"category": "spot", "symbol": SYMBOL, "interval": INTERVAL, "limit": LIMIT}
    response = requests.get(KLINE_URL, params=params)

    if response.status_code == 200:
        return response.json().get("result", {}).get("list", [])
    else:
        print(f"Ошибка API: {response.status_code}")
        return None

def find_support_resistance(candles):
    """Определяет уровни поддержки и сопротивления"""
    closes = np.array([float(c[4]) for c in candles])
    highs = np.array([float(c[2]) for c in candles])
    lows = np.array([float(c[3]) for c in candles])

    support = np.min(lows)
    resistance = np.max(highs)

    return support, resistance

def detect_breakout():
    """Проверяет пробой уровней"""
    candles = get_kline_data()
    if not candles:
        return

    support, resistance = find_support_resistance(candles)
    last_close = float(candles[-1][4])

    if last_close >= resistance * (1 + TOLERANCE):
        print(f"🚀 Пробой вверх! Цена {last_close:.2f} выше сопротивления {resistance:.2f}")
    elif last_close <= support * (1 - TOLERANCE):
        print(f"⚠️ Пробой вниз! Цена {last_close:.2f} ниже поддержки {support:.2f}")
    else:
        print(f"📊 Цена {last_close:.2f}, диапазон: {support:.2f} - {resistance:.2f} (без пробоя)")

if __name__ == "__main__":
    detect_breakout()

pip install snoop

import requests
import numpy as np

# Настройки
SYMBOL = "BTCUSDT"
KLINE_URL = "https://api.bybit.com/v5/market/kline"
INTERVAL = "15"  # 15-минутные свечи
LIMIT = 100  # Количество свечей для расчета
RSI_PERIOD = 14  # Длина RSI
OVERBOUGHT = 70  # Уровень перекупленности
OVERSOLD = 30  # Уровень перепроданности

def get_kline_data():
    """Получает исторические свечи"""
    params = {"category": "spot", "symbol": SYMBOL, "interval": INTERVAL, "limit": LIMIT}
    response = requests.get(KLINE_URL, params=params)

    if response.status_code == 200:
        return response.json().get("result", {}).get("list", [])
    else:
        print(f"Ошибка API: {response.status_code}")
        return None

def calculate_rsi(prices, period=14):
    """Рассчитывает RSI"""
    deltas = np.diff(prices)
    gains = np.maximum(deltas, 0)
    losses = np.abs(np.minimum(deltas, 0))

    avg_gain = np.convolve(gains, np.ones(period) / period, mode='valid')
    avg_loss = np.convolve(losses, np.ones(period) / period, mode='valid')

    rs = avg_gain / (avg_loss + 1e-10)
    rsi = 100 - (100 / (1 + rs))
    return rsi

def analyze_rsi():
    """Анализирует рынок по RSI"""
    candles = get_kline_data()
    if not candles:
        return

    close_prices = np.array([float(c[4]) for c in candles])
    rsi = calculate_rsi(close_prices, RSI_PERIOD)

    if rsi[-1] > OVERBOUGHT:
        print(f"🔥 RSI = {rsi[-1]:.2f} → Возможен разворот вниз (перекупленность)")
    elif rsi[-1] < OVERSOLD:
        print(f"🟢 RSI = {rsi[-1]:.2f} → Возможен разворот вверх (перепроданность)")
    else:
        print(f"📊 RSI = {rsi[-1]:.2f} → Нейтральная зона")

if __name__ == "__main__":
    analyze_rsi()

pip install hatch

python -m pip install --upgrade --force-reinstall numpy-quaternion

import requests
import time

# Константы
TRADES_URL = "https://api.bybit.com/v5/market/recent-trade"
SYMBOL = "BTCUSDT"  # Торговая пара
CATEGORY = "spot"   # Тип рынка (spot или linear для фьючерсов)
VOLUME_THRESHOLD = 5  # Минимальный объём сделки для "кита" (в BTC)
REFRESH_INTERVAL = 2  # Интервал обновления (в секундах)

def get_recent_trades():
    """Получить последние сделки"""
    params = {
        "category": CATEGORY,
        "symbol": SYMBOL,
        "limit": 50  # Берём последние 50 сделок
    }
    response = requests.get(TRADES_URL, params=params)
    if response.status_code == 200:
        return response.json().get("result", {}).get("list", [])
    else:
        raise Exception(f"Ошибка API Trades: {response.status_code}, {response.text}")

def detect_whale_trades():
    """Мониторинг крупных сделок (китов)"""
    try:
        print(f"Начинаем мониторинг крупных сделок для {SYMBOL}...\n")
        while True:
            trades = get_recent_trades()

            for trade in trades:
                price = float(trade["p"])  # Цена сделки
                volume = float(trade["q"])  # Объём сделки
                side = "🟢 Покупка" if trade["S"] == "Buy" else "🔴 Продажа"

                # Фильтруем только крупные сделки
                if volume >= VOLUME_THRESHOLD:
                    print(f"{side} на {volume:.2f} BTC по цене {price:.2f}")

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

if __name__ == "__main__":
    detect_whale_trades()

pip install blosc

import requests
import time

# Константы
KLINE_URL = "https://api.bybit.com/v5/market/kline"
SYMBOL = "BTCUSDT"  # Торговая пара
CATEGORY = "spot"   # Тип рынка (spot или linear для фьючерсов)
INTERVAL = "1"  # Таймфрейм свечей (1 минута)
SMA_PERIOD = 10  # Количество свечей для расчёта SMA
REFRESH_INTERVAL = 5  # Интервал обновления (в секундах)

def get_kline_data():
    """Получить исторические свечи"""
    params = {
        "category": CATEGORY,
        "symbol": SYMBOL,
        "interval": INTERVAL,
        "limit": SMA_PERIOD  # Берём последние N свечей
    }
    response = requests.get(KLINE_URL, params=params)
    if response.status_code == 200:
        result = response.json().get("result", {}).get("list", [])
        if result:
            return [float(candle[4]) for candle in result]  # Закрытия свечей
        else:
            raise ValueError("Пустой ответ в 'result.list'.")
    else:
        raise Exception(f"Ошибка API Kline: {response.status_code}, {response.text}")

def calculate_sma(prices):
    """Рассчитать скользящую среднюю (SMA)"""
    return sum(prices) / len(prices) if prices else 0

def monitor_trend():
    """Мониторинг тренда на основе SMA"""
    try:
        print(f"Начинаем мониторинг тренда {SYMBOL}...\n")
        while True:
            # Получаем закрытия свечей
            closing_prices = get_kline_data()
            current_price = closing_prices[-1]  # Последняя цена закрытия
            sma = calculate_sma(closing_prices)

            # Определяем тренд
            trend = "⬆️ Восходящий" if current_price > sma else "⬇️ Нисходящий"

            # Выводим результаты
            print(f"Цена: {current_price:.2f}, SMA({SMA_PERIOD}): {sma:.2f}, Тренд: {trend}")

            # Интервал обновления
            time.sleep(REFRESH_INTERVAL)
    except Exception as e:
        print(f"Ошибка: {e}")

if __name__ == "__main__":
    monitor_trend()

pip install deeplake

import requests
import time

# Константы
ORDERBOOK_URL = "https://api.bybit.com/v5/market/orderbook"
SYMBOL = "BTCUSDT"  # Торговая пара
CATEGORY = "spot"   # Тип рынка (spot или linear для фьючерсов)
REFRESH_INTERVAL = 5  # Интервал обновления (в секундах)

def get_best_bid_ask():
    """Получить лучшие цены bid и ask"""
    params = {
        "category": CATEGORY,
        "symbol": SYMBOL
    }
    response = requests.get(ORDERBOOK_URL, params=params)
    if response.status_code == 200:
        result = response.json().get("result")
        if result:
            best_bid = result.get("b", [])[0]  # Лучшая цена bid
            best_ask = result.get("a", [])[0]  # Лучшая цена ask
            return best_bid, best_ask
        else:
            raise ValueError("Пустой ответ в поле 'result'.")
    else:
        raise Exception(f"Ошибка API Orderbook: {response.status_code}, {response.text}")

def calculate_spread(best_bid, best_ask):
    """Рассчитать спред между лучшими ценами bid и ask"""
    bid_price = float(best_bid[0])
    ask_price = float(best_ask[0])
    spread = ask_price - bid_price
    return bid_price, ask_price, spread

def monitor_best_bid_ask():
    """Мониторинг лучших bid и ask"""
    try:
        print(f"Начинаем мониторинг лучших bid и ask для {SYMBOL}...\n")
        while True:
            # Получаем лучшие bid и ask
            best_bid, best_ask = get_best_bid_ask()

            # Рассчитываем спред
            bid_price, ask_price, spread = calculate_spread(best_bid, best_ask)

            # Выводим результаты
            print(f"Bid: {bid_price:.2f}, Ask: {ask_price:.2f}, Спред: {spread:.2f}")

            # Интервал обновления
            time.sleep(REFRESH_INTERVAL)
    except Exception as e:
        print(f"Ошибка: {e}")

if __name__ == "__main__":
    monitor_best_bid_ask()

pip install pyscaffold

import requests
import time

# Константы
FUNDING_URL = "https://api.bybit.com/v5/market/funding/history"
SYMBOL = "BTCUSDT"  # Торговая пара
CATEGORY = "linear" # Тип рынка (фьючерсы)
CHECK_INTERVAL = 300  # Интервал проверки (в секундах)

def get_latest_funding_rate():
    """Получить последнюю ставку финансирования"""
    params = {
        "category": CATEGORY,
        "symbol": SYMBOL,
        "limit": 1  # Только последнее значение
    }
    response = requests.get(FUNDING_URL, params=params)
    if response.status_code == 200:
        funding_data = response.json()["result"]["list"]
        if funding_data:
            return float(funding_data[0]["fundingRate"]), funding_data[0]["fundingRateTimestamp"]
        else:
            raise Exception("Нет данных по ставке финансирования.")
    else:
        raise Exception(f"Ошибка API Funding Rate: {response.status_code}, {response.text}")

def monitor_funding_rate():
    """Мониторинг ставки финансирования"""
    try:
        print(f"Начинаем мониторинг ставки финансирования для {SYMBOL}...\n")
        previous_rate = None

        while True:
            # Получаем текущую ставку финансирования
            funding_rate, timestamp = get_latest_funding_rate()
            
            # Сравниваем с предыдущей ставкой
            if previous_rate is not None:
                rate_change = (funding_rate - previous_rate) * 100  # Изменение в процентах
                print(f"Ставка финансирования: {funding_rate:.6f} (Изменение: {rate_change:+.2f}%)")
                if abs(rate_change) > 0.01:  # Порог изменения, при котором выводится предупреждение
                    print(f"🔔 Внимание! Ставка финансирования изменилась на {rate_change:+.2f}%!")
            else:
                print(f"Ставка финансирования: {funding_rate:.6f}")

            # Обновляем предыдущую ставку
            previous_rate = funding_rate

            # Задержка перед следующей проверкой
            time.sleep(CHECK_INTERVAL)
    except Exception as e:
        print(f"Ошибка: {e}")

if name == "main":
    monitor_funding_rate()

pip install tenacity

import requests
import time

# Константы
BASE_URL = "https://api.bybit.com/v5/market/kline"
SYMBOL = "BTCUSDT"  # Торговая пара
CATEGORY = "spot"   # Тип рынка
INTERVAL = "60"     # Интервал свечей (60 минут)
LIMIT = 50          # Количество свечей для анализа (N периодов)
THRESHOLD_MULTIPLIER = 2  # Умножитель для определения аномального объёма

def get_historical_volumes():
    """Получить исторические объёмы (Kline)"""
    params = {
        "category": CATEGORY,
        "symbol": SYMBOL,
        "interval": INTERVAL,
        "limit": LIMIT
    }
    response = requests.get(BASE_URL, params=params)
    if response.status_code == 200:
        return [float(kline[5]) for kline in response.json()["result"]["list"]]  # Объём сделок
    else:
        raise Exception(f"Ошибка API: {response.status_code}, {response.text}")

def detect_anomalous_volume(volumes):
    """Определить, есть ли аномальный объём"""
    avg_volume = sum(volumes[:-1]) / (len(volumes) - 1)  # Средний объём без последнего значения
    last_volume = volumes[-1]  # Последний объём
    if last_volume > avg_volume * THRESHOLD_MULTIPLIER:
        return True, avg_volume, last_volume
    return False, avg_volume, last_volume

def main():
    try:
        print(f"Начинаем мониторинг объёмов для {SYMBOL}...\n")

        while True:
            # Получаем исторические данные объёмов
            volumes = get_historical_volumes()

            # Проверяем на наличие аномального объёма
            is_anomalous, avg_volume, last_volume = detect_anomalous_volume(volumes)

            if is_anomalous:
                print(f"🔔 Аномальный объём обнаружен!")
                print(f"Средний объём: {avg_volume:.2f}, Последний объём: {last_volume:.2f}\n")
            else:
                print(f"Объёмы в пределах нормы. Последний объём: {last_volume:.2f}, Средний объём: {avg_volume:.2f}")

            # Задержка между проверками
            time.sleep(60 * int(INTERVAL))  # Интервал совпадает с таймфреймом свечи
    except Exception as e:
        print(f"Ошибка: {e}")

if __name__ == "__main__":
    main()

pip install flupy

import requests
import pandas as pd

# Константы
BASE_URL = "https://api.bybit.com/v5/market/kline"
SYMBOL = "BTCUSDT"  # Торговая пара
CATEGORY = "spot"   # Тип рынка
INTERVAL = "60"     # Интервал свечей (60 минут)
LIMIT = 14          # Количество свечей для ATR (по умолчанию 14 периодов)

def get_historical_data():
    """Получить исторические данные (Kline)"""
    params = {
        "category": CATEGORY,
        "symbol": SYMBOL,
        "interval": INTERVAL,
        "limit": LIMIT + 1  # Нужно на 1 свечу больше для расчётов
    }
    response = requests.get(BASE_URL, params=params)
    if response.status_code == 200:
        return response.json()["result"]["list"]
    else:
        raise Exception(f"Ошибка API: {response.status_code}, {response.text}")

def calculate_atr(klines):
    """Вычислить ATR (средний истинный диапазон)"""
    # Преобразуем данные в DataFrame
    data = [
        {"high": float(kline[2]), "low": float(kline[3]), "close": float(kline[4])}
        for kline in klines
    ]
    df = pd.DataFrame(data)

    # Вычисляем истинный диапазон (TR)
    df["previous_close"] = df["close"].shift(1)
    df["tr"] = df[["high", "previous_close"]].max(axis=1) - df[["low", "previous_close"]].min(axis=1)

    # Рассчитываем ATR как скользящее среднее истинного диапазона
    df["atr"] = df["tr"].rolling(window=LIMIT).mean()

    # Возвращаем последнее значение ATR
    return df["atr"].iloc[-1]

def main():
    try:
        print(f"Вычисляем ATR для {SYMBOL} за последние {LIMIT} периодов...\n")

        # Получаем исторические данные
        klines = get_historical_data()

        # Вычисляем ATR
        atr = calculate_atr(klines)

        # Выводим результат
        print(f"Средний истинный диапазон (ATR) за {LIMIT} периодов: {atr:.2f}")
    except Exception as e:
        print(f"Ошибка: {e}")

if __name__ == "__main__":
    main()

pip install poetry-dynamic-versioning

pip install selenium-wire

import requests

def get_order_book(symbol, limit=100):
    """
    Получает стакан ордеров для указанной торговой пары.
    """
    url = f"https://api.binance.com/api/v3/depth?symbol={symbol}&limit={limit}"
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Ошибка получения стакана ордеров для {symbol}.")
        return None

def analyze_order_book(order_book):
    """
    Анализирует дисбаланс между заявками на покупку и продажу.
    """
    bids = order_book['bids']  # Покупки
    asks = order_book['asks']  # Продажи

    # Суммируем объемы заявок
    total_bid_volume = sum([float(bid[1]) for bid in bids])  # bid[1] = объем
    total_ask_volume = sum([float(ask[1]) for ask in asks])  # ask[1] = объем

    imbalance = (total_bid_volume - total_ask_volume) / (total_bid_volume + total_ask_volume) * 100

    return total_bid_volume, total_ask_volume, imbalance

def main():
    pair = input("Введите торговую пару (например, BTCUSDT): ").strip().upper()
    print(f"Получение стакана ордеров для {pair}...")
    order_book = get_order_book(pair)

    if order_book:
        bid_volume, ask_volume, imbalance = analyze_order_book(order_book)
        print(f"\nАнализ стакана для {pair}:")
        print(f"Общий объем покупок (bids): {bid_volume:.2f}")
        print(f"Общий объем продаж (asks): {ask_volume:.2f}")
        print(f"Дисбаланс: {imbalance:.2f}%")
        
        if imbalance > 10:
            print("Рынок перекуплен (давление покупателей).")
        elif imbalance < -10:
            print("Рынок перепродан (давление продавцов).")
        else:
            print("Рынок сбалансирован.")
    else:
        print("Не удалось получить данные стакана ордеров.")

if __name__ == "__main__":
    main()

pip install pywebio

import requests
import numpy as np

def get_market_data():
    """Получает данные о 24-часовой статистике торговых пар с Binance."""
    url = "https://api.binance.com/api/v3/ticker/24hr"
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        print("Ошибка подключения к Binance API.")
        return []

def calculate_fear_greed_index(data):
    """Рассчитывает индикатор страха и жадности."""
    price_changes = []
    volumes = []
    
    for pair in data:
        price_change = float(pair['priceChangePercent'])
        volume = float(pair['quoteVolume'])
        
        price_changes.append(price_change)
        volumes.append(volume)
    
    # Нормализуем данные
    avg_price_change = np.mean(price_changes)
    avg_volume = np.mean(volumes)
    
    fear_index = 50 - (avg_price_change / 2)  # Чем ниже, тем больше страха
    greed_index = (avg_volume / np.max(volumes)) * 50  # Чем выше объем, тем больше жадности
    
    total_index = max(0, min(100, fear_index + greed_index))  # Суммируем в пределах [0, 100]
    return total_index

def main():
    print("Индикатор страха и жадности на основе Binance...")
    data = get_market_data()
    if data:
        index = calculate_fear_greed_index(data)
        print(f"Текущий индекс страха и жадности: {index:.2f}/100")
        if index < 25:
            print("Рынок в зоне страха. Возможно, это хорошее время для покупки.")
        elif index > 75:
            print("Рынок в зоне жадности. Будьте осторожны с покупками.")
        else:
            print("Рынок сбалансирован.")
    else:
        print("Не удалось получить данные для расчета индикатора.")

if __name__ == "__main__":
    main()

pip install mechanize

import requests
import time

def get_price(symbol):
    """Получает текущую цену торговой пары с Binance."""
    url = f"https://api.binance.com/api/v3/ticker/price?symbol={symbol}"
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        return float(data["price"])
    else:
        print(f"Ошибка подключения к API Binance для пары {symbol}.")
        return None

def price_tracker(symbol, target_price):
    """Отслеживает цену и уведомляет, если цель достигнута."""
    print(f"Начинаю мониторинг {symbol}. Целевая цена: {target_price}")
    try:
        while True:
            price = get_price(symbol)
            if price:
                print(f"Текущая цена {symbol}: {price}")
                if price >= target_price:
                    print(f"🎉 Целевая цена достигнута! {symbol}: {price}")
                    break
            time.sleep(5)  # Интервал обновления (5 секунд)
    except KeyboardInterrupt:
        print("\nМониторинг остановлен.")

if __name__ == "__main__":
    pair = input("Введите торговую пару (например, BTCUSDT): ").strip().upper()
    try:
        target = float(input(f"Введите целевую цену для {pair}: ").strip())
        price_tracker(pair, target)
    except ValueError:
        print("Неверный ввод. Пожалуйста, укажите корректную цену.")

pip install authlib

import requests
import time

def get_binance_data():
    """Получает данные о торговых парах с Binance."""
    url = "https://api.binance.com/api/v3/ticker/24hr"
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        print("Ошибка подключения к Binance API.")
        return []

def find_unusual_activity(data):
    """Находит пары с самым большим изменением объема торгов."""
    unusual_pairs = sorted(data, key=lambda x: float(x['quoteVolume']), reverse=True)[:10]
    return unusual_pairs

def main():
    print("Анализ  активности на Binance...")
    while True:
        data = get_binance_data()
        if data:
            unusual_pairs = find_unusual_activity(data)
            print("\nТоп-10 пар с наибольшим объемом торгов за 24 часа:")
            for pair in unusual_pairs:
                print(f"{pair['symbol']} - Объем торгов: {pair['quoteVolume']} {pair['symbol'][-3:]}")
        else:
            print("Не удалось получить данные.")
        
        print("\nОжидание 1 час для следующего обновления...")
        time.sleep(3600)  # Обновление каждый час

if __name__ == "__main__":
    main()

pip install mpld3

import requests
import json

# API endpoint
API_URL = "https://api.dexscreener.com/token-boosts/top/v1"

def fetch_token_data():
    """Fetch token data from the API and display all relevant details including icons and links."""
    try:
        # Make the API request
        response = requests.get(API_URL)

        # Check if the request was successful
        if response.status_code == 200:
            # Parse the response JSON
            data = response.json()

            # Iterate through the tokens and display relevant details
            for token in data:
                url = token.get("url", "N/A")
                chain_id = token.get("chainId", "N/A")
                token_address = token.get("tokenAddress", "N/A")
                header = token.get("header", "No header available")
                icon = token.get("icon", "No icon available")
                description = token.get("description", "No description available")

                # Handle links if available
                links = token.get("links", [])
                formatted_links = "\n".join(
                    [f"{link.get('type', 'Link')}: {link.get('url', 'No URL')}" for link in links]
                )

                # Print the token details
                print(f"URL: {url}")
                print(f"Chain ID: {chain_id}")
                print(f"Token Address: {token_address}")
                print(f"Header: {header}")
                print(f"Icon: {icon}")
                print(f"Description: {description}")
                print(f"Links:\n{formatted_links if links else 'No links available'}")
                print("-" * 40)

        else:
            print(f"Failed to fetch data. Status code: {response.status_code}")
    except Exception as e:
        print(f"Error fetching data: {e}")

if __name__ == "__main__":
    fetch_token_data()

import time

def tail(file_path):
    """Читает файл и выводит новые строки в реальном времени."""
    try:
        with open(file_path, "r") as file:
            # Переходим в конец файла
            file.seek(0, 2)
            print(f"Мониторинг файла: {file_path}")
            while True:
                line = file.readline()
                if not line:
                    time.sleep(1)  # Ждем новые строки
                    continue
                print(line, end="")
    except FileNotFoundError:
        print(f"Файл {file_path} не найден.")
    except KeyboardInterrupt:
        print("\nМониторинг завершен.")

if __name__ == "__main__":
    path_to_file = input("Введите путь к файлу для мониторинга: ").strip()
    tail(path_to_file)

pip install fugue

import os
import time

def delete_old_files(directory, days):
    """Удаляет файлы старше указанного количества дней."""
    current_time = time.time()
    cutoff_time = current_time - (days * 86400)  # 86400 секунд = 1 день

    if not os.path.exists(directory):
        print(f"Директория {directory} не существует.")
        return

    print(f"Очистка файлов в {directory}, старше {days} дней...")
    for root, _, files in os.walk(directory):
        for file in files:
            file_path = os.path.join(root, file)
            try:
                file_mod_time = os.path.getmtime(file_path)
                if file_mod_time < cutoff_time:
                    os.remove(file_path)
                    print(f"Удалено: {file_path}")
            except Exception as e:
                print(f"Ошибка при удалении {file_path}: {e}")

    print("Очистка завершена.")

if __name__ == "__main__":
    dir_to_clean = input("Введите путь к директории для очистки: ").strip()
    days_old = int(input("Введите количество дней для удаления старых файлов: ").strip())
    delete_old_files(dir_to_clean, days_old)

pip install pybryt

import csv
import matplotlib.pyplot as plt

def load_csv(file_path):
    """Считывает данные из CSV-файла."""
    try:
        with open(file_path, "r", encoding="utf-8") as file:
            reader = csv.reader(file)
            data = [row for row in reader]
        return data
    except FileNotFoundError:
        print("Файл не найден.")
        return None

def plot_bar_chart(data):
    """Создает столбчатый график."""
    labels, values = zip(*data)
    plt.bar(labels, values, color="skyblue")
    plt.xlabel("Категории")
    plt.ylabel("Значения")
    plt.title("Столбчатый график")
    plt.show()

def plot_pie_chart(data):
    """Создает круговую диаграмму."""
    labels, values = zip(*data)
    plt.pie(values, labels=labels, autopct="%1.1f%%", startangle=140)
    plt.title("Круговая диаграмма")
    plt.show()

def plot_line_chart(data):
    """Создает линейный график."""
    labels, values = zip(*data)
    plt.plot(labels, values, marker="o", color="green")
    plt.xlabel("Категории")
    plt.ylabel("Значения")
    plt.title("Линейный график")
    plt.show()

if __name__ == "__main__":
    print("Программа: Генератор диаграмм из CSV")
    file_path = input("Введите путь к CSV-файлу: ").strip()
    raw_data = load_csv(file_path)
    if raw_data:
        try:
            # Конвертируем данные в числа
            data = [(row[0], float(row[1])) for row in raw_data]
        except ValueError:
            print("Ошибка: Убедитесь, что второй столбец содержит числовые значения.")
        else:
            print("\nВыберите тип диаграммы:")
            print("1. Столбчатый график")
            print("2. Круговая диаграмма")
            print("3. Линейный график")
            choice = input("Ваш выбор (1-3): ").strip()

            if choice == "1":
                plot_bar_chart(data)
            elif choice == "2":
                plot_pie_chart(data)
            elif choice == "3":
                plot_line_chart(data)
            else:
                print("Неверный выбор.")

pip install textattack

from collections import Counter
import re

def clean_text(text):
    """Очищает текст от пунктуации и приводит к нижнему регистру."""
    text = re.sub(r'[^\w\s]', '', text)  # Убираем пунктуацию
    return text.lower()

def analyze_text(file_path):
    """Читает файл и анализирует частоту слов."""
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            text = file.read()
        cleaned_text = clean_text(text)
        words = cleaned_text.split()
        word_count = Counter(words)
        return word_count
    except FileNotFoundError:
        print("Файл не найден.")
        return None

def display_top_words(word_count, top_n=10):
    """Выводит топ N самых частых слов."""
    print(f"\nТоп {top_n} самых частых слов:")
    for word, count in word_count.most_common(top_n):
        print(f"{word}: {count}")

if __name__ == "__main__":
    print("Программа: Анализатор частоты слов")
    file_path = input("Введите путь к текстовому файлу: ").strip()
    word_count = analyze_text(file_path)
    if word_count:
        top_n = input("Сколько самых частых слов вывести? (По умолчанию: 10): ").strip()
        top_n = int(top_n) if top_n.isdigit() else 10
        display_top_words(word_count, top_n)

pip install snorkel

import time
import json

TASKS_FILE = "time_tracker.json"

def load_tasks():
    """Загружает список задач из файла."""
    try:
        with open(TASKS_FILE, "r", encoding="utf-8") as file:
            return json.load(file)
    except FileNotFoundError:
        return {}
    except json.JSONDecodeError:
        print("Ошибка чтения файла. Начинаем с пустого списка.")
        return {}

def save_tasks(tasks):
    """Сохраняет список задач в файл."""
    with open(TASKS_FILE, "w", encoding="utf-8") as file:
        json.dump(tasks, file, indent=4)

def start_task(tasks):
    """Начинает отслеживать задачу."""
    task_name = input("Введите название задачи: ").strip()
    if task_name in tasks:
        print(f"Задача '{task_name}' уже существует. Продолжение отслеживания.")
    else:
        print(f"Начато отслеживание задачи '{task_name}'.")
    tasks[task_name] = tasks.get(task_name, 0)
    start_time = time.time()
    input("Нажмите Enter, чтобы остановить отслеживание...")
    elapsed_time = time.time() - start_time
    tasks[task_name] += round(elapsed_time)
    print(f"Задача '{task_name}' обновлена: {tasks[task_name]} секунд.")

def view_tasks(tasks):
    """Отображает список задач и потраченное время."""
    if not tasks:
        print("Нет задач для отображения.")
    else:
        print("\nСписок задач:")
        for task, seconds in tasks.items():
            print(f"{task}: {seconds // 60} минут {seconds % 60} секунд")

def reset_task(tasks):
    """Сбрасывает время отслеживания задачи."""
    task_name = input("Введите название задачи для сброса: ").strip()
    if task_name in tasks:
        tasks[task_name] = 0
        print(f"Время задачи '{task_name}' сброшено.")
    else:
        print(f"Задача '{task_name}' не найдена.")

if __name__ == "__main__":
    tasks = load_tasks()
    print("Программа: Трекер времени задач")
    while True:
        print("\nМеню:")
        print("1. Начать задачу")
        print("2. Просмотреть задачи")
        print("3. Сбросить задачу")
        print("4. Выйти")
        choice = input("Выберите действие (1-4): ").strip()

        if choice == "1":
            start_task(tasks)
            save_tasks(tasks)
        elif choice == "2":
            view_tasks(tasks)
        elif choice == "3":
            reset_task(tasks)
            save_tasks(tasks)
        elif choice == "4":
            print("Выход из программы. До свидания!")
            break
        else:
            print("Неверный выбор. Попробуйте снова.")

pip install transformers

import os
import shutil

def list_files(directory):
    """Выводит список файлов в текущей директории."""
    try:
        files = os.listdir(directory)
        if files:
            print("\nСодержимое папки:")
            for file in files:
                print(f"- {file}")
        else:
            print("Папка пуста.")
    except FileNotFoundError:
        print("Указанная папка не найдена.")
    except PermissionError:
        print("Нет доступа к указанной папке.")

def copy_file(source, destination):
    """Копирует файл."""
    try:
        shutil.copy(source, destination)
        print(f"Файл '{source}' успешно скопирован в '{destination}'.")
    except FileNotFoundError:
        print(f"Файл '{source}' не найден.")
    except Exception as e:
        print(f"Ошибка при копировании: {e}")

def rename_file(old_name, new_name):
    """Переименовывает файл."""
    try:
        os.rename(old_name, new_name)
        print(f"Файл '{old_name}' переименован в '{new_name}'.")
    except FileNotFoundError:
        print(f"Файл '{old_name}' не найден.")
    except Exception as e:
        print(f"Ошибка при переименовании: {e}")

def delete_file(file_name):
    """Удаляет файл."""
    try:
        os.remove(file_name)
        print(f"Файл '{file_name}' успешно удален.")
    except FileNotFoundError:
        print(f"Файл '{file_name}' не найден.")
    except Exception as e:
        print(f"Ошибка при удалении: {e}")

if __name__ == "__main__":
    print("Программа: Файловый менеджер")
    while True:
        print("\nМеню:")
        print("1. Просмотреть содержимое папки")
        print("2. Копировать файл")
        print("3. Переименовать файл")
        print("4. Удалить файл")
        print("5. Выйти")
        choice = input("Выберите действие (1-5): ").strip()

        if choice == "1":
            directory = input("Введите путь к папке (оставьте пустым для текущей папки): ").strip() or "."
            list_files(directory)
        elif choice == "2":
            source = input("Введите путь к исходному файлу: ").strip()
            destination = input("Введите путь назначения (папка или имя файла): ").strip()
            copy_file(source, destination)
        elif choice == "3":
            old_name = input("Введите текущее имя файла: ").strip()
            new_name = input("Введите новое имя файла: ").strip()
            rename_file(old_name, new_name)
        elif choice == "4":
            file_name = input("Введите имя файла для удаления: ").strip()
            delete_file(file_name)
        elif choice == "5":
            print("Выход из программы. До свидания!")
            break
        else:
            print("Неверный выбор. Попробуйте снова.")

pip install gym

from cryptography.fernet import Fernet

def generate_key():
    """Генерирует и сохраняет ключ шифрования в файл."""
    key = Fernet.generate_key()
    with open("secret.key", "wb") as key_file:
        key_file.write(key)
    print("Ключ успешно сгенерирован и сохранен в файл 'secret.key'.")

def load_key():
    """Загружает ключ шифрования из файла."""
    try:
        with open("secret.key", "rb") as key_file:
            return key_file.read()
    except FileNotFoundError:
        print("Ключ не найден. Сначала создайте его.")
        return None

def encrypt_message(message, key):
    """Шифрует сообщение с использованием ключа."""
    fernet = Fernet(key)
    return fernet.encrypt(message.encode()).decode()

def decrypt_message(encrypted_message, key):
    """Расшифровывает сообщение с использованием ключа."""
    fernet = Fernet(key)
    return fernet.decrypt(encrypted_message.encode()).decode()

if __name__ == "__main__":
    print("Программа: Шифрование и дешифрование текста")
    while True:
        print("\nМеню:")
        print("1. Создать ключ шифрования")
        print("2. Зашифровать сообщение")
        print("3. Расшифровать сообщение")
        print("4. Выйти")
        choice = input("Выберите действие (1-4): ").strip()

        if choice == "1":
            generate_key()
        elif choice in ["2", "3"]:
            key = load_key()
            if key:
                if choice == "2":
                    message = input("Введите сообщение для шифрования: ").strip()
                    encrypted = encrypt_message(message, key)
                    print(f"Зашифрованное сообщение: {encrypted}")
                elif choice == "3":
                    encrypted_message = input("Введите сообщение для расшифровки: ").strip()
                    try:
                        decrypted = decrypt_message(encrypted_message, key)
                        print(f"Расшифрованное сообщение: {decrypted}")
                    except Exception:
                        print("Не удалось расшифровать сообщение. Проверьте ключ и ввод.")
        elif choice == "4":
            print("Выход из программы. До свидания!")
            break
        else:
            print("Неверный выбор. Попробуйте снова.")

python -m pip install manim

def calculate_bmi(weight, height):
    """Вычисляет индекс массы тела (ИМТ)."""
    try:
        bmi = weight / (height ** 2)
        return round(bmi, 2)
    except ZeroDivisionError:
        print("Рост не может быть равен нулю.")
        return None

def interpret_bmi(bmi):
    """Интерпретирует значение ИМТ."""
    if bmi < 18.5:
        return "Недостаточный вес"
    elif 18.5 <= bmi < 24.9:
        return "Нормальный вес"
    elif 25 <= bmi < 29.9:
        return "Избыточный вес"
    else:
        return "Ожирение"

if __name__ == "__main__":
    print("Программа: Калькулятор ИМТ")
    while True:
        print("\nМеню:")
        print("1. Рассчитать ИМТ")
        print("2. Выйти")
        choice = input("Выберите действие (1-2): ").strip()
        
        if choice == "1":
            try:
                weight = float(input("Введите вес (кг): ").strip())
                height = float(input("Введите рост (м): ").strip())
                bmi = calculate_bmi(weight, height)
                if bmi is not None:
                    category = interpret_bmi(bmi)
                    print(f"Ваш ИМТ: {bmi}")
                    print(f"Категория: {category}")
            except ValueError:
                print("Пожалуйста, введите корректные числовые значения.")
        elif choice == "2":
            print("Выход из программы. До свидания!")
            break
        else:
            print("Неверный выбор. Попробуйте снова.")

pip install pyttsx3

import requests

API_URL = "http://www.omdbapi.com/"
API_KEY = "YOUR_API_KEY"  # Получите бесплатный API-ключ на http://www.omdbapi.com/apikey.aspx

def get_movie_info(movie_name):
    """Получает информацию о фильме из OMDB API."""
    try:
        params = {
            "t": movie_name,
            "apikey": API_KEY
        }
        response = requests.get(API_URL, params=params)
        if response.status_code == 200:
            data = response.json()
            if data.get("Response") == "True":
                title = data.get("Title", "Неизвестно")
                year = data.get("Year", "Неизвестно")
                genre = data.get("Genre", "Неизвестно")
                director = data.get("Director", "Неизвестно")
                actors = data.get("Actors", "Неизвестно")
                plot = data.get("Plot", "Нет описания")
                imdb_rating = data.get("imdbRating", "Нет рейтинга")
                
                print(f"\nИнформация о фильме '{title}':")
                print(f"Год: {year}")
                print(f"Жанр: {genre}")
                print(f"Режиссер: {director}")
                print(f"Актеры: {actors}")
                print(f"Описание: {plot}")
                print(f"Рейтинг IMDb: {imdb_rating}")
            else:
                print("Фильм не найден. Проверьте название.")
        else:
            print("Ошибка при запросе к API. Попробуйте позже.")
    except Exception as e:
        print(f"Произошла ошибка: {e}")

if __name__ == "__main__":
    print("Программа: Информация о фильмах")
    while True:
        print("\nМеню:")
        print("1. Найти информацию о фильме")
        print("2. Выйти")
        choice = input("Выберите действие (1-2): ").strip()
        
        if choice == "1":
            movie_name = input("Введите название фильма: ").strip()
            get_movie_info(movie_name)
        elif choice == "2":
            print("Выход из программы. До свидания!")
            break
        else:
            print("Неверный выбор. Попробуйте снова.")

pip install facebook-sdk

import requests

API_URL = "https://www.googleapis.com/books/v1/volumes"

def search_books(query, max_results=5):
    """Ищет книги по запросу с помощью Google Books API."""
    try:
        params = {
            "q": query,
            "maxResults": max_results
        }
        response = requests.get(API_URL, params=params)
        if response.status_code == 200:
            data = response.json()
            books = data.get("items", [])
            
            if books:
                print(f"\nНайдено {len(books)} книг(и):\n")
                for idx, book in enumerate(books, start=1):
                    title = book["volumeInfo"].get("title", "Нет названия")
                    authors = ", ".join(book["volumeInfo"].get("authors", ["Неизвестный автор"]))
                    description = book["volumeInfo"].get("description", "Нет описания")
                    print(f"{idx}. {title}")
                    print(f"   Автор(ы): {authors}")
                    print(f"   Описание: {description[:200]}...")  # Ограничиваем описание
                    print("-" * 40)
            else:
                print("Книги по вашему запросу не найдены.")
        else:
            print("Ошибка при запросе к API. Попробуйте позже.")
    except Exception as e:
        print(f"Произошла ошибка: {e}")

if __name__ == "__main__":
    print("Программа: Поиск книг")
    while True:
        print("\nМеню:")
        print("1. Искать книги")
        print("2. Выйти")
        choice = input("Выберите действие (1-2): ").strip()
        
        if choice == "1":
            query = input("Введите название книги, автора или ключевое слово: ").strip()
            search_books(query)
        elif choice == "2":
            print("Выход из программы. До свидания!")
            break
        else:
            print("Неверный выбор. Попробуйте снова.")