async def readOptionChain(self, ctx, stock=None): """Takes a stock ticker as the parameter to parse multiple option chains for multiple dynamically generated expirations (currently set to next 3 monthly expirations) and prints out information regarding a stock option's volume * current price. The printout takes the 5 best results and showcases it, as well as the entire OCs tallied up to show a preferred side. :param ctx: :param stock: :return: """ if stock and s.validateTicker(stock): price = s.tickerPrice(stock) if price >= 10: junk = await ctx.send("```" + "Loading the option chain for " + str(stock).upper() + "..." + "```") try: res = flow.mostExpensive(stock) if res: await ctx.send("```" + res + "```") except: await ctx.send("```" + "Failed to load the option chain for " + str(stock).upper() + "\n" "This may be due to low activity in the option chain, Robinhood API, " "or other abnormal activity." + "```") finally: await junk.delete() else: await ctx.send("```" + stock.upper() + " is not a valid ticker for options.\n" + "```") elif stock: await ctx.send("```" + stock.upper() + " is not a valid ticker.\n" + "```") else: res = "Read Option Info: Displays closest valued options for a ticker with which side is dominating and " \ "top 5 most valued strikes.\n" + \ "Ex. .read [stock]\n" await ctx.send("```" + res + "```")
async def findOptionChain(self, ctx, stock=None, type=None, expir=None): """Takes in a stock ticker, an optional expiration date (defaulted to friday expiration [if applicable]), a type (defaulted to call) and prints the information (Strike, price, volume, OI) on 1 ITM strike and 3 OTM strikes to discord. :param ctx: :param stock: {1-5} character stock-ticker. :param type: Defaulted to 'call'. Can be either 'call' or 'put'. :param expir: Defaulted to 'None'. Represents the expiration date in the format YYYY-MM-DD :return: """ if stock and s.validateTicker(stock): price = s.tickerPrice(stock) if price >= 5: res = o.pcOptionChain(stock, type, expir, price) await ctx.send("```" + res + "```") else: await ctx.send("```" + stock.upper() + " is not a valid ticker for options.\n" + "```") elif stock: await ctx.send("```" + stock.upper() + " is not a valid ticker.\n" + "```") else: res = "Option chain: Displays stock option chain information based on ticker, type (call or put), " \ "and expiration.\n" + \ "Ex: .f [stock]\n" + \ "Ex: .f [stock], [type]\n" + \ "Ex: .f [stock], [type], [expiration]\n" await ctx.send("```" + res + "```")
def generate_multiple_months(ticker, quantity): strike = round10(s.tickerPrice(ticker)) monthly1 = validateExp(ticker, str(third_friday(getYear(), getMonth(), getMonthlyDay())), 'call', strike) months = [monthly1] for i in range(1, quantity): months.append(validateExp(ticker, generate_next_month_exp(months[i - 1]), 'call', strike)) return months
def loadStrikes_SPY(): """Loads strikes into call_strikes & put_strikes for SPY :return: """ price = s.tickerPrice('SPY') callprice = o.roundPrice(price, 1, 'call') putprice = o.roundPrice(price, 1, 'put') for i in range(0, 15): # Now that we have the iterator and rounded price, collect actual strikes call_strikes_SPY.append(o.grabStrike(callprice, 1, 'call', i)) put_strikes_SPY.append(o.grabStrike(putprice, 1, 'put', i))
def validateStrike(stock, type, expir, strike): """Given parameters that should all be correct validate strike price. If strike price is not correct, return a correct one. :param stock: :param type: :param expir: :param strike: :return: """ price = s.tickerPrice(stock) if not r.find_options_by_expiration_and_strike(stock, expir, strike, type): strikeIterator = searchStrikeIterator(stock, type, expir, price) price = roundPrice(price, strikeIterator, type) return grabStrike(price, strikeIterator, type, 0) else: return strike
def checkAnomalies(timestamp, daystamp): """Called every 3m to check records against current option values. Reports any anomalies found. :param timestamp: :return: """ anomaly = generate_SPY() if anomaly: price = s.tickerPrice('SPY') res = "Found large cash movement in past 3 min:\nCurrent SPY price @ " + str(price) + "\n" w = csv.writer(open(anomalies_csv, "w")) for val in anomaly: cost = formatIntForHumans(anomaly.get(val)['diff']) curr = str(int(anomaly.get(val)['curr'])) volume = str(anomaly.get(val)['volume']) gamma = str(anomaly.get(val)['gamma']) dte = str(anomaly.get(val)['dte']) w.write([val, dte, cost, curr, volume, gamma, daystamp, timestamp[2:]]) res += dte + val[10:] + ': +$' + cost + " Price: $" + curr + " Vol: " + volume + " Gamma: " + gamma + "\n" return res
def loadStrikes(ticker, expir): """Loads strikes into call_strikes & put_strikes :return: 2 lists: call_strikes & put_strikes """ strike_value = {} days_till_expiration = [] callStrikeIterator = [] price = s.tickerPrice(ticker) for exp in expir: days_till_expiration.append(cal.DTE(exp)) callStrikeIterator.append( o.searchStrikeIterator(ticker, 'call', exp, price)) call_value = o.pcOptionMin( ticker, 'call', expir, strike_value, days_till_expiration, o.roundPrice(price, callStrikeIterator[0], 'call'), callStrikeIterator) put_value = o.pcOptionMin( ticker, 'put', expir, strike_value, days_till_expiration, o.roundPrice(price, callStrikeIterator[0], 'put'), callStrikeIterator) return strike_value, [call_value, put_value]