---
license: mit
language:
- en
library_name: transformers
pipeline_tag: depth-estimation
---
# config.py
BINANCE_API_KEY = 'your_binance_api_key'
ALPHA_VANTAGE_API_KEY = 'your_alpha_vantage_api_key'
YAHOO_FINANCE_API_KEY = 'your_yahoo_finance_api_key'
TRADING_VIEW_API_KEY = 'your_trading_view_api_key'
BINOMO_API_KEY = 'your_binomo_api_key'
TELEGRAM_BOT_API_KEY = 'your_telegram_bot_api_key'

# data_acquisition.py
import requests
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from telegram.ext import Updater, CommandHandler

def fetch_binance_data(pair):
    url = f"https://api.binance.com/api/v3/klines?symbol={pair}&interval=1h"
    response = requests.get(url)
    data = response.json()
    df = pd.DataFrame(data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume', 'close_time', 'quote_asset_volume', 'number_of_trades', 'taker_buy_base_asset_volume', 'taker_buy_quote_asset_volume', 'ignore'])
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    return df[['timestamp', 'open', 'high', 'low', 'close', 'volume']]

def fetch_alpha_vantage_data(pair):
    symbol = pair.split("USDT")[0]  # Assuming pair like BTCUSDT
    url = f"https://www.alphavantage.co/query?function=TIME_SERIES_INTRADAY&symbol={symbol}&interval=60min&apikey={ALPHA_VANTAGE_API_KEY}"
    response = requests.get(url)
    data = response.json()
    time_series_key = 'Time Series (60min)'
    if time_series_key not in data:
        raise ValueError(f"Error fetching data from Alpha Vantage: {data}")
    df = pd.DataFrame(data[time_series_key]).T
    df.columns = ['open', 'high', 'low', 'close', 'volume']
    df.index = pd.to_datetime(df.index)
    return df.reset_index().rename(columns={'index': 'timestamp'})

def fetch_yahoo_finance_data(pair):
    url = f"https://yfapi.net/v8/finance/chart/{pair}?interval=60m"
    headers = {'x-api-key': YAHOO_FINANCE_API_KEY}
    response = requests.get(url, headers=headers)
    data = response.json()
    timestamps = data['chart']['result'][0]['timestamp']
    ohlc = data['chart']['result'][0]['indicators']['quote'][0]
    df = pd.DataFrame({
        'timestamp': pd.to_datetime(timestamps, unit='s'), 
        'open': ohlc['open'], 
        'high': ohlc['high'], 
        'low': ohlc['low'], 
        'close': ohlc['close'], 
        'volume': ohlc['volume']
    })
    return df

def fetch_trading_view_data(pair):
    # Placeholder for TradingView API data fetching
    raise NotImplementedError("TradingView API integration not implemented.")

def fetch_binomo_data(pair):
    # Placeholder for Binomo API data fetching
    raise NotImplementedError("Binomo API integration not implemented.")

def get_combined_data(pair):
    df_binance = fetch_binance_data(pair)
    df_alpha = fetch_alpha_vantage_data(pair)
    df_yahoo = fetch_yahoo_finance_data(pair)
    # Merge dataframes on timestamp
    df = pd.merge(df_binance, df_alpha, on='timestamp', suffixes=('_binance', '_alpha'))
    df = pd.merge(df, df_yahoo, on='timestamp', suffixes=('', '_yahoo'))
    # Drop any redundant columns or handle conflicts
    return df

def preprocess_data(df):
    df = df.dropna()
    scaler = StandardScaler()
    scaled_data = scaler.fit_transform(df[['open', 'high', 'low', 'close', 'volume']])
    return scaled_data, scaler

def create_dataset(data, time_step=60):
    X, Y = [], []
    for i in range(len(data) - time_step - 1):
        a = data[i:(i + time_step), :]
        X.append(a)
        Y.append(data[i + time_step, 3])  # Assuming 'close' price is the target
    return np.array(X), np.array(Y)

def build_model(input_shape):
    model = Sequential()
    model.add(LSTM(50, return_sequences=True, input_shape=input_shape))
    model.add(LSTM(50, return_sequences=False))
    model.add(Dropout(0.2))
    model.add(Dense(25))
    model.add(Dense(1))
    model.compile(optimizer='adam', loss='mean_squared_error')
    return model

def train_model(df):
    data, scaler = preprocess_data(df)
    X, Y = create_dataset(data)
    X_train, Y_train = X[:int(len(X) * 0.8)], Y[:int(len(Y) * 0.8)]
    X_val, Y_val = X[int(len(X) * 0.8):], Y[int(len(Y) * 0.8):]
    model = build_model((X_train.shape[1], X_train.shape[2]))
    model.fit(X_train, Y_train, validation_data=(X_val, Y_val), epochs=20, batch_size=32)
    return model, scaler

def generate_signal(pair):
    df = get_combined_data(pair)
    model, scaler = train_model(df)
    recent_data = df.tail(60).drop(columns=['timestamp'])
    scaled_recent_data = scaler.transform(recent_data)
    prediction = model.predict(np.expand_dims(scaled_recent_data, axis=0))
    last_close = df['close'].iloc[-1]
    if prediction > last_close:
        return "Buy"
    else:
        return "Sell"

def start(update, context):
    context.bot.send_message(chat_id=update.effective_chat.id, text="I'm a trading bot, how can I help you today?")

def signal(update, context):
    pair = context.args[0] if context.args else 'BTCUSDT'
    try:
        trade_signal = generate_signal(pair)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"Trade Signal for {pair}: {trade_signal}")
    except Exception as e:
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"Error: {e}")

def main():
    updater = Updater(token=TELEGRAM_BOT_API_KEY, use_context=True)
    dispatcher = updater.dispatcher

    start_handler = CommandHandler('start', start)
    signal_handler = CommandHandler('signal', signal)

    dispatcher.add_handler(start_handler)
    dispatcher.add_handler(signal_handler)

    updater.start_polling()

if __name__ == '__main__':
    main()