def get_data_from_tradingView(self):
# dataframeSPY = pd.read_csv("data/SPY.csv")
# dataframeSPY['time'] = pd.to_datetime(dataframeSPY['time'], unit='s')
# print(dataframeSPY.tail())
tesla = TA_Handler()
tesla.set_symbol_as("TSLA")
tesla.set_exchange_as_crypto_or_stock("NASDAQ")
tesla.set_screener_as_stock("america")
tesla.set_interval_as(Interval.INTERVAL_1_DAY)
print(tesla.get_analysis().summary)
def get_stock_indicators_list(
lista=list
): #Get sell/buy indicators for multiple stocks from a list, and print the results
handler = TA_Handler()
for i in range(len(lista)):
handler.set_symbol_as(lista[i][0])
handler.set_exchange_as_crypto_or_stock("NASDAQ")
handler.set_screener_as_stock("america")
handler.set_interval_as(Interval.INTERVAL_1_HOUR)
stock = handler.get_analysis().summary
stock_table = []
for b in stock.items():
stock_table.append(b)
stock_table.insert(0, ["Company: " + lista[i][0].upper(), "Result"])
stock_table = AsciiTable(stock_table)
print(stock_table.table)
def root():
if request.method == "GET":
return render_template("index.html",
version=tradingview_ta.__version__,
captcha_sitekey=hcaptcha_sitekey)
elif request.method == "POST":
try:
# hCaptcha
hcaptcha_response = request.form["h-captcha-response"]
captchaReq = requests.post("https://hcaptcha.com/siteverify",
data={
"secret": hcaptcha_secret,
"response": hcaptcha_response
})
if captchaReq.json()["success"] == False:
return render_template("error.html",
version=tradingview_ta.__version__,
error="Error: Invalid captcha",
captcha_sitekey=hcaptcha_sitekey)
# TradingView Technical Analysis
handler = TA_Handler()
handler.set_symbol_as(request.form["symbol"])
handler.set_exchange_as_crypto_or_stock(request.form["exchange"])
handler.set_screener_as_stock(request.form["screener"])
handler.set_interval_as(request.form["interval"])
analysis = handler.get_analysis()
return render_template("success.html",
version=tradingview_ta.__version__,
symbol=analysis.symbol,
exchange=analysis.exchange,
screener=analysis.screener,
interval=analysis.interval,
time=analysis.time.astimezone(timezone.utc),
summary=analysis.summary,
oscillators=analysis.oscillators,
moving_averages=analysis.moving_averages,
indicators=analysis.indicators,
captcha_sitekey=hcaptcha_sitekey)
except Exception as e:
return render_template("error.html",
version=tradingview_ta.__version__,
error=e,
captcha_sitekey=hcaptcha_sitekey)
def get_stock_indicators_manual(
): #Get sell/buy indicators from tradingview_ta for one stock, with user input and print the result
handler = TA_Handler()
symbol = loop_simples_de_coleta(configleng[4], configleng[0],
configleng[2])
handler.set_symbol_as(symbol)
exchange = loop_simples_de_coleta(configleng[5], configleng[0],
configleng[2])
handler.set_exchange_as_crypto_or_stock(exchange)
handler.set_screener_as_stock(
loop_simples_de_coleta(configleng[8], configleng[0], configleng[2]))
r = str(interval_options())
handler.set_interval_as(r)
stock = handler.get_analysis().summary
stock_table = []
for i in stock.items():
stock_table.append(i)
stock_table.insert(0, ["Company: " + symbol.upper(), "Result"])
stock_table = AsciiTable(stock_table)
print(stock_table.table)
def t_infos():
symbol = input("entreprise symbole :\n> ")
exchange = input("place bourisère :\n> ")
country = input("pays: \n> ")
print("Résultats analyses techniques", symbol, ":")
try:
_object = TA_Handler()
_object.set_symbol_as(symbol)
_object.set_exchange_as_crypto_or_stock(exchange)
_object.set_screener_as_stock(country)
_object.set_interval_as(Interval.INTERVAL_1_DAY)
test = _object.get_analysis().summary
print("1 jour >", test)
_object.set_interval_as(Interval.INTERVAL_1_WEEK)
test = _object.get_analysis().summary
print("1 sem >", test)
_object.set_interval_as(Interval.INTERVAL_1_MONTH)
test = _object.get_analysis().summary
print("1 mois >", test)
print("-" * 100)
except:
print("ERREUR > une ou plusieures données sont érronées.")
def tech():
id_focus = input("ID action > ")
symbol = input("entreprise symbole > ")
exchange = input("place bourisère > ")
country = input("pays > ")
print("Analyse technique :")
try:
_object = TA_Handler()
_object.set_symbol_as(symbol)
_object.set_exchange_as_crypto_or_stock(exchange)
_object.set_screener_as_stock(country)
_object.set_interval_as(Interval.INTERVAL_1_DAY)
tradingview_result = _object.get_analysis().summary
print("1 jour >", tradingview_result)
_object.set_interval_as(Interval.INTERVAL_1_WEEK)
tradingview_result = _object.get_analysis().summary
print("1 sem >", tradingview_result)
_object.set_interval_as(Interval.INTERVAL_1_MONTH)
tradingview_result = _object.get_analysis().summary
print("1 mois >", tradingview_result)
print("Infos ajoutée en DB")
with connexion:
c.execute(
f"UPDATE ACTIONS SET tec_exchange = '{exchange}', tec_country = '{country}' WHERE id = {id_focus};"
)
except:
print("ERREUR > une ou plusieures données sont érronées.")
def get_buy_or_sell(ticker_exchange, intervals, ratio):
keys = ['BUY', 'SELL', 'NEUTRAL']
handler = TA_Handler(symbol='VUG',
screener='america',
exchange='AMEX',
interval=intervals[0])
print(bcolors.NEUTRAL, ' {:10s} {:15s} '.format('Ticker',
'Recommendation'),
'Summary of Technical Analysis', bcolors.ENDC)
print(
'--------------------------------------------------------------------------'
)
tickers_to_buy = []
tickers_to_sell = []
for symbol, exchange in ticker_exchange.items():
handler.set_symbol_as(symbol)
handler.exchange = exchange
summary = {'BUY': 0, 'SELL': 0, 'NEUTRAL': 0}
for intervali in intervals:
handler.set_interval_as(intervali)
analysis = handler.get_analysis()
#print(' ',analysis.interval,analysis.summary)
#print(analysis.interval)
#print(intervali,analysis.oscillators)
#print(intervali,analysis.moving_averages)
#keys = [key for key in analysis.indicators.keys() if 'Pivot' in key]
#for key in analysis.indicators.keys():
#if 'Pivot' in key:
#print(intervali,key,analysis.indicators[key])
#print(' ',summary+analysis.summary)
for key, val in summary.items():
summary[key] += analysis.summary[key]
#print(analysis.time)
#print(analysis.oscillators)
#print(analysis.indicators)
#print(' ',summary)
num_tests = 0
for summary_key, summary_val in summary.items():
num_tests += summary_val
shaun_recommendation = 'NEUTRAL'
for summary_key, summary_val in summary.items():
if summary_val > ratio * num_tests:
shaun_recommendation = summary_key
if shaun_recommendation == 'BUY':
#print(bcolors.BUY+handler.symbol,shaun_recommendation,summary,bcolors.ENDC)
print(
bcolors.BUY,
' {:10s} {:15s} '.format(handler.symbol,
shaun_recommendation), summary,
bcolors.ENDC)
tickers_to_buy.append(handler.symbol)
elif shaun_recommendation == 'SELL':
#print(bcolors.SELL,handler.symbol,shaun_recommendation,summary,bcolors.ENDC)
print(
bcolors.SELL,
' {:10s} {:15s} '.format(handler.symbol,
shaun_recommendation), summary,
bcolors.ENDC)
tickers_to_sell.append(handler.symbol)
elif shaun_recommendation == 'NEUTRAL':
#print(bcolors.NEUTRAL,handler.symbol,shaun_recommendation,summary,bcolors.ENDC)
print(
bcolors.NEUTRAL,
' {:10s} {:15s} '.format(handler.symbol,
shaun_recommendation), summary,
bcolors.ENDC)
#print(help(handler))
#print(help(handler.get_analysis()))
#print(handler.get_indicators())
print(bcolors.BUY + 'recommended to buy ', tickers_to_buy, bcolors.ENDC)
print(bcolors.SELL + 'recommended to sell ', tickers_to_sell, bcolors.ENDC)
return tickers_to_buy, tickers_to_sell
def analyse_technique(id_infos):
print("Analyse technique :")
try:
with connexion:
c.execute(
f"SELECT tec_symbol, tec_exchange, tec_country FROM actions where id = {id_infos};"
)
result = c.fetchone()
tec_symbol = result[0]
tec_exchange = result[1]
tec_country = result[2]
try: #1- on tente avec ce qui est stocké en db
_object = TA_Handler()
_object.set_symbol_as(tec_symbol)
_object.set_exchange_as_crypto_or_stock(tec_exchange)
_object.set_screener_as_stock(tec_country)
_object.set_interval_as(Interval.INTERVAL_1_DAY)
tradingview_result = _object.get_analysis().summary
_object.set_interval_as(Interval.INTERVAL_1_WEEK)
tradingview_result2 = _object.get_analysis().summary
_object.set_interval_as(Interval.INTERVAL_1_MONTH)
tradingview_result3 = _object.get_analysis().summary
c.execute(
f"UPDATE ACTIONS SET tec_exchange = '{tec_exchange}', tec_country = '{tec_country}' WHERE id = {id_infos};"
)
print("1 jour >", tradingview_result)
print("1 sem >", tradingview_result2)
print("1 mois >", tradingview_result3)
except:
tec_country = "AMERICA"
tec_exchange = "NYSE"
try:
_object = TA_Handler()
_object.set_symbol_as(tec_symbol)
_object.set_exchange_as_crypto_or_stock(tec_exchange)
_object.set_screener_as_stock(tec_country)
_object.set_interval_as(Interval.INTERVAL_1_DAY)
tradingview_result = _object.get_analysis().summary
_object.set_interval_as(Interval.INTERVAL_1_WEEK)
tradingview_result2 = _object.get_analysis().summary
_object.set_interval_as(Interval.INTERVAL_1_MONTH)
tradingview_result3 = _object.get_analysis().summary
c.execute(
f"UPDATE ACTIONS SET tec_exchange = '{tec_exchange}', tec_country = '{tec_country}' WHERE id = {id_infos};"
)
print("1 jour >", tradingview_result)
print("1 sem >", tradingview_result2)
print("1 mois >", tradingview_result3)
except:
tec_country = "AMERICA"
tec_exchange = "NASDAQ"
try:
_object = TA_Handler()
_object.set_symbol_as(tec_symbol)
_object.set_exchange_as_crypto_or_stock(tec_exchange)
_object.set_screener_as_stock(tec_country)
_object.set_interval_as(Interval.INTERVAL_1_DAY)
tradingview_result = _object.get_analysis().summary
_object.set_interval_as(Interval.INTERVAL_1_WEEK)
tradingview_result2 = _object.get_analysis().summary
_object.set_interval_as(Interval.INTERVAL_1_MONTH)
tradingview_result3 = _object.get_analysis().summary
c.execute(
f"UPDATE ACTIONS SET tec_exchange = '{tec_exchange}', tec_country = '{tec_country}' WHERE id = {id_infos};"
)
print("1 jour >", tradingview_result)
print("1 sem >", tradingview_result2)
print("1 mois >", tradingview_result3)
except:
print(
"Aucune donnée d'analyse technique, utilisez .tech"
)
except:
print("ERROR 14")
from tradingview_ta import TA_Handler, Interval
symbol = 'BTCUSDT'
exchange = 'BINANCE'
pair = TA_Handler()
pair.set_symbol_as(symbol)
pair.set_exchange_as_crypto_or_stock(exchange)
pair.set_screener_as_crypto()
pair.set_interval_as(Interval.INTERVAL_1_DAY)
print(pair.get_analysis().summary)
# Example output: {"RECOMMENDATION": "BUY", "BUY": 8, "NEUTRAL": 6, "SELL": 3}
print(pair.get_analysis().oscillators)
print(pair.get_analysis().moving_averages)
print(pair.get_analysis().indicators)
class Trader:
def __init__(self, wallet: dict, min_price_change: float) -> None:
# initialize wallet amounts
self.tokens = list(wallet.keys())
self.values = list(wallet.values())
self.symbol = ''.join(self.tokens)
self.price_change = min_price_change
self.current_price = 0
# initialize price api
self.api = 'https://min-api.cryptocompare.com/data/pricemulti?fsyms={0}&tsyms={1}&api_key={2}'.format(
self.tokens[0], self.tokens[1], cfg.CRYPTOCOMPARE_TOKEN)
# initialize technical analysis api
self.handler = TA_Handler()
self.handler.set_symbol_as(self.symbol)
self.handler.set_exchange_as_crypto_or_stock("BINANCE")
self.handler.set_screener_as_crypto()
self.handler.set_interval_as(Interval.INTERVAL_15_MINUTES)
def check_recommendation(self) -> str:
return self.handler.get_analysis().summary['RECOMMENDATION']
def get_price(self) -> float:
response = requests.request("GET", self.api)
json_resp = json.loads(response.text)
return json_resp[self.tokens[0]][self.tokens[1]]
def buy(self, percent) -> float:
quantity = self.values[1] * percent
self.values[0] += quantity / self.current_price
self.values[1] -= quantity
return quantity / self.current_price
def sell(self, percent) -> float:
quantity = self.values[0] * percent
self.values[1] += quantity * self.current_price
self.values[0] -= quantity
return quantity
# return'SOLD '+str(quantity) +' '+self.trading_pair[0]+' for ' + str(price)
def handle_status_change(self, curr) -> float:
if curr == 'STRONG_BUY' and self.values[1] > 0:
return (self.buy(1), 'BUY')
elif curr == 'BUY' and self.values[1] > 0:
return (self.buy(0.4), 'BUY')
elif curr == 'SELL' and self.values[0] > 0:
return (self.sell(0.4), 'SELL')
elif curr == 'STRONG_SELL' and self.values[0] > 0:
return (self.sell(1), 'SELL')
else:
return (0, None)
def wallet_pretty(self) -> str:
w = emoji.emojize(
':credit_card:\n{:.4f} {}\n{:.4f} {}\n\nTotal:\n{:.4f} {}'.format(
self.values[0], self.tokens[0], self.values[1], self.tokens[1],
self.values[1] + self.values[0] * self.current_price,
self.tokens[1]))
return w
def trade_pretty(self, quantity, side) -> str:
if side == 'SELL':
return emoji.emojize(
':left_arrow: Sold {:.4f} {} for {:.4f}'.format(
quantity, self.tokens[0], self.current_price))
else:
return emoji.emojize(
':right_arrow: Bought {:.4f} {} for {:.4f}'.format(
quantity, self.tokens[0], self.current_price))
def persist(self) -> None:
with open('./saved.pickle', 'wb') as f:
pickle.dump(self, f)
def run(self) -> str:
logging.info('Started trading ' + self.symbol)
# prev_rec = 'NONE'
prev_price = self.current_price
while True:
try:
rec = self.check_recommendation()
self.current_price = self.get_price()
price_change = abs(1 - (prev_price / self.current_price))
if price_change > self.price_change or 'STRONG' in rec:
traded = self.handle_status_change(rec)
self.persist()
if traded[0] <= 0:
continue
prev_price = self.current_price
# prev_rec = rec
tradedstr = self.trade_pretty(*traded)
walletstr = self.wallet_pretty()
yield tradedstr
logging.info(tradedstr)
logging.info(walletstr)
self.persist()
except:
logging.exception('Error occurred')
finally:
time.sleep(30)
'1h', #Interval.INTERVAL_1_HOUR,
'4h', #Interval.INTERVAL_4_HOURS,
'1d', #Interval.INTERVAL_1_DAY,
'1W', #Interval.INTERVAL_1_WEEK,
'1M' #Interval.INTERVAL_1_MONTH,
]
summary = {'BUY': 0, 'SELL': 0, 'NEUTRAL': 0}
keys = ['BUY', 'SELL', 'NEUTRAL']
handler = TA_Handler(symbol='VUG',
screener='america',
exchange='AMEX',
interval=intervals[0])
#help(TA_Handler)
print(handler.symbol)
for intervali in intervals:
handler.set_interval_as(intervali)
analysis = handler.get_analysis()
print(' ', analysis.interval, analysis.summary)
#print(analysis.interval)
#print(intervali,analysis.oscillators)
#print(intervali,analysis.moving_averages)
#keys = [key for key in analysis.indicators.keys() if 'Pivot' in key]
#for key in analysis.indicators.keys():
#if 'Pivot' in key:
#print(intervali,key,analysis.indicators[key])
#print(' ',summary+analysis.summary)
for key, val in summary.items():
summary[key] += analysis.summary[key]
#print(analysis.time)
#print(analysis.oscillators)
#print(analysis.indicators)
from django.contrib.auth.decorators import login_required
from django.db.models import F
from django.shortcuts import render, redirect
from django.http import HttpResponse
from .models import Shares
from .forms import SharesForm
from django.contrib import messages
from django.core.paginator import Paginator
from tradingview_ta import TA_Handler, Interval
tesla = TA_Handler()
tesla.set_symbol_as("TSLA")
tesla.set_exchange_as_crypto_or_stock("NASDAQ")
tesla.set_screener_as_stock("america")
tesla.set_interval_as(Interval.INTERVAL_1_DAY)
print(tesla.get_analysis().summary)
# Example output: {"RECOMMENDATION": "BUY", "BUY": 8, "NEUTRAL": 6, "SELL": 3}
@login_required
def index(request, message=messages):
all_shares = Shares.objects.filter()
paginator = Paginator(all_shares, 10)
page = request.GET.get('pg')
all_shares = paginator.get_page(page)
return render(request, 'index.html', {'all_shares': all_shares})
@login_required
def add_shares(request):
from tqdm import trange
import time
import datetime as dt
#########
tickers = pd.read_csv('dataset/ind_nifty50list.csv')
tickers = pd.DataFrame(tickers.Symbol)
########
dictionary = {'-': '_', '&': '_'}
tickers.replace(dictionary, regex=True, inplace=True)
Stock = {}
handler = TA_Handler()
handler.set_exchange_as_crypto_or_stock("NSE")
handler.set_screener_as_stock("india")
tickers['Strength'] = 0
while True:
handler.set_interval_as(Interval.INTERVAL_1_HOUR)
# tickers.shape[0]
for i in trange(tickers.shape[0]):
try:
handler.set_symbol_as(tickers.Symbol[i])
Stock[tickers.Symbol[i]] = [
handler.get_analysis().summary['RECOMMENDATION'],
handler.get_analysis().indicators['close']
]
#print([i],tickers[i],handler.get_analysis().summary['RECOMMENDATION'])
except:
print("An exception occurred", tickers[i])
Stocks_df = pd.DataFrame.from_dict(Stock,
orient='index',
from binance.client import Client
from binance.enums import *
client = Client(config.API_KEY, config.API_SECRET, tld='com')
now = datetime.now()
fecha = now.strftime("%d-%m-%y %H:%M:%S")
lista = client.get_all_tickers()
strongBuy_list = []
strongSell_list = []
for i in lista:
tesla = TA_Handler()
tesla.set_symbol_as(i['symbol'])
tesla.set_exchange_as_crypto_or_stock("BINANCE")
tesla.set_screener_as_crypto()
tesla.set_interval_as(Interval.INTERVAL_1_HOUR)
print(i['symbol'])
try:
print(tesla.get_analysis().summary)
except Exception as e:
print("No Data")
continue
if ((tesla.get_analysis().summary)["RECOMMENDATION"]) == "STRONG_BUY":
print(f" Compar más fuerte {i}", fecha)
strongBuy_list.append(i['symbol'])
elif ((tesla.get_analysis().summary)["RECOMMENDATION"]) == "STRONG_SELL":
print(f" Compar más fuerte {i}", fecha)
strongSell_list.append(i['symbol'])
print("*** STRONG BUY LIST ***")
cls()
print("Bienvenue sur Tradyglo v.BETA")
while i == 0:
symbol = input("entreprise symbole > ")
exchange = input("place bourisère > ")
country = input("pays > ")
print("-" * 100)
print("Résultats analyses techniques", symbol, ":")
_object = TA_Handler()
_object.set_symbol_as(symbol)
_object.set_exchange_as_crypto_or_stock(exchange)
_object.set_screener_as_stock(country)
_object.set_interval_as(Interval.INTERVAL_1_DAY)
test = _object.get_analysis().summary
print("1 jour >", test)
_object.set_interval_as(Interval.INTERVAL_1_WEEK)
test = _object.get_analysis().summary
print("1 sem >", test)
_object.set_interval_as(Interval.INTERVAL_1_MONTH)
test = _object.get_analysis().summary
print("1 mois >", test)
print("\n")
#cls()
from tqdm import trange
import time
import datetime as dt
#########
tickers = pd.read_csv('dataset/ind_nifty50list.csv')
tickers = pd.DataFrame(tickers.Symbol)
########
dictionary = {'-': '_', '&': '_'}
tickers.replace(dictionary, regex=True, inplace=True)
Stock = {}
handler = TA_Handler()
handler.set_exchange_as_crypto_or_stock("NSE")
handler.set_screener_as_stock("india")
tickers['Strength'] = 0
while True:
handler.set_interval_as(Interval.INTERVAL_1_DAY)
# tickers.shape[0]
for i in trange(tickers.shape[0]):
try:
handler.set_symbol_as(tickers.Symbol[i])
Stock[tickers.Symbol[i]] = [
handler.get_analysis().summary['RECOMMENDATION'],
handler.get_analysis().indicators['close']
]
#print([i],tickers[i],handler.get_analysis().summary['RECOMMENDATION'])
except:
print("An exception occurred", tickers[i])
Stocks_df = pd.DataFrame.from_dict(Stock,
orient='index',
from tqdm import trange
import time
import datetime as dt
#########
tickers = pd.read_csv('dataset/ind_nifty50list.csv')
tickers = pd.DataFrame(tickers.Symbol)
########
dictionary = {'-': '_', '&': '_'}
tickers.replace(dictionary, regex=True, inplace=True)
Stock = {}
handler = TA_Handler()
handler.set_exchange_as_crypto_or_stock("NSE")
handler.set_screener_as_stock("india")
tickers['Strength'] = 0
while True:
handler.set_interval_as(Interval.INTERVAL_15_MINUTES)
# tickers.shape[0]
for i in trange(tickers.shape[0]):
try:
handler.set_symbol_as(tickers.Symbol[i])
Stock[tickers.Symbol[i]] = [
handler.get_analysis().summary['RECOMMENDATION'],
handler.get_analysis().indicators['close']
]
#print([i],tickers[i],handler.get_analysis().summary['RECOMMENDATION'])
except:
print("An exception occurred", tickers[i])
Stocks_df = pd.DataFrame.from_dict(Stock,
orient='index',
