def get_past_prices(range, ticker):
'''
Input: a list of date tuples in the format (%Y%m%d,%Y%m%d), and the stock ticker symbol.
Output: a dataframe with the open/close/high/low and volume historical figures related to the provided stock ticker.
Example: get_past_prices([('2010-12-01', '2010-12-31')], 'AAPL')
'''
td = TDClient(apikey="ef26202dacaf412fb157a05403f81ca3")
times = []
counter = 1
for start, end in range:
# delay to prevent API limits.
time.sleep(20)
ts = td.time_series(symbol=ticker,
interval="1day",
start_date=start,
end_date=end).as_pandas()
times.append(ts)
print(str(counter) + ')', str(start) + ' to', end)
counter += 1
stock_prices = pd.concat(times)
print("Final shape: {}".format(stock_prices.shape))
return stock_prices
def output(request):
if request.GET.get("ticker"):
userinput = request.GET.get("ticker")
td = TDClient(apikey="5ab205ca85414927b3b757076d329696")
ts = td.time_series(symbol=userinput, interval="1min",
outputsize=1).as_json()
return render(request, 'test.html', {'script': ts})
def get_tickers_data(interval="1day", outputsize=5000):
sp500_tickers, names = get_tickers_list_SP500()
with open("apikey.txt", "r") as file:
apikey = json.loads(file.read())
td = TDClient(apikey=apikey)
for ticker in sp500_tickers:
df = td.time_series(symbol=ticker,
outputsize=outputsize,
interval=interval).as_pandas()
print(df.head())
df.to_csv(f"tickers_data/{ticker}.csv")
time.sleep(10)
def update_stock(stock=str): #Gets the stock data from Twelvedata
td = TDClient(apikey=supersecretapi()) #get your own api! :P
ts = td.time_series(symbol=stock,
interval="1day",
timezone="America/Argentina/Buenos_Aires",
start_date="2020-11-02",
end_date="2021-01-09",
outputsize=5000).as_pandas()
ts = ts.sort_values(
"datetime"
) #I Spend too much time sorting the DataFrame and not saving it hahaha
print(ts)
ts.to_csv("data/%s.csv" % stock)
return ts
def getData(ticker):
td = TDClient(apikey="b34e89fbda894c4186fdd1db0c4aca4b")
ts1 = td.time_series(symbol=ticker, interval="5min",
outputsize=78).with_vwap().with_macd()
ts1_p = ts1.as_pandas()
ts2 = ts1.with_heikinashicandles()
ts2_p = ts2.as_pandas()
ts = pd.concat([ts1_p, ts2_p], axis=1).reindex(ts1_p.index)
ts = ts.rename(
columns={
"open": "Open",
"close": "Close",
"high": "High",
"low": "Low",
"volume": "Volume"
})
for i in ts:
print(i)
return ts
def main():
td = TDClient(apikey=config.API_KEY)
print('Running Initial Historical Fetch!')
fetchHistoricalData(td)
print("Scheduling Fetch Loop!")
sched = BlockingScheduler()
sched.add_job(fetchHistoricalData,
'cron',
args=[td],
minute='0-59',
second='25')
sched.start()
import time
from collections import namedtuple
import requests
import websocket
from twelvedata import TDClient
import json
# Initialize client - apikey parameter is requiered
td = TDClient(apikey="ece0867f7f864c78aca8f03754a1a788")
stock_id = set(line.strip() for line in open('StockID.txt'))
indicator_id = set(line.strip() for line in open('Tech.txt'))
Transaction = namedtuple('Transaction',
'type time timezone symbol shares stock_price')
transactions = []
user_shares = dict()
def is_float(test):
try:
float(test)
return True
except ValueError:
return False
def buy(parameters):
params = parameters.split(" ")
symbol = ""
num_of_shares = 0
stat_operator = ""
stat_parameter = 0
def _init_client():
return TDClient(
"demo",
http_client=CachedHttpClient(API_URL),
)
from twelvedata import TDClient
import asyncio
import websocket
import ssl
import json
td = TDClient(apikey="6ada7883b5494ec2ab023bbbf350a589")
ts = td.time_series(
symbol="BTC/USD",
outputsize=8,
interval="1h",
)
ts.as_plotly_figure().show()
def appendToDataFrame(dataframe, dict):
dataframe = dataframe.append(dict, ignore_index=True)
return dataframe
def on_message(ws, message):
print(message)
def on_error(ws, error):
print(error)
def on_close(ws):
print("Connection closed")
def on_open(ws):
cursor.execute("""
SELECT id, symbol, name FROM stock WHERE country='United States' OR country='India'
""")
rows = cursor.fetchall()
symbols = []
stock_dict = {}
for row in rows:
symbol = row['symbol']
symbols.append(symbol)
stock_dict[symbol] = row['id']
print(stock_dict)
print(symbols[:20])
chunk_size = 8
td = TDClient(apikey=config.API_KEY)
# for i in range(0, len(symbols)):
# print(barsets)
# print(stock_dict[barsets['id']])
# for i in range(0, len(symbols)):
start_time = time.time()
for i in range(0, len(symbols), chunk_size):
try:
sample_list = symbols[i:i + chunk_size]
ts = td.time_series(symbol=sample_list,
interval="2h",
def run(hours):
start = time.process_time()
td = TDClient(apikey=TWELVE_DATA_API_KEY)
cluster = MongoClient(MONGO_DB)
db = cluster["wsb_momentum"]
collection = db["daily_mentions"]
todays_date = date.today()
yesterday_date = todays_date - timedelta(days=1)
todays_data = collection.find_one({"date": str(todays_date)})
yesterdays_data = collection.find_one({"date": str(yesterday_date)})
yesterdays_tickers = yesterdays_data['tickers']
todays_tickers = todays_data['tickers']
todays_formatted_data = []
yesterdays_formatted_data = {}
difference = []
coef_list = [
51.6, 27.2, 21.1, 16.8, 14.7, 9.4, 7.9, 6.3, 4.6, 3.6, 3, 2.6, 2.2, 2,
1.6, 1.5, 1.4, 1.35, 1.3, 1.25, 1.2, 1.15, 1.1, 1, 1
]
for ticker in todays_tickers:
todays_formatted_data.append({
'ticker': ticker['ticker'],
'mentions': ticker['mentions'][0]
})
for ticker in yesterdays_tickers:
yesterdays_formatted_data[ticker['ticker']] = ticker['mentions'][0]
for item in todays_formatted_data:
ticker = item['ticker']
try:
difference.append({
"ticker":
ticker,
"mentions":
item['mentions'],
"difference":
round(item['mentions'] * coef_list[hours], 0) -
yesterdays_formatted_data[ticker],
"difference_percentage":
round((((item['mentions'] * coef_list[hours]) -
yesterdays_formatted_data[ticker]) /
yesterdays_formatted_data[ticker]) * 100, 2)
})
except:
pass
difference.sort(key=lambda x: x.get('difference'), reverse=True)
todays_formatted_data.sort(key=lambda x: x.get('mentions'), reverse=True)
top_by_mentions = todays_formatted_data[0:9]
top_by_increase = difference[0:19]
top_by_increase.sort(key=lambda x: x.get('difference_percentage'))
for ticker in top_by_increase:
volume_last_thirty = 0
volume_previous_thirty = 0
yahoo_data = yf.Ticker(ticker["ticker"])
list_yahoo_data = yahoo_data.history(period="5d").values.tolist()
try:
ticker["open"] = str(round(list_yahoo_data[4][0], 2))
ticker["yesterday_open"] = str(round(list_yahoo_data[3][0], 2))
ticker["yesterday_high"] = str(round(list_yahoo_data[3][1], 2))
ticker["yesterday_low"] = str(round(list_yahoo_data[3][2], 2))
ticker["yesterday_close"] = str(round(list_yahoo_data[3][3], 2))
except:
print('excepted 2', ticker)
try:
twelve_data = td.time_series(
symbol=ticker["ticker"],
interval="1day",
outputsize=2,
timezone="America/New_York",
)
list_twelve_data = twelve_data.as_pandas().values.tolist()
ticker["open"] = str(round(list_twelve_data[0][0], 2))
ticker["yesterday_open"] = str(round(list_twelve_data[1][0],
2))
ticker["yesterday_high"] = str(round(list_twelve_data[1][1],
2))
ticker["yesterday_low"] = str(round(list_twelve_data[1][2], 2))
ticker["yesterday_close"] = str(
round(list_twelve_data[1][3], 2))
time.sleep(8)
except:
ticker["thirty_min_change_percentage"] = 0.00
ticker["one_hour_change_percentage"] = 0.00
print('excepted 3', ticker)
time.sleep(8)
try:
data = td.time_series(
symbol=ticker["ticker"],
interval="1min",
outputsize=60,
timezone="America/New_York",
)
list_data = data.as_pandas().values.tolist()
for interval in list_data[0:29]:
volume_last_thirty += interval[4]
for interval in list_data[30:59]:
volume_previous_thirty += interval[4]
ticker["change_since_open"] = str(
round(list_data[0][3] - float(ticker["open"]), 2))
ticker["change_since_open_percentage"] = str(
round((list_data[0][3] - float(ticker["open"])) /
float(ticker["open"]) * 100, 2))
ticker["volume"] = str(int(volume_last_thirty))
ticker["volume_change"] = str(
int(volume_last_thirty - volume_previous_thirty))
ticker["volume_change_percentage"] = str(
round(((volume_last_thirty - volume_previous_thirty) /
volume_previous_thirty) * 100, 2))
ticker["thirty_min_change"] = str(
round(list_data[0][3] - list_data[29][0], 2))
ticker["one_hour_change"] = str(
round(list_data[0][3] - list_data[59][0], 2))
ticker["thirty_min_change_percentage"] = str(
round(
((list_data[0][3] - list_data[29][0]) / list_data[29][0]) *
100, 2))
ticker["one_hour_change_percentage"] = str(
round(
((list_data[0][3] - list_data[59][0]) / list_data[59][0]) *
100, 2))
ticker["price"] = str(round(list_data[0][3], 2))
except:
ticker["thirty_min_change_percentage"] = 0.00
ticker["one_hour_change_percentage"] = 0.00
pass
time.sleep(8)
message = '*Top Twenty Tickers By Increase In Mentions Since Yesterday:* \n'
message_two = ''
message_three = ''
website = "\n <https://wsb-data.vercel.app/|Investigate these tickers further> \n"
alert = False
alert_message = '@channel *High acceleration detected* \n'
for ticker in top_by_increase[0:6]:
small_increase_high_mentions = float(
ticker["difference_percentage"]) > 100 and int(
ticker["mentions"]) > 100
big_increase_moderate_mentions = float(
ticker["difference_percentage"]) > 500 and int(
ticker["mentions"]) > 50
huge_increase_low_mentions = float(
ticker["difference_percentage"]) > 2000
price_increase = float(
ticker["thirty_min_change_percentage"]) > 5 or float(
ticker["one_hour_change_percentage"]) > 10
link = '<https://finance.yahoo.com/quote/' + ticker[
"ticker"] + '|*' + ticker["ticker"] + ":*> \n"
if (small_increase_high_mentions or big_increase_moderate_mentions
or huge_increase_low_mentions) and price_increase:
alert = True
try:
mentions = "```On pace for " + str(int(
ticker["difference"])) + " (" + str(
ticker["difference_percentage"]
) + "%) more mentions than yesterday. \n"
price = "Currently $" + ticker["price"] + "\n"
opened = "Opened at $" + ticker["open"] + "\n"
open_change = "Change of $" + ticker[
"change_since_open"] + " (" + ticker[
"change_since_open_percentage"] + "%) since open. \n"
price_thirty = "Change of $" + ticker[
"thirty_min_change"] + " (" + ticker[
"thirty_min_change_percentage"] + "%) over thirty minutes. \n"
price_sixty = "Change of $" + ticker[
"one_hour_change"] + " (" + ticker[
"one_hour_change_percentage"] + "%) over one hour. \n"
volume = ticker[
"volume"] + " volume traded in the past thirty minutes. \n"
volume_change = "Change of " + ticker[
"volume_change"] + " (" + ticker[
"volume_change_percentage"] + "%) from the previous thirty minutes. \n"
yesterday = "Yesterday: Open: $" + ticker[
"yesterday_open"] + ". High: $" + ticker[
"yesterday_high"] + ". Low: $" + ticker[
"yesterday_low"] + ". Close: $" + ticker[
"yesterday_close"] + ". ``` \n"
alert_message += link + mentions + price + opened + open_change + price_thirty + price_sixty + volume + volume_change + yesterday
except:
alert_message += "Error fetching data for high acceleration ticker: " + link
else:
try:
mentions = "```On pace for " + str(int(
ticker["difference"])) + " (" + str(
ticker["difference_percentage"]
) + "%) more mentions than yesterday. \n"
price = "Currently $" + ticker["price"] + "\n"
opened = "Opened at $" + ticker["open"] + "\n"
open_change = "Change of $" + ticker[
"change_since_open"] + " (" + ticker[
"change_since_open_percentage"] + "%) since open. \n"
price_thirty = "Change of $" + ticker[
"thirty_min_change"] + " (" + ticker[
"thirty_min_change_percentage"] + "%) over thirty minutes. \n"
price_sixty = "Change of $" + ticker[
"one_hour_change"] + " (" + ticker[
"one_hour_change_percentage"] + "%) over one hour. \n"
volume = ticker[
"volume"] + " volume traded in the past thirty minutes. \n"
volume_change = "Change of " + ticker[
"volume_change"] + " (" + ticker[
"volume_change_percentage"] + "%) from the previous thirty minutes. \n"
yesterday = "Yesterday: Open: $" + ticker[
"yesterday_open"] + ". High: $" + ticker[
"yesterday_high"] + ". Low: $" + ticker[
"yesterday_low"] + ". Close: $" + ticker[
"yesterday_close"] + ". ``` \n"
message += link + mentions + price + opened + open_change + price_thirty + price_sixty + volume + volume_change + yesterday
except:
message += "Error fetching data for " + link
for ticker in top_by_increase[6:14]:
small_increase_high_mentions = float(
ticker["difference_percentage"]) > 100 and int(
ticker["mentions"]) > 100
big_increase_moderate_mentions = float(
ticker["difference_percentage"]) > 500 and int(
ticker["mentions"]) > 50
huge_increase_low_mentions = float(
ticker["difference_percentage"]) > 2000
price_increase = float(
ticker["thirty_min_change_percentage"]) > 5 or float(
ticker["one_hour_change_percentage"]) > 10
link = '<https://finance.yahoo.com/quote/' + ticker[
"ticker"] + '|*' + ticker["ticker"] + ":*> \n"
if (small_increase_high_mentions or big_increase_moderate_mentions
or huge_increase_low_mentions) and price_increase:
alert = True
try:
mentions = "```On pace for " + str(int(
ticker["difference"])) + " (" + str(
ticker["difference_percentage"]
) + "%) more mentions than yesterday. \n"
price = "Currently $" + ticker["price"] + "\n"
opened = "Opened at $" + ticker["open"] + "\n"
open_change = "Change of $" + ticker[
"change_since_open"] + " (" + ticker[
"change_since_open_percentage"] + "%) since open. \n"
price_thirty = "Change of $" + ticker[
"thirty_min_change"] + " (" + ticker[
"thirty_min_change_percentage"] + "%) over thirty minutes. \n"
price_sixty = "Change of $" + ticker[
"one_hour_change"] + " (" + ticker[
"one_hour_change_percentage"] + "%) over one hour. \n"
volume = ticker[
"volume"] + " volume traded in the past thirty minutes. \n"
volume_change = "Change of " + ticker[
"volume_change"] + " (" + ticker[
"volume_change_percentage"] + "%) from the previous thirty minutes. \n"
yesterday = "Yesterday: Open: $" + ticker[
"yesterday_open"] + ". High: $" + ticker[
"yesterday_high"] + ". Low: $" + ticker[
"yesterday_low"] + ". Close: $" + ticker[
"yesterday_close"] + ". ``` \n"
alert_message += link + mentions + price + opened + open_change + price_thirty + price_sixty + volume + volume_change + yesterday
except:
alert_message += "Error fetching data for high acceleration ticker: " + link
else:
try:
mentions = "```On pace for " + str(int(
ticker["difference"])) + " (" + str(
ticker["difference_percentage"]
) + "%) more mentions than yesterday. \n"
price = "Currently $" + ticker["price"] + "\n"
opened = "Opened at $" + ticker["open"] + "\n"
open_change = "Change of $" + ticker[
"change_since_open"] + " (" + ticker[
"change_since_open_percentage"] + "%) since open. \n"
price_thirty = "Change of $" + ticker[
"thirty_min_change"] + " (" + ticker[
"thirty_min_change_percentage"] + "%) over thirty minutes. \n"
price_sixty = "Change of $" + ticker[
"one_hour_change"] + " (" + ticker[
"one_hour_change_percentage"] + "%) over one hour. \n"
volume = ticker[
"volume"] + " volume traded in the past thirty minutes. \n"
volume_change = "Change of " + ticker[
"volume_change"] + " (" + ticker[
"volume_change_percentage"] + "%) from the previous thirty minutes. \n"
yesterday = "Yesterday: Open: $" + ticker[
"yesterday_open"] + ". High: $" + ticker[
"yesterday_high"] + ". Low: $" + ticker[
"yesterday_low"] + ". Close: $" + ticker[
"yesterday_close"] + ". ``` \n"
message_two += link + mentions + price + opened + open_change + price_thirty + price_sixty + volume + volume_change + yesterday
except:
message_two += "Error fetching data for " + link
for ticker in top_by_increase[14:]:
small_increase_high_mentions = float(
ticker["difference_percentage"]) > 100 and int(
ticker["mentions"]) > 100
big_increase_moderate_mentions = float(
ticker["difference_percentage"]) > 500 and int(
ticker["mentions"]) > 50
huge_increase_low_mentions = float(
ticker["difference_percentage"]) > 2000
price_increase = float(
ticker["thirty_min_change_percentage"]) > 5 or float(
ticker["one_hour_change_percentage"]) > 10
link = '<https://finance.yahoo.com/quote/' + ticker[
"ticker"] + '|*' + ticker["ticker"] + ":*> \n"
if (small_increase_high_mentions or big_increase_moderate_mentions
or huge_increase_low_mentions) and price_increase:
alert = True
try:
mentions = "```On pace for " + str(int(
ticker["difference"])) + " (" + str(
ticker["difference_percentage"]
) + "%) more mentions than yesterday. \n"
price = "Currently $" + ticker["price"] + "\n"
opened = "Opened at $" + ticker["open"] + "\n"
open_change = "Change of $" + ticker[
"change_since_open"] + " (" + ticker[
"change_since_open_percentage"] + "%) since open. \n"
price_thirty = "Change of $" + ticker[
"thirty_min_change"] + " (" + ticker[
"thirty_min_change_percentage"] + "%) over thirty minutes. \n"
price_sixty = "Change of $" + ticker[
"one_hour_change"] + " (" + ticker[
"one_hour_change_percentage"] + "%) over one hour. \n"
volume = ticker[
"volume"] + " volume traded in the past thirty minutes. \n"
volume_change = "Change of " + ticker[
"volume_change"] + " (" + ticker[
"volume_change_percentage"] + "%) from the previous thirty minutes. \n"
yesterday = "Yesterday: Open: $" + ticker[
"yesterday_open"] + ". High: $" + ticker[
"yesterday_high"] + ". Low: $" + ticker[
"yesterday_low"] + ". Close: $" + ticker[
"yesterday_close"] + ". ``` \n"
alert_message += link + mentions + price + opened + open_change + price_thirty + price_sixty + volume + volume_change + yesterday
except:
alert_message += "Error fetching data for high acceleration ticker: " + link
else:
try:
mentions = "```On pace for " + str(int(
ticker["difference"])) + " (" + str(
ticker["difference_percentage"]
) + "%) more mentions than yesterday. \n"
price = "Currently $" + ticker["price"] + "\n"
opened = "Opened at $" + ticker["open"] + "\n"
open_change = "Change of $" + ticker[
"change_since_open"] + " (" + ticker[
"change_since_open_percentage"] + "%) since open. \n"
price_thirty = "Change of $" + ticker[
"thirty_min_change"] + " (" + ticker[
"thirty_min_change_percentage"] + "%) over thirty minutes. \n"
price_sixty = "Change of $" + ticker[
"one_hour_change"] + " (" + ticker[
"one_hour_change_percentage"] + "%) over one hour. \n"
volume = ticker[
"volume"] + " volume traded in the past thirty minutes. \n"
volume_change = "Change of " + ticker[
"volume_change"] + " (" + ticker[
"volume_change_percentage"] + "%) from the previous thirty minutes. \n"
yesterday = "Yesterday: Open: $" + ticker[
"yesterday_open"] + ". High: $" + ticker[
"yesterday_high"] + ". Low: $" + ticker[
"yesterday_low"] + ". Close: $" + ticker[
"yesterday_close"] + ". ``` \n"
message_three += link + mentions + price + opened + open_change + price_thirty + price_sixty + volume + volume_change + yesterday
except:
message_three += "Error fetching data for " + link
slack_data = {'text': message}
response = requests.post(webhook_url,
data=json.dumps(slack_data),
headers={'Content-Type': 'application/json'})
if response.status_code != 200:
raise ValueError(
'Request to slack returned an error %s, the response is:\n%s' %
(response.status_code, response.text))
time.sleep(1)
slack_data = {'text': message_two}
response = requests.post(webhook_url,
data=json.dumps(slack_data),
headers={'Content-Type': 'application/json'})
if response.status_code != 200:
raise ValueError(
'Request to slack returned an error %s, the response is:\n%s' %
(response.status_code, response.text))
time.sleep(1)
slack_data = {'text': message_three + website}
response = requests.post(webhook_url,
data=json.dumps(slack_data),
headers={'Content-Type': 'application/json'})
if response.status_code != 200:
raise ValueError(
'Request to slack returned an error %s, the response is:\n%s' %
(response.status_code, response.text))
if alert:
time.sleep(1)
slack_data = {'text': alert_message, "link_names": True}
response = requests.post(webhook_url,
data=json.dumps(slack_data),
headers={'Content-Type': 'application/json'})
if response.status_code != 200:
raise ValueError(
'Request to slack returned an error %s, the response is:\n%s' %
(response.status_code, response.text))
from twelvedata import TDClient
from discord import Webhook, RequestsWebhookAdapter
import datetime
import config_values as config
current_time = datetime.datetime.now().time()
value_threshold = 450
#run only between market hours
if (current_time > datetime.time(9)) and (current_time < datetime.time(15,59)):
td = TDClient(apikey=config.static_values["api_key"])
ts = td.time_series(
symbol="GME",
interval="1min",
outputsize=1,
timezone="America/New_York",
).as_json()
stock_time = ts[0]["datetime"]
stock_high = ts[0]["high"]
format_string = "{time} - the high in the last two minutes for GME is ${high}".format(time = stock_time, high = stock_high)
webhook = Webhook.from_url(config.static_values["webhook_url"], adapter=RequestsWebhookAdapter())
if float(stock_high) > value_threshold:
webhook.send(format_string)
def indicators(symbol):
ts = td.time_series(symbol=symbol, interval='1min', outputsize=3)
ind = ts.with_sma(time_period=5).with_sma(time_period=8).with_sma(
time_period=13).as_pandas()
ind['symbol'] = symbol
return ind
t0 = time.perf_counter()
symbols = [
'INO', 'BIOC', 'AMD', 'QQQ', 'SQQQ', 'HTBX', 'AAPL', 'TRNX', 'MSFT', 'CZR'
]
td = TDClient(apikey=twelvedata_api_key)
#print(indicators(symbols[0]))
#print(indicators(symbols[1]))
#print(indicators(symbols[2]))
#print(indicators(symbols[3]))
#print(indicators(symbols[4]))
#print(indicators(symbols[5]))
#print(indicators(symbols[6]))
#print(indicators(symbols[7]))
#print(indicators(symbols[8]))
#print(indicators(symbols[9]))
with concurrent.futures.ThreadPoolExecutor() as executor:
results = [executor.submit(indicators, symbol) for symbol in symbols]
for result in results:
# Test out for best results
overSoldLine = 47
overBoughtLine = 59
# Dynamic Variables
boughtState = False
stockOwned = 0
bal = 10000
percentageRiskPerTrade = 0.2
while True:
try:
# Initiliaze client -api key
td = TDClient(apikey=apiKey)
ts = td.time_series(
symbol="CAD/USD",
interval="5min",
outputsize=1,
timezone="America/New_York"
)
# Returning Json
df = ts.with_rsi().as_json()
print("------")
print(get_live_price("CADUSD=X"))
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
print("Current Time: ", current_time)
print("Rsi: ")
print(df[0]["rsi"])
from tkinter import *
from tkinter import ttk
from twelvedata import TDClient
import numpy as np
import pandas as pd
import time
import matplotlib
import mplfinance as mplFin
key = 'c95e6270c7b14d49a090a6bd6ef3563a'
td = TDClient(apikey=key)
class BackTrader:
def __init__(self):
global var
root = Tk()
root.title('Back Tester v0.1')
root.geometry('600x600')
var = IntVar(root)
var.set(1)
button_frame = Frame(root)
button_frame.grid(column=3, row=8, pady=20)
valueOutput = Text(root, width=60, height=1)
titleLabel = Label(root, text='Back Tester v0.1')
titleLabel.config(font=('Verdana 12 bold'))
compTickerLabel = Label(root, text='Ticker Symbol:')
compIntervalLabel = Label(root, text='Interval:')
def _init_client():
return TDClient(
"demo",
http_client=CachedHttpClient("https://api.twelvedata.com"),
)
from twelvedata import TDClient
import pandas as pd
td = TDClient(apikey="4138a26532c14163a10c81b40f323194")
def getTwelveData(_symbol, _interval='1min'):
ts = td.time_series(
symbol=_symbol,
interval=_interval,
outputsize=30,
timezone="America/Los_Angeles",
)
df = ts.without_ohlc().with_sma(time_period=3).with_sma(
time_period=8).with_sma(time_period=21).with_rsi().as_pandas()
return df
def testData(_symbol, _interval='1min'):
ts = td.time_series(
symbol=_symbol,
interval=_interval,
outputsize=35,
timezone="America/Los_Angeles",
)
df_new = ts.as_pandas()
valueList = []
for index, value in enumerate(df_new['close']):
if index < 11:
valueList.append(df_new['close'][index:3 + index].mean())