Python bot for trading

Question

import yfinance as yf
import pandas as pd

dataF = yf.download("EURUSD=X", start="2022-12-22", end="2022-12-24", interval='60m')

print(dataF.iloc[:])

def signal_generator(df):
    open = df.Open.iloc[-1]
    close = df.Close.iloc[1]
    one_open = df.Open.iloc[-2]
    one_close = df.Close.iloc[-2]
    
    # Bearish Pattern
    if (open<=close and
    one_open>one_close ):
        return 1

    # Bullish Pattern
    elif (open>=close and
    one_open<one_close  
    ):
        return 2
    
    # No clear pattern
    else:
        return 0

signal = []
signal.append(0)
for i in range(1,len(dataF)):
    
    df = dataF[i-1:i+1]
    signal.append(signal_generator(df))
#signal_generator(data)
dataF["signal"] = signal


print(dataF.signal.value_counts())

in the first example seems like is working grabbing 2 candle stick but when i grab 4 as next code example it shows me an error.........

import yfinance as yf
import pandas as pd

dataF = yf.download("EURUSD=X", start="2022-12-22", end="2022-12-24", interval='60m')

print(dataF.iloc[:])

def signal_generator(df):
    open = df.Open.iloc[-1]
    close = df.Close.iloc[1]
    one_open = df.Open.iloc[-2]
    one_close = df.Close.iloc[-2]
    two_open = df.Close.iloc[-3]
    two_close = df.Close.iloc[-3]
    three_open = df.Close.iloc[-3]
    three_close = df.Close.iloc[-3]
    
    
    
    
    # Bearish Pattern
    if (open<=close and
    one_open>one_close and
    two_open<two_close and
    three_open>=three_close):
        return 1

    # Bullish Pattern
    elif (open>=close and
    one_open<one_close and
    two_open>two_close and 
    three_open<=three_close 
    ):
        return 2
    
    # No clear pattern
    else:
        return 0

signal = []
signal.append(0)
for i in range(1,len(dataF)):
    
    df = dataF[i-1:i+1]
    signal.append(signal_generator(df))
#signal_generator(data)
dataF["signal"] = signal


print(dataF.signal.value_counts())

I believe the problem is in this line.......

df = dataF[i-1:i+1]

Answer 1

Try this and feed back.

from utils import *
import time
import numpy as np
import pandas as pd
import datetime
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
import math
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import StandardScaler
import xgboost as xgb
from sklearn.metrics import accuracy_score
import warnings
warnings.filterwarnings("ignore")
from pandas_datareader import data as wb


tickers = ['SBUX']
start = '2022-09-01'
end = '2022-12-13'


price_data = []
for ticker in tickers:
    data = yf.download(ticker, start, end)
    data = data.reset_index()
    prices = data.loc[:,['Date','Adj Close']]
    price_data.append(prices.assign(ticker=ticker)[['ticker', 'Date', 'Adj Close']])
df = pd.concat(price_data)
df.dtypes
df.head()
df.shape



# Technical Indicators
data = df

num_training_days = int(data.shape[0]*.7)
print('Number of training days: {}. Number of test days: {}.'.format(num_training_days, data.shape[0]-num_training_days))


data['ma7'] = data['Adj Close'].rolling(window=7).mean()
data['ma21'] = data['Adj Close'].rolling(window=21).mean()


# Create exponential weighted moving average
data['26ema'] = data['Adj Close'].ewm(span=26).mean()
data['12ema'] = data['Adj Close'].ewm(span=12).mean()
data['MACD'] = (data['12ema']-data['26ema'])

# Create Bollinger Bands
data['20sd'] = data['Adj Close'].rolling(window=20).std() 
data['upper_band'] = data['ma21'] + (data['20sd']*2)
data['lower_band'] = data['ma21'] - (data['20sd']*2)

# Create Exponential moving average
data['ema'] = data['Adj Close'].ewm(com=0.5).mean()

# Create Momentum
data['momentum'] = data['Adj Close']-1
    

dataset_TI_df = data
dataset = data

#def plot_technical_indicators(dataset, last_days):
last_days = 250
plt.figure(figsize=(16, 10), dpi=100)
shape_0 = dataset.shape[0]
xmacd_ = shape_0-last_days
dataset = dataset.iloc[-last_days:, :]
x_ = range(3, dataset.shape[0])
x_ =list(dataset.index)

# Plot first subplot
plt.subplot(2, 1, 1)
plt.plot(dataset['ma7'],label='MA 7', color='g',linestyle='--')
plt.plot(dataset['Adj Close'],label='Closing Price', color='b')
plt.plot(dataset['ma21'],label='MA 21', color='r',linestyle='--')
plt.plot(dataset['upper_band'],label='Upper Band', color='c')
plt.plot(dataset['lower_band'],label='Lower Band', color='c')
plt.fill_between(x_, dataset['lower_band'], dataset['upper_band'], alpha=0.35)
plt.title('Technical indicators for Starbucks - last {} days.'.format(last_days))
plt.legend()

# Plot second subplot
plt.subplot(2, 1, 2)
plt.title('MACD')
plt.plot(dataset['MACD'],label='MACD', linestyle='-.')
plt.hlines(15, xmacd_, shape_0, colors='g', linestyles='--')
plt.hlines(-15, xmacd_, shape_0, colors='g', linestyles='--')
# plt.plot(dataset['log_momentum'],label='Momentum', color='b',linestyle='-')

plt.legend()
plt.show()

# Trade Signals
signalBuy = []
signalSell = []
position = False 

for i in range(len(data)):
    if data['ma7'][i] > data['ma21'][i]:
        if position == False :
            signalBuy.append(data['Adj Close'][i])
            signalSell.append(np.nan)
            position = True
        else:
            signalBuy.append(np.nan)
            signalSell.append(np.nan)
    elif data['ma7'][i] < data['ma21'][i]:
        if position == True:
            signalBuy.append(np.nan)
            signalSell.append(data['Adj Close'][i])
            position = False
        else:
            signalBuy.append(np.nan)
            signalSell.append(np.nan)
    else:
        signalBuy.append(np.nan)
        signalSell.append(np.nan)

data['Buy_Signal_price'] = signalBuy
data['Sell_Signal_price'] = signalSell
data


# Plotting Buy and Sell Points
fig, ax = plt.subplots(figsize=(14,8))
ax.plot(data['Adj Close'] , label = 'stock' ,linewidth=0.5, color='blue', alpha = 0.9)
ax.plot(data['ma7'], label = 'ma7', alpha = 0.85)
ax.plot(data['ma21'], label = 'ma21' , alpha = 0.85)
ax.scatter(data.index , data['Buy_Signal_price'] , label = 'Buy' , marker = '^', color = 'green',alpha =1 )
ax.scatter(data.index , data['Sell_Signal_price'] , label = 'Sell' , marker = 'v', color = 'red',alpha =1 )
ax.set_title(" Price History with buy and sell signals",fontsize=10, backgroundcolor='blue', color='white')
ax.set_xlabel(f'{startdate} - {end_date}' ,fontsize=18)
ax.set_ylabel('Close Price INR (₨)' , fontsize=18)
legend = ax.legend()
ax.grid()
plt.tight_layout()
plt.show()

moving_average_window = 30

data = df

# readjusting data Frame
data = data[["Adj Close"]]

# creating ** moving average
data["ma20"] = data["Adj Close"].rolling(window=moving_average_window).mean()

#calculating daily returns
data["daily returns"] = np.log(data["Adj Close"] / data["Adj Close"].shift(1))

data["position"] = [0] * len(data)
data.reset_index(inplace=True)
data = data.drop(["index"], axis=1)

pos_exit = False
pos = "N"

std = round(data["daily returns"].std(),4)
mean = round(data["daily returns"].mean(),4)

print("Std on daily returns  :", std)
print("Mean on daily returns :", mean,"\n")

print(data.head(7))


# Event Driven Testing
for i in range(1, len(data)):
    # Signal to go short and reset position
    if pos_exit:
        pos_exit = False
        pos = "N"
        continue

    # going long, if return goes beyond lower bound 
    # (1 standard deviation). The asumption here is 
    # that the stock will revert back to its mean value
    if data["Adj Close"][i] < ((1 - std) * data["ma20"][i]):
        data.at[i, "position"] = 1
        pos = "L"

    # scenario if return in between lower and upper bounds
    if pos == "L":
        data.at[i, "position"] = 1
     
    # updating strategy returns
    data["strategy returns"] = data["daily returns"] * data["position"]

    # exiting if the strategy return drops by 3%
    if data["strategy returns"][i] < -0.03:
        data.at[i, "position"] = 0
        pos_exit = True 

data.tail(10)


# taking positions after one day of signals being generated
data["position"].shift(1)



print("Buy and hold returns =",round(list(data["daily returns"].cumsum())[-1],4)*100,"%")
print("Strategy returns =", round(list(data["strategy returns"].cumsum())[-1],4)*100,"%")