def load_prices(self, interval='day'): trader = Robinhood() # get prices # note: api takes 75 or fewer tickers self.ticker_prices = [] segments = list(range(0, len(self.tickers), 75)) if segments[-1] != len(self.tickers): segments.append(len(self.tickers)) for i in list(range(1, len(segments))): tp = trader.get_historical_quotes( self.tickers[segments[i - 1]:segments[i]], interval='day', span='year')['results'] self.ticker_prices = self.ticker_prices + tp self.full_market = np.zeros(( len(self.ticker_prices[0]['historicals']), # day dim len(self.tickers), # ticker dim 2)) # var dim (open, close) self.len_hist = self.full_market.shape[0] # for each day for day in list(range((self.len_hist - 1))): for ticker in list(range(len(self.tickers))): if self.ticker_prices[ticker]['historicals']: day_ticker_p = self.ticker_prices[ticker]['historicals']\ [self.len_hist - 1 - day] p_open = day_ticker_p['open_price'] p_close = day_ticker_p['close_price'] self.full_market[day][ticker] = [p_open, p_close] else: self.full_market[day][ticker] = [None, None]
def __init__(self): self.home_path = os.path.abspath(os.getcwd()) if 'ec2-user' in self.home_path: self.home_path = '/home/ec2-user/takaomattcom' self.par_path = '/home/ec2-user/' else: self.par_path = os.path.dirname(self.home_path) + '/' self.home_path += '/' with open(self.par_path + '/auth/robinhood.txt') as f: data = f.read().split('\n') RH_username = data[0] RH_password = data[1] with open(self.par_path + '/auth/alphavantage.txt') as f: self.av_API = f.read().split('\n')[0] self.my_trader = Robinhood() self.my_trader.login(username=RH_username, password=RH_password) self.equity = self.my_trader.equity() conn_users = sqlite3.connect(self.home_path + 'users.db') cursor_users = conn_users.cursor() self.users = cursor_users.execute("SELECT * FROM user;").fetchall() associate = { '*****@*****.**': 'Matt', '*****@*****.**': 'Tim', '*****@*****.**': 'Mazy', '*****@*****.**': 'Andrew' } self.users = { str(x[2]): [associate[x[2]], x[4], str(x[5])] for x in self.users }
def __init__(self, title='', num_stocks=15, mailing_list=[], debug=False): self.title = title self.num_stocks = num_stocks self.home_path = os.path.abspath(os.getcwd()) if 'ec2-user' in self.home_path: self.home_path = '/home/ec2-user/capit-vita' self.file_path = self.home_path + '/data/' self.par_path = os.path.dirname(self.home_path) + '/' self.home_path = self.home_path + '/' if os.path.exists(self.par_path + '/takaomattcom/static/img/stocks/'): self.alt_file_path = self.par_path + '/takaomattcom/static/img/stocks/' else: self.alt_file_path = None #print('capit', self.home_path, self.file_path, self.par_path, self.alt_file_path) self.mailing_list = mailing_list self.debug = debug self.batchSize = 50 with open(self.par_path + '/auth/alphavantage.txt') as f: self.av_API = f.read().split('\n')[0] with open(self.par_path + '/auth/robinhood.txt') as f: data = f.read().split('\n') robinhood_username = data[0] robinhood_password = data[1] self.trader = Robinhood() self.trader.login(username=robinhood_username, password=robinhood_password)
def _get_stock_assets_value(rh: Robinhood) -> float: """Returns the total value held in stocks""" positions = rh.positions()["results"] stock_assets = 0 for position in positions: num_stocks = float(position["quantity"]) if num_stocks == 0: # Sometimes RH returns stocks that have never been bought by # the account continue instrument = rh.get_url(position["instrument"]) if instrument["state"] == "inactive": # This symbol may have been discontinued and changed into a # different symbol. Calling get_quote() will result in an # InvalidTickerSymbol exception continue symbol = instrument["symbol"] quote = rh.get_quote(symbol) price_str = quote["last_extended_hours_trade_price"] if price_str is None: price_str = quote["last_trade_price"] stock_assets += float(price_str) * num_stocks return stock_assets
class RobinhoodExporter: """ Exports metadata about a Robinhood user's held securities and portfolio. """ def __init__(self, mfa_code, username=None, password=None): username = os.environ['rh_user'] if not username else username password = os.environ['rh_pass'] if not password else password try: self.rh = Robinhood() if not self.rh.login(username, password, mfa_code): raise LoginException("Invalid login credentials.") except: raise LoginException("Invalid login credentials.") def _securities_to_quotes(self, securities): return self.rh.get_url(quote_endpoint(securities))['results'] def _stocks_from_securities(self, securities): for security, quote in zip(securities, self._securities_to_quotes(securities)): yield Stock.from_security_and_quote(security, quote) def export_portfolio(self, export_func=None): securities = self.rh.securities_owned() stocks = list(self._stocks_from_securities(securities['results'])) total_equity = self.rh.equity() portfolio = Portfolio(total_equity, stocks) if export_func: export_func(portfolio) return portfolio
def __init__(self): self.start_time = datetime.now() self.my_trader = Robinhood() self.my_trader.login(username=usrnm, password=pssw) self.equity = self.my_trader.equity() self.owned_securities = self.my_trader.securities_owned() self.available_funds = self.my_trader.equity() - sum([x[1]*x[4] for x in self.my_trader.securities_owned()]) self.buy_limit = 120 self.stocks = [] self.ld = 10 ## sell no matter what self.sd = 5 ## sell if positive self.file_path = home_path self.conn = sqlite3.connect(self.file_path+'log.db') self.conn.execute('drop table if exists history') self.conn.execute('''create table history (id int primary key not null, date text not null, activity text not null, stock text not null, gain text not null);''') self.idCount = 1 print('Deleting old files...') # delete old files os.chdir(self.file_path) for f in glob.glob("*.png"): os.remove(f)
def get_stock_info(self): print("Getting stock data from Robinhood") trader = Robinhood() quotes = zip(self.stock_list, trader.quotes_data(self.stock_list)) return quotes
def __init__(self): cmd.Cmd.__init__(self) self.trader = Robinhood() try: data = open(self.auth_file).read() auth_data = json.loads(data) if 'auth_token' in auth_data: self.trader.device_token = auth_data['device_token'] self.trader.auth_token = auth_data['auth_token'] self.trader.refresh_token = auth_data['refresh_token'] self.trader.relogin_oauth2() self._save_auth_data() self.trader.headers['Authorization'] = 'Bearer ' + self.trader.auth_token except: challenge_type = 'email' if CHALLENGE_TYPE == 'sms': challenge_type = 'sms' self.trader.login(username=USERNAME, password=PASSWORD, challenge_type = challenge_type) try: data = open(self.instruments_cache_file).read() self.instruments_cache = json.loads(data) for k in self.instruments_cache: self.instruments_reverse_cache[self.instruments_cache[k]] = k except: pass try: data = open(self.watchlist_file).read() self.watchlist = json.loads(data) except: pass
def api(self): ''' Sets up the API to RH if able, otherwise warns Args: None Returns: None ''' api = Api(self) if api.exec_(): self.rUser = api.user self.rPass = api.password data = {'Queue': [], 'API': {'Password': self.rPass, 'User': self.rUser}} logging.info('Successfully Created Keys and Config') self.autosave() self.trader = Robinhood() try: self.trader.login(username = self.rUser, password = self.rPass) logging.info('Successfully Logged Into Robinhood') if not self.qModel: self.startup(data) self.update() except requests.exceptions.HTTPError: logging.error('Unsuccessful Login For Robinhood') self.warn('Login Fail') self.api()
def __init__(self): logger.info("logging into Robinhood...") robinhood_username = os.environ.get('ROBINHOOD_USERNAME') robinhood_password = os.environ.get('ROBINHOOD_PASSWORD') self._api = Robinhood() self._api.login(username=robinhood_username, password=robinhood_password) logger.info("logged in to Robinhood.")
def __init__(self): cfg = self.get_config() self.user_name = cfg.get('robinhood').get('user') self.password = cfg.get('robinhood').get('password') self.client = Robinhood() self.client.login(username=self.user_name, password=self.password) self.stock_list = self.get_stock_list(cfg.get('stock')) self.stock_owned()
def login(): username = raw_input('Login: '******'Password: '******'Error: Wrong Email or Password' sys.exit(0) return trader
def _login(self, username, password): self.client = Robinhood() # try import the module with passwords try: _temp = __import__('auth') self.client.login(_temp.local_user, _temp.local_password) except: self.client.login(username=username, password=password) return self
def test_bad_logout(): """logout without logging in""" if not LOGIN_OK: pytest.xfail('cannot test without valid user/passwd') rh_obj = Robinhood() with pytest.warns(UserWarning): req = rh_obj.logout() assert req.status_code != 200
def gather(stock,count): # import the robinhood api library from Robinhood import Robinhood import os import time import datetime #key setup import ast keys =[] f = open('keys') keys = ast.literal_eval(f.read()) f.close() # login ## log into robinhood my_trader = Robinhood(); my_trader.login(username=keys[0][1], password=keys[1][1]) # stock selection ## the variable 'stock' is a string passed through the function #stock = sys.argv[1].upper() stock = stock.upper() stock_instrument = my_trader.instruments(stock)[0] # variable declaration last_trade = 0 bid_price = 0 ask_price = 0 #count = 1 #sell_prices = [] #sell_price_slope = 0 #sell_average_prices = [] #sell_slope_of_averages = 0 #sell_sd = [] #sell_sum = 0 # make timestamp stamp = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S.%f') #stamp = datetime.datetime.fromtimestamp(time.time()).strftime('%S.%f') # set up quote data quote_data = my_trader.quote_data(stock) last_trade = float(quote_data['last_trade_price']) bid_price = float(quote_data['bid_price']) ask_price = float(quote_data['ask_price']) payload = [stamp,last_trade,ask_price,bid_price] # push to redis import redis r_server = redis.Redis(host='localhost',port=6669) r_server.zadd(stock, payload, count)
def __init__(self, mfa_code, username=None, password=None): username = os.environ['rh_user'] if not username else username password = os.environ['rh_pass'] if not password else password try: self.rh = Robinhood() if not self.rh.login(username, password, mfa_code): raise LoginException("Invalid login credentials.") except: raise LoginException("Invalid login credentials.")
def __init__(self, stock, stock_friendly_name, r_username, r_password): self.stock = stock self.stock_friendly_name = stock_friendly_name self.r_username = r_username self.r_password = r_password self.my_trader = Robinhood() logged_in = self.my_trader.login(username=self.r_username, password=self.r_password) if not logged_in: raise Exception("Failed to login") self.quote = self.my_trader.quote_data(self.stock)
def __init__(self, username, password): self.username = username self.password = password self.robinhood = Robinhood() self.loggedin = self.robinhood.login(username=username, password=password) self.trades = self.prep_data()
def get_robinhood_portfolio_value(username, password): my_trader = Robinhood() try: my_trader.login(username=username, password=password) portfolio = my_trader.portfolios() if portfolio['extended_hours_equity']: return float(portfolio['extended_hours_equity']) else: return float(portfolio['equity']) except exceptions.LoginFailed: # This started happening even with valid creds due to robinhood update, expected token response return "BADLOGIN"
def test_logout(config=CONFIG): """make sure logout works""" if not LOGIN_OK: pytest.xfail('cannot test without valid user/passwd') rh_obj = Robinhood() assert rh_obj.login(username=config.get('LOGIN', 'username'), password=config.get('LOGIN', 'password')) assert rh_obj.auth_token is not None req = rh_obj.logout() assert req.status_code == 200
def buy(stock, ask_gap, r): from utils import * import redis r = redis.Redis(host='localhost', port=6669) r.set_response_callback('SMEMBERS', list) # import the robinhood api library from Robinhood import Robinhood import os import time import datetime #key setup import ast keys = [] f = open('keys') keys = ast.literal_eval(f.read()) f.close() # login ## log into robinhood my_trader = Robinhood() my_trader.login(username=keys[0][1], password=keys[1][1]) # config robinhood to trade on that stock stock_instrument = my_trader.instruments(stock)[0] ############################ # BUY LOOP ############################ # average and slope declaration count = 1 buy_prices = [] buy_price_slope = 0 buy_average_prices = [] buy_slope_of_averages = 0 buy_sum = 0 ## begin buy loop buy = False bought_at = 0.0 while buy == False: if (last_bid(stock, r) - last_ask(stock, r)) > ask_gap: # buy a single share of the stock at the ask price #buy_order = my_trader.place_buy_order(stock_instrument, 1, ask_price) # break the buy loop buy = True bought_at = last_ask(stock, r) return buy, bought_at
def __init__(self): cmd.Cmd.__init__(self) self.trader = Robinhood() self.trader.login(username=USERNAME, password=PASSWORD) try: data = open('instruments.data').read() self.instruments_cache = json.loads(data) for k in self.instruments_cache: self.instruments_reverse_cache[self.instruments_cache[k]] = k except: pass
def __init__(self): cmd.Cmd.__init__(self) self.trader = Robinhood() self.trader.login_prompt() try: data = open('instruments.data').read() self.instruments_cache = json.loads(data) for k in self.instruments_cache: self.instruments_reverse_cache[self.instruments_cache[k]] = k except: pass
def test_intstruments(config=CONFIG): """test `instruments` endpoint""" #TODO: this test is bad, just repeat of code inside endpoint params = {'query': CONFIG.get('FETCH', 'test_ticker')} headers = {'User-Agent': CONFIG.get('FETCH', 'user_agent')} address = Robinhood().endpoints['instruments'] res = requests.get(address, headers=headers, params=params) res.raise_for_status() hard_data = res.json()['results'] data = Robinhood().instruments(CONFIG.get('FETCH', 'test_ticker')) assert data == hard_data
class RobinhoodSource(object): def __init__(self, stock, stock_friendly_name, r_username, r_password): self.stock = stock self.stock_friendly_name = stock_friendly_name self.r_username = r_username self.r_password = r_password self.my_trader = Robinhood() logged_in = self.my_trader.login(username=self.r_username, password=self.r_password) if not logged_in: raise Exception("Failed to login") self.quote = self.my_trader.quote_data(self.stock) def set_position(self, avg_price, shares, unvested_shares): self.avg_price = avg_price self.shares = shares self.unvested_shares = unvested_shares @property def quote(self): return self.robinhood_quote @quote.setter def quote(self, robinhood_quote_dict): self.robinhood_quote = RobinhoodQuote(robinhood_quote_dict) def get_response(self): slugs = { 'last_trade_price': float(self.quote.last_trade_price), 'previous_close': float(self.quote.previous_close), 'stock_friendly_name': self.stock_friendly_name } slugs['stock_percent_change'] = 100.0 * ((slugs['last_trade_price'] - slugs['previous_close']) / slugs['previous_close']) slugs['stock_percent_change_abs'] = abs(slugs['stock_percent_change']) slugs['stock_up_down'] = 'up' if slugs['stock_percent_change'] > 0.0 else 'down' ar = AlexaResponse(slugs, preamble='From Robinhood') ar.add_blurb("{stock_friendly_name} stock is {stock_up_down} {stock_percent_change_abs:.1f}%, trading at ${last_trade_price:.0f}") ar.set_title(ar.get_blurbs()[0]) if set(['avg_price', 'unvested_shares', 'shares']).intersection(dir(self)): slugs['portfolio_percent_change'] = 100 * ((slugs['last_trade_price'] - self.avg_price) / self.avg_price) slugs['portfolio_percent_change_abs'] = abs(slugs['portfolio_percent_change']) slugs['portfolio_up_down'] = 'up' if slugs['portfolio_percent_change'] > 0.0 else 'down' slugs['portfolio_vested_value'] = float(self.shares) * slugs['last_trade_price'] slugs['portfolio_potential_value'] = (self.shares + self.unvested_shares) * slugs['last_trade_price'] ar.add_blurb("You are {portfolio_up_down} {portfolio_percent_change_abs:.1f}" + " percent with a total value of approximately ${portfolio_vested_value:0.0f}" + " and a potential value of ${portfolio_potential_value:0.0f} if all shares vest") return ar
def init(): global driver global page_date global my_trader global logged_in my_trader = Robinhood() username_input = input("Robinhood Username:") password_input = getpass.getpass() logged_in = my_trader.login(username=username_input,password=password_input) page_date = 'NULL' driver = webdriver.Chrome(r'C:\Users\migue\Desktop\StockBot\chromedriver.exe') print('driver initialized')
def __init__(self, parent=None): QtWidgets.QDialog.__init__(self, parent) self.setupUi(self) try: from resources.NASDAQ import tickCurrents nTest = tickCurrents('NVDA') if nTest: if nTest['LTP']: self.setStates(self.nState, True) else: self.setStates(self.nState, False) else: self.setStates(self.nState) except ImportError: self.setStates(self.nState) try: from Robinhood import Robinhood rTest = Robinhood() self.setStates(self.rState, True) except: self.setStates(self.rState)
def test_get_news(config=CONFIG): """test `get_news` endpoint""" test_ticker = CONFIG.get('FETCH', 'test_ticker') raw_news = helpers.fetch_REST_directly('news', test_ticker, config) get_news = Robinhood().get_news(test_ticker) assert get_news == raw_news
def _get_crypto_assets_value(rh: Robinhood) -> float: """Returns the total value held in crypto""" # print(rh.crypto_orders()) crypto_assets = 0 crypto_holdings_data = rh.crypto_holdings()["results"] for crypto_holding in crypto_holdings_data: quantity_available = float(crypto_holding["quantity_available"]) if quantity_available == 0: continue code = crypto_holding["currency"]["code"] market_price_str = rh.crypto_quote(rh.CRYPTO_PAIRS[code])["mark_price"] crypto_assets += quantity_available * float(market_price_str) return crypto_assets
def __init__(self): cmd.Cmd.__init__(self) self.trader = Robinhood() # Robinhood now uses 2FA # The workflow we use is as follows # If we find auth token in auth.data - try to see if it still works # If yes, continue # If no, try to refresh the token using refresh token # If it still fails, we need to relogin with 2FA try: data = open(self.auth_file).read() auth_data = json.loads(data) if 'auth_token' in auth_data: self.trader.device_token = auth_data['device_token'] self.trader.auth_token = auth_data['auth_token'] self.trader.refresh_token = auth_data['refresh_token'] self.trader.headers[ 'Authorization'] = 'Bearer ' + self.trader.auth_token try: self.trader.user() except: del self.trader.headers['Authorization'] self.trader.relogin_oauth2() self._save_auth_data() except: challenge_type = 'email' if CHALLENGE_TYPE == 'sms': challenge_type = 'sms' self.trader.login(username=USERNAME, password=PASSWORD, challenge_type=challenge_type) self._save_auth_data() try: data = open(self.instruments_cache_file).read() self.instruments_cache = json.loads(data) for k in self.instruments_cache: self.instruments_reverse_cache[self.instruments_cache[k]] = k except: pass try: data = open(self.watchlist_file).read() self.watchlist = json.loads(data) except: pass
def test_login_badpass(config=CONFIG): """try to login with bad creds""" if not LOGIN_OK: pytest.xfail('cannot test without valid user/passwd') bad_pass = '******' with pytest.raises(RH_exception.LoginFailed): Robinhood().login(username=config.get('LOGIN', 'username'), password=bad_pass)
class RobinhoodUtility: __robinhood = Robinhood() __sell_book_path = 'configs/robinhood_sell_book.csv' @staticmethod def is_order_open(order: dict) -> bool: return order['state'] == 'queued' or order[ 'state'] == 'unconfirmed' or order['state'] == 'confirmed' @staticmethod def instrument_2_symbol(instrument: str) -> str: return RobinhoodUtility.__robinhood.get_url(instrument)['symbol'] @staticmethod def symbol_2_instrument(symbol: str) -> str: return RobinhoodUtility.__robinhood.get_url( 'https://api.robinhood.com/quotes/%s/' % symbol)['instrument'] @staticmethod def is_market_open(): current_time_est = datetime.datetime.now(pytz.timezone('US/Eastern')) return datetime.time( hour=9, minute=30) <= current_time_est.time() <= datetime.time( hour=16, minute=00) @staticmethod def get_max_trade_price(symbol: str, bid_price: bool = True, ask_price: bool = False) -> float: trade_prices = RobinhoodUtility.__robinhood.last_trade_price(symbol) if bid_price: trade_prices += RobinhoodUtility.__robinhood.bid_price(symbol) if ask_price: trade_prices += RobinhoodUtility.__robinhood.ask_price(symbol) return float(max(max(trade_prices))) @staticmethod def load_sell_book() -> pd.DataFrame: return pd.read_csv(RobinhoodUtility.__sell_book_path, index_col=0).astype('float') @staticmethod def save_sell_book(sell_book: pd.DataFrame): sell_book.to_csv(RobinhoodUtility.__sell_book_path) @staticmethod def upload_sell_book(sell_book: pd.DataFrame, github_token: str) -> bool: repo = github.Github(github_token).get_user().get_repo('finance') remote_path = '/%s' % RobinhoodUtility.__sell_book_path remote_file = repo.get_file_contents(remote_path) new_file = sell_book.to_csv() uploaded = False if remote_file.decoded_content != new_file.encode('ascii'): repo.update_file(remote_path, 'update sell book', sell_book.to_csv(), remote_file.sha) RobinhoodUtility.save_sell_book(sell_book) uploaded = True return uploaded
'date': order['last_transaction_at'], 'state': order['state'] } def get_all_history_orders(rb_client): orders = [] past_orders = rb.order_history() orders.extend(past_orders['results']) while past_orders['next']: print("{} order fetched".format(len(orders))) next_url = past_orders['next'] past_orders = fetch_json_by_url(rb_client, next_url) orders.extend(past_orders['results']) print("{} order fetched".format(len(orders))) return orders rb = Robinhood() # !!!!!! change the username and passs, be careful when paste the code to public rb.login(username="******", password="******") past_orders = get_all_history_orders(rb) instruments_db = shelve.open('instruments.db') orders = [order_item_info(order, rb, instruments_db) for order in past_orders] keys = ['side', 'symbol', 'shares', 'price', 'date', 'state'] with open('orders.csv', 'w') as output_file: dict_writer = csv.DictWriter(output_file, keys) dict_writer.writeheader() dict_writer.writerows(orders)
totalTransacts = 0 cash = 0 minCash = cash netWorth = 0 minNetWorth = 0 maxNetWorth = 0 cashHistory = [] netHistory = [] shareHistory = [] #Setup my_trader = Robinhood(); #login print "\n\nWelcome to MarketMiner\n" print time.asctime() ,"\n" #username = raw_input("Robinhood Username: "******"YOUR_USERNAME", password="******") sys.stdout.flush() start_time = time.time()
logged_in = False # hard code your credentials here to avoid entering them each time you run the script username = "" password = "" parser = argparse.ArgumentParser(description='Export Robinhood trades to a CSV file') parser.add_argument('--debug', action='store_true', help='store raw JSON output to debug.json') parser.add_argument('--username', default=username, help='your Robinhood username') parser.add_argument('--password', default=password, help='your Robinhood password') args = parser.parse_args() username = args.username password = args.password robinhood = Robinhood(); # login to Robinhood while not logged_in: if username == "": print "Robinhood username:"******"": password = getpass.getpass() logged_in = robinhood.login(username=username, password=password) if logged_in == False: password = "" print "Invalid username or password. Try again.\n", fields = collections.defaultdict(dict)
from Robinhood import Robinhood my_trader = Robinhood(username="******", password="******") #get stock information about a stock # Note: for some stock names, more than one instrument # may be returned for a given stock symbol stock_instrument = my_trader.instruments("GEVO")[0] #You can stock information about current bid_price, etc quote_info = my_trader.quote_data("GEVO") #place a buy order (uses market bid price) buy_order = my_trader.place_buy_order(stock_instrument, 1) #place a sell order sell_order = my_trader.place_sell_order(stock_instrument, 1)
from Robinhood import Robinhood #Setup my_trader = Robinhood() #login my_trader.login(username="******", password="******") #Get stock information #Note: Sometimes more than one instrument may be returned for a given stock symbol stock_instrument = my_trader.instruments("GEVO")[0] #Get a stock's quote my_trader.print_quote("AAPL") #Prompt for a symbol my_trader.print_quote() #Print multiple symbols my_trader.print_quotes(stocks=["BBRY", "FB", "MSFT"]) #View all data for a given stock ie. Ask price and size, bid price and size, previous close, adjusted previous close, etc. quote_info = my_trader.quote_data("GEVO") print(quote_info) #Place a buy order (uses market bid price) buy_order = my_trader.place_buy_order(stock_instrument, 1) #Place a sell order sell_order = my_trader.place_sell_order(stock_instrument, 1)
from Robinhood import Robinhood #Setup my_trader = Robinhood(username="******", password="******"); #Get stock information #Note: Sometimes more than one instrument may be returned for a given stock symbol stock_instrument = my_trader.instruments("GEVO")[0] #Get a stock's quote my_trader.print_quote("AAPL") #Prompt for a symbol my_trader.print_quote(); #Print multiple symbols my_trader.print_quotes(stocks=["BBRY", "FB", "MSFT"]) #View all data for a given stock ie. Ask price and size, bid price and size, previous close, adjusted previous close, etc. quote_info = my_trader.quote_data("GEVO") print(quote_info); #Place a buy order (uses market bid price) buy_order = my_trader.place_buy_order(stock_instrument, 1) #Place a sell order sell_order = my_trader.place_sell_order(stock_instrument, 1)