Create app.py

app.py

@@ -0,0 +1,191 @@
+import random
+from pricegenerator.PriceGenerator import PriceGenerator, uLogger
+from datetime import datetime, timedelta
+import gradio as gr
+import pandas as pd
+import pickle
+import matplotlib.pyplot as plt
+import mplfinance as mpf
+import numpy as np
+from PIL import Image
+import io
+from sklearn.preprocessing import StandardScaler
+import requests
+import time
+
+def download_model():
+    # URL do arquivo do modelo
+    model_url = "https://huggingface.co/artbreguez/BinaryOptionsXGB/resolve/main/eurusd.pkl?download=true"
+
+    # Baixar o arquivo do modelo
+    response = requests.get(model_url, stream=True)
+
+    # Verificar se o download foi bem-sucedido
+    if response.status_code == 200:
+        # Salvar o arquivo
+        with open('eurusd.pkl', 'wb') as f:
+            for chunk in response.iter_content(1024):
+                f.write(chunk)
+        print("Modelo baixado com sucesso!")
+        return True
+    else:
+        print("Erro ao baixar o modelo:", response.status_code)
+        return False
+
+# Realizar o download do modelo
+download_success = download_model()
+
+if download_success:
+    with open('eurusd.pkl', 'rb') as f:
+        content = f.read()
+    with open('eurusd.pkl', 'rb') as f:
+        model = pickle.load(f)
+else:
+    print("Download do modelo falhou.")
+
+
+# model = load_model()
+
+
+def generate_candle_image(df, predicao):
+    df['DateTime'] = pd.to_datetime(df['DateTime'])
+    df.set_index('DateTime', inplace=True)
+
+    prox_candle = pd.DataFrame(index=[df.index[-1] + pd.Timedelta(hours=1)])
+    prox_candle['Open'] = df['Close'].iloc[-1] 
+
+    if predicao[0] == 1:  # Predição positiva
+        prox_candle['Close'] = prox_candle['Open'] + 0.01  
+        prox_candle['High'] = prox_candle['Open'] + 0.01  
+        prox_candle['Low'] = prox_candle['Open']  
+    else:  # Predição negativa
+        prox_candle['Close'] = prox_candle['Open'] - 0.01  
+        prox_candle['High'] = prox_candle['Open']  
+        prox_candle['Low'] = prox_candle['Open'] - 0.01 
+
+    prox_candle['Volume'] = 0  
+
+    df_combined = pd.concat([df, prox_candle])
+
+    nans = [float('nan')]*len(df_combined)
+    cdf = pd.DataFrame(dict(Open=nans, High=nans, Low=nans, Close=nans), index=df_combined.index)
+    cdf.loc[df_combined.index[-1]] = df_combined.loc[df_combined.index[-1]]
+
+    mc = mpf.make_marketcolors(up='green', down='red')
+    s = mpf.make_mpf_style(marketcolors=mc)
+
+    fig, axlist = mpf.plot(df_combined, type='candle', volume=True, returnfig=True, ylabel_lower='Volume', title='EUR/USD Price Chart')
+    mpf.plot(cdf, type='candle', style=s, ax=axlist[0])
+
+    img_bytes = io.BytesIO()
+    plt.savefig(img_bytes, format='png')
+    img_bytes.seek(0)
+
+    img_pil = Image.open(img_bytes)
+
+    return img_pil
+
+
+def predict(X_2d):
+  return model.predict(X_2d)
+
+
+def generate_array(df):
+    features = df.drop(columns=['DateTime'])
+    scaler = StandardScaler()
+    normalized_features = scaler.fit_transform(features)
+    df_normalized = pd.DataFrame(normalized_features, columns=features.columns, index=df.index)
+    X = df_normalized.iloc[-1].values  # Obtém apenas os valores dos recursos normalizados
+    X_2d = np.array(X).reshape(1, -1)
+    return X_2d
+
+
+def calculate_bollinger_bands(df, period=20):
+    df['SMA'] = df['Close'].rolling(window=period).mean()
+    df['STD'] = df['Close'].rolling(window=period).std()
+    df['Upper'] = df['SMA'] + (2 * df['STD'])
+    df['Lower'] = df['SMA'] - (2 * df['STD'])
+    return df
+
+def calculate_stochastic_oscillator(df, period=14):
+    low_min = df['Low'].rolling(window=period).min()
+    high_max = df['High'].rolling(window=period).max()
+    close_diff = df['Close'] - low_min
+    high_diff = high_max - low_min
+    stoch = close_diff / high_diff * 100
+    df['Stochastic'] = stoch
+    return df
+
+def calculate_rsi(df, period=14):
+    diff = df['Close'].diff()
+    gain = diff.where(diff > 0, 0)
+    loss = -diff.where(diff < 0, 0)
+    ema_gain = gain.ewm(alpha=1/period, min_periods=period, adjust=False).mean()
+    ema_loss = loss.ewm(alpha=1/period, min_periods=period, adjust=False).mean()
+    rs = ema_gain / ema_loss
+    rsi = 100 - (100 / (1 + rs))
+    df['RSI'] = rsi
+    return df
+
+def process_data(file_path):
+    with open(file_path, 'r') as f:
+        data = f.readlines()
+
+    data = [line.strip().split(',') for line in data]
+
+    df = pd.DataFrame(data, columns=['Date', 'Time', 'Open', 'High', 'Low', 'Close', 'Volume'])
+
+    numeric_columns = ['Open', 'High', 'Low', 'Close', 'Volume']
+    df[numeric_columns] = df[numeric_columns].astype(float)
+
+    df['DateTime'] = pd.to_datetime(df['Date'] + ' ' + df['Time'])
+    df.set_index('DateTime', inplace=True)
+
+    df = calculate_bollinger_bands(df)
+    df = calculate_stochastic_oscillator(df)
+    df = calculate_rsi(df)
+    df.drop(['Date', 'Time', 'STD'], axis=1, inplace=True)
+    processed_file_path = file_path.replace('.csv', '_processed.csv')
+    df.to_csv(processed_file_path)
+    
+    return df
+
+def generate_graph_data():
+  uLogger.setLevel(0)
+
+  priceModel = PriceGenerator()
+  priceModel.precision = 5  # 5 casas decimais para maior precisão
+  priceModel.ticker = "EURUSD"  # par de moedas EUR/USD
+  priceModel.timeframe = timedelta(hours=1)  # intervalo de tempo entre os candles, 1 dia
+  priceModel.timeStart = datetime.today() - timedelta(days=1)  # dados do último ano
+  priceModel.horizon = 24  # 24 candles, correspondendo a um dia de dados
+  priceModel.maxClose = 1.25  # Maior preço de fechamento, similar aos preços do EUR/USD
+  priceModel.minClose = 1.05  # Menor preço de fechamento, similar aos preços do EUR/USD
+  priceModel.initClose = None  # Preço inicial aleatório dentro do intervalo (minClose, maxClose)
+  priceModel.maxOutlier = 0.01  # Máximo desvio para outliers, similar aos preços do EUR/USD
+  priceModel.maxCandleBody = None  # Sem limite para o tamanho do corpo dos candles
+  priceModel.maxVolume = 500000  # Volume máximo, valor arbitrário
+  priceModel.upCandlesProb = 0.5  # Probabilidade de candle de alta de 50%
+  priceModel.outliersProb = 0.03  # Probabilidade de outliers de 3%
+  priceModel.trendDeviation = 0.0005  # Desvio para definir tendência, valor pequeno
+  priceModel.zigzag = 0.01  # Diferença entre pontos do indicador ZigZag
+  priceModel._chartTitle = "EUR/USD Price Chart"  # Título do gráfico
+
+  priceModel.Generate()
+
+  priceModel.SaveToFile(fileName="eur_usd_prices.csv")
+
+def generate_predictions():
+    generate_graph_data()
+    df = process_data('eur_usd_prices.csv')
+    df = pd.read_csv('eur_usd_prices_processed.csv')
+    x_d2 = generate_array(df)
+    prediction = predict(x_d2)
+    image = generate_candle_image(df, prediction)
+    return image
+
+outputs = gr.Image(type='pil', label='label')
+inputs  = None
+title = "Binary Options Predictor"
+description = "This tool generates a simulated candlestick chart for EUR/USD. If the last candlestick is green, it indicates an upward trend, while a red candlestick suggests a downward trend."
+gr.Interface(generate_predictions, inputs, outputs, title=title, description=description).launch(debug=True)