def analyze(pairs): taMax = 0 taMaxCoin = 'none' signal_coins = {} first_analysis = {} second_analysis = {} first_handler = {} second_handler = {} if os.path.exists('signals/signalsample.exs'): os.remove('signals/signalsample.exs') for pair in pairs: first_handler[pair] = TA_Handler( symbol=pair, exchange=MY_EXCHANGE, screener=MY_SCREENER, interval=MY_FIRST_INTERVAL, timeout= 10 ) second_handler[pair] = TA_Handler( symbol=pair, exchange=MY_EXCHANGE, screener=MY_SCREENER, interval=MY_SECOND_INTERVAL, timeout= 10 ) for pair in pairs: try: first_analysis = first_handler[pair].get_analysis() second_analysis = second_handler[pair].get_analysis() except Exception as e: print("Exeption:") print(e) print (f'Coin: {pair}') print (f'First handler: {first_handler[pair]}') print (f'Second handler: {second_handler[pair]}') tacheckS = 0 first_tacheck = first_analysis.summary['BUY'] second_tacheck = second_analysis.summary['BUY'] if FULL_LOG: print(f'{pair} First {first_tacheck} Second {second_tacheck}') else: print(".", end = '') if first_tacheck > taMax: taMax = first_tacheck taMaxCoin = pair if first_tacheck >= TA_BUY_THRESHOLD and second_tacheck >= TA_BUY_THRESHOLD: signal_coins[pair] = pair print("") print(f'Signal detected on {pair}') with open('signals/signalsample.exs','a+') as f: f.write(pair + '\n') print("") print(f'Max signal by {taMaxCoin} at {taMax} on shortest timeframe') return signal_coins
def get_tradingview_recommendation(ticker: str, screener: str, exchange: str, interval: str) -> pd.DataFrame: """Get tradingview recommendation based on technical indicators Parameters ---------- ticker : str Ticker to get the recommendation from tradingview based on technical indicators screener : str Screener based on tradingview docs https://python-tradingview-ta.readthedocs.io/en/latest/usage.html exchange: str Exchange based on tradingview docs https://python-tradingview-ta.readthedocs.io/en/latest/usage.html interval: str Interval time to check technical indicators and correspondent recommendation Returns ------- df_recommendation: pd.DataFrame Dataframe of tradingview recommendations based on technical indicators """ if not exchange: s_req = f"https://www.alphavantage.co/query?function=OVERVIEW&symbol={ticker}&apikey={cfg.API_KEY_ALPHAVANTAGE}" result = requests.get(s_req, stream=True) exchange = result.json()["Exchange"] if not interval: df_recommendation = pd.DataFrame() index_recommendation = [] for an_interval in ["1M", "1W", "1d", "4h", "1h", "15m", "5m", "1m"]: # If the returned data was successful if result.status_code == 200: stock_recommendation = TA_Handler( symbol=ticker, screener=screener, exchange=exchange, interval=an_interval, ) d_recommendation = stock_recommendation.get_analysis().summary df_recommendation = df_recommendation.append(d_recommendation, ignore_index=True) index_recommendation.append(INTERVALS[an_interval]) df_recommendation.index = index_recommendation df_recommendation[["BUY", "NEUTRAL", "SELL"]] = df_recommendation[[ "BUY", "NEUTRAL", "SELL" ]].astype(int) df_recommendation.index.name = "Interval" else: stock_recommendation = TA_Handler(symbol=ticker, screener=screener, exchange=exchange, interval=interval) d_recommendation = stock_recommendation.get_analysis().summary df_recommendation = pd.DataFrame.from_dict(d_recommendation, orient="index").T df_recommendation.index = INTERVALS[interval] return df_recommendation
def analyze(): analysis = {} handler = {} handler = TA_Handler(symbol=SYMBOL, exchange=EXCHANGE, screener=SCREENER, interval=INTERVAL, timeout=10) try: analysis = handler.get_analysis() except Exception as e: print("pausebotmod:") print("Exception:") print(e) ma_sell = analysis.moving_averages['SELL'] if ma_sell >= THRESHOLD: paused = True print( f'pausebotmod: Market not looking too good, bot paused from buying {ma_sell}/{THRESHOLD}' ) else: print( f'pausebotmod: Market looks ok, bot is running {ma_sell}/{THRESHOLD}' ) paused = False return paused
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.")
async def coin(message: types.Message): _lang = Lang(_langs, message.from_user.language_code)._lang if message.get_args() == "": data = ["BTCUSD", "BINANCE"] elif re.match(r"^[a-zA-Z]{6,8}$", message.get_args()): data = [re.search(r"^[a-zA-Z]{6,8}$", message.get_args()).group(), "BINANCE"] elif re.match(r"^[a-zA-Z]{6,8}:[a-zA-Z]{4,}$", message.get_args()): data = re.findall(r"^([a-zA-Z]{6,8}):([a-zA-Z]{4,})$", message.get_args())[0] else: return await message.reply(_lang["FORMAT"]) try: handler = TA_Handler( screener= "crypto", exchange= data[1], symbol= data[0], interval= "1d" ) analysis = handler.get_analysis() open_price = analysis.indicators["open"] close_price = analysis.indicators["close"] variance = ((close_price / open_price) -1) * 100 await message.reply(_lang["SUMMARY"].format( pair= data[0], exchange= data[1], emoji= "⬆️" if variance > 0 else "⬇️", variance= format(variance, ".2f"), recommended= _lang[analysis.summary["RECOMMENDATION"]], open_price= format_price(open_price), close_price= format_price(close_price) )) except: return await message.reply(_lang["NOT_FOUND"])
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 do_GET(self): o = urlparse(self.path) qParsed = parse_qs(o.query) symbol = qParsed['symbol'][0] screener = qParsed['screener'][0] exchange = qParsed['exchange'][0] interval = qParsed['interval'][0] tv = TA_Handler(symbol=symbol, screener=screener, exchange=exchange, interval=interval) analyse = tv.get_analysis() print({symbol, screener, exchange, interval}, analyse) self._set_headers() self.wfile.write( bytes( json.dumps({ 'request': { 'symbol': symbol, 'screener': screener, 'exchange': exchange, 'interval': interval }, 'result': { 'summary': analyse.summary, 'time': analyse.time.isoformat(), 'oscillators': analyse.oscillators, 'moving_averages': analyse.moving_averages, 'indicators': analyse.indicators } }), "utf-8"))
def tradingview_rec(ticker, timeframe): try: if timeframe == "week": handler = TA_Handler( symbol=ticker, screener="america", exchange="NASDAQ", interval=Interval.INTERVAL_1_WEEK ) elif timeframe == "month": handler = TA_Handler( symbol=ticker, screener="america", exchange="NASDAQ", interval=Interval.INTERVAL_1_MONTH ) return handler.get_analysis().summary except: return "Could not fetch recommendation"
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 run(self): while 1: handler = TA_Handler( symbol="USDTUSD", exchange="KRAKEN", screener="crypto", interval=Interval.INTERVAL_1_MINUTE ) self.lock.acquire() self.tether_index[0] = handler.get_analysis().indicators['close'] self.lock.release() time.sleep(2)
def analyze(pairs): signal_coins = {} analysis = {} handler = {} if os.path.exists('signals/custsignalmod.exs'): os.remove('signals/custsignalmod.exs') for pair in pairs: handler[pair] = TA_Handler(symbol=pair, exchange=EXCHANGE, screener=SCREENER, interval=INTERVAL, timeout=10) for pair in pairs: try: analysis = handler[pair].get_analysis() except Exception as e: print("Signalsample:") print("Exception:") print(e) print(f'Coin: {pair}') print(f'handler: {handler[pair]}') oscCheck = 0 maCheck = 0 for indicator in OSC_INDICATORS: if analysis.oscillators['COMPUTE'][indicator] == 'BUY': oscCheck += 1 for indicator in MA_INDICATORS: if analysis.moving_averages['COMPUTE'][indicator] == 'BUY': maCheck += 1 if FULL_LOG: print( f'Custsignalmod:{pair} Oscillators:{oscCheck}/{len(OSC_INDICATORS)} Moving averages:{maCheck}/{len(MA_INDICATORS)}' ) if oscCheck >= OSC_THRESHOLD and maCheck >= MA_THRESHOLD: signal_coins[pair] = pair print( f'Custsignalmod: Signal detected on {pair} at {oscCheck}/{len(OSC_INDICATORS)} oscillators and {maCheck}/{len(MA_INDICATORS)} moving averages.' ) with open('signals/custsignalmod.exs', 'a+') as f: f.write(pair + '\n') return signal_coins
async def recom(ctx, stock_name): """Shows what you should do with a stock, buy or sell""" """try: ticker = yf.Ticker(str(stock_name)) rec = pd.DataFrame(ticker.recommendations) except: return await ctx.send("```" + str(rec.tail(1)) + "```")""" try: #see if the stock is in NASDAQ handler = TA_Handler(symbol=str(stock_name), screener="america", exchange="NASDAQ", interval=Interval.INTERVAL_1_DAY) analysis = handler.get_analysis() #get the analysis of the stock except: try: #see if the stock is in the NYSE handler = TA_Handler(symbol=str(stock_name), screener="america", exchange="NYSE", interval=Interval.INTERVAL_1_DAY) analysis = handler.get_analysis() except: try: #else check if its a crypto handler = TA_Handler(symbol=str(stock_name), screener="crypto", exchange="binance", interval=Interval.INTERVAL_1_DAY) analysis = handler.get_analysis() except: return #if none of the above end the function await ctx.send( "```You should {0} {1} right NOW!```".format( ''.join(analysis.summary['RECOMMENDATION'].replace('_', ' ')), stock_name) ) #tells the user what they should do with the stock or crypto
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 __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 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 get_macd_indicator(self, symbol): _handler = TA_Handler(symbol="{0}".format(symbol), screener="crypto", exchange="binance", interval=MACD_INTERVAL) _analysis = _handler.get_analysis() _ema10 = _analysis.indicators['EMA10'] _ema20 = _analysis.indicators['EMA20'] if _ema10 > _ema20: position = 'BUY' else: position = 'SELL' if position != self.tickers['{0}'.format(symbol)]['lastPosition']: return position return None
print("Testing {}Tradingview-TA{} v{}{}".format(Fore.CYAN, Fore.MAGENTA, tradingview_ta.__version__, Style.RESET_ALL)) print( "This test is {}semi-automatic{}. Please compare with tradingview's data manually." .format(Fore.LIGHTRED_EX, Style.RESET_ALL)) print("------------------------------------------------") COUNT = 5 success = 0 print("{}#0{} {}Testing invalid symbol{}".format(Fore.BLUE, Style.RESET_ALL, Fore.LIGHTBLUE_EX, Style.RESET_ALL)) handler = TA_Handler(symbol="ThisSymbolIsInvalid", interval="1m", screener="america", exchange="NASDAQ") try: analysis = handler.get_analysis() if analysis: print("{}#0{} Invalid symbol test {}failed{}. No exception occured.". format(Fore.BLUE, Style.RESET_ALL, Fore.RED, Style.RESET_ALL)) except Exception as e: if str(e) == "Exchange or symbol not found.": print("{}#0{} Invalid symbol test {}success{}.".format( Fore.BLUE, Style.RESET_ALL, Fore.GREEN, Style.RESET_ALL)) success += 1 else: print( "{}#0{} Invalid symbol test {}failed{}. An exception occured, but the symbol is valid." .format(Fore.BLUE, Style.RESET_ALL, Fore.RED, Style.RESET_ALL))
#print(tradingview_ta.__version__) intervals = [ '1m', #Interval.INTERVAL_1_MINUTE, '5m', #Interval.INTERVAL_5_MINUTES, '15m', #Interval.INTERVAL_15_MINUTES, '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)
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
from tradingview_ta import TA_Handler, Interval # from tradingview_ta import Exchange cryptos = ["BTCUSDT", "ETHUSD"] for crypto in cryptos: print("Sancando info de:", crypto, "...") handler = TA_Handler(symbol=crypto, screener="crypto", exchange="binance", interval=Interval.INTERVAL_1_DAY) handler = TA_Handler() handler.set_symbol_as("BTCUSDT") handler.set_exchange_as_crypto_or_stock("binance") handler.set_screener_as_crypto() handler.set_interval_as(Interval.INTERVAL_1_DAY) analysis = handler.get_analysis() summary = analysis.summary oscillators = analysis.oscillators moving_averages = analysis.moving_averages indicators = analysis.indicators time = analysis.time print("Resumen:", summary) print("Osciladores:", oscillators) print("Medias Moviles:", moving_averages) print("Precios:", indicators) print("Tiempo:", time)
def cls(): os.system('cls' if os.name == 'nt' else 'clear') 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)
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)
def get_tradingview_recommendation(ticker: str, screener: str, exchange: str, interval: str) -> str: """Get tradingview recommendation based on technical indicators Parameters ---------- ticker : str Ticker to get the recommendation from tradingview based on technical indicators screener : str Screener based on tradingview docs https://python-tradingview-ta.readthedocs.io/en/latest/usage.html exchange: str Exchange based on tradingview docs https://python-tradingview-ta.readthedocs.io/en/latest/usage.html interval: str Interval time to check technical indicators and correspondent recommendation Returns ------- str tradingview recommendation based on technical indicators """ if not exchange: s_req = f"https://www.alphavantage.co/query?function=OVERVIEW&symbol={ticker}&apikey={cfg.API_KEY_ALPHAVANTAGE}" result = requests.get(s_req, stream=True) exchange = result.json()["Exchange"] if not interval: df_recommendation = pd.DataFrame() index_recommendation = list() for interv in ["1M", "1W", "1d", "4h", "1h", "15m", "5m", "1m"]: # If the returned data was successful if result.status_code == 200: stock_recommendation = TA_Handler( symbol=ticker, screener=screener, exchange=exchange, interval=interv, ) d_recommendation = stock_recommendation.get_analysis().summary df_recommendation = df_recommendation.append(d_recommendation, ignore_index=True) index_recommendation.append(INTERVALS[interv]) df_recommendation.index = index_recommendation df_recommendation[["BUY", "NEUTRAL", "SELL"]] = df_recommendation[[ "BUY", "NEUTRAL", "SELL" ]].astype(int) df_recommendation["-----"] = "-----" df_recommendation.index.name = "Interval" recommendation = df_recommendation[[ "RECOMMENDATION", "-----", "BUY", "NEUTRAL", "SELL" ]].to_string() else: stock_recommendation = TA_Handler(symbol=ticker, screener=screener, exchange=exchange, interval=interval) d_recommendation = stock_recommendation.get_analysis().summary recommendation = f"Interval: {INTERVALS[interval]}\n" recommendation += f"Recommendation: {d_recommendation['RECOMMENDATION']}\n" recommendation += f"{int(d_recommendation['BUY'])} BUY, {int(d_recommendation['NEUTRAL'])} NEUTRAL" recommendation += f", {int(d_recommendation['SELL'])} SELL" return recommendation
# coding: utf-8 # In[ ]: import pandas as pd from tradingview_ta import TA_Handler, Interval 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'])
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):
"""Using the tradingview-ta package to get ethereum data from binance in 15 minute intervals""" from tradingview_ta import TA_Handler, Interval handler = TA_Handler(symbol="ETHUSD", screener="crypto", exchange="binance", interval=Interval.INTERVAL_15_MINUTES) analysis = handler.get_analysis()
from tradingview_ta import TA_Handler xlmbtc = TA_Handler() xlmbtc.pair = "xlmbtc" xlmbtc.interval = "1m" #xlmbtc.driver = "chrome" #xlmbtc.headless = True xlmbtc.start_driver() analysis = xlmbtc.get_analysis() print(analysis) #Example output: ["Buy", 3, 10, 17]
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")