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
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 __init__(self):
self._future_date = date.today() + timedelta(5)
self._rh = Robinhood()
self._rh.login(username=USERNAME,
password=PASSWORD,
qr_code=MFA)
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)
def __init__(self, name: str = 'pyrh_adapter'):
super().__init__(name, ['pyrh_request', 'trade'])
self.rbn = Robinhood()
self.logged_in = False
self.client_req = Queue()
self.requests = Queue()
self.request_lock = Lock()
def __init__(self, username, pwd, rsi=5):
self.rh = Robinhood()
self.rh.login(username=username, password=pwd)
self.rsiPeriod = rsi
self.enteredPosition = False
self.s = sched.scheduler(time.time, time.sleep)
self.data = np.array([])
self.closePrices = []
def rh_setup():
load_dotenv(verbose=True)
rh_user = os.getenv("ROBINHOOD_USERNAME")
rh_pass = os.getenv("ROBINHOOD_PASSWORD")
rh_qr = os.getenv("ROBINHOOD_QR")
rh = Robinhood()
rh.login(username=rh_user, password=rh_pass, qr_code=rh_qr)
return rh
def addRobinhood(self):
rh = Robinhood()
if self.RobinHoodUser:
rh.login(username=self.RobinHoodUser,
password=self.RobinHoodPassword)
rh.print_quote("AAPL")
else:
print("You must set your Robinhood passwords up in init")
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 login():
load_dotenv()
try:
rh = load_session()
except InvalidCacheFile:
rh = Robinhood(username=os.getenv("username"),
password=os.getenv("password"))
rh.login()
dump_session(rh) # so you don't have to do mfa again
return rh
def login(email: str, password: str, mfa_secret: str) -> Robinhood:
client = Robinhood(email, password)
totp = pyotp.TOTP(mfa_secret)
# We do this, because we don't want to modify the underlying API library
# excessively to support this. Therefore, we monkey-patch our way to
# success.
with mock_stdin(totp.now()):
client.login()
return client
def test_get_historical_data(config=CONFIG):
headers = {"User-Agent": CONFIG.get("FETCH", "user_agent")}
address = Robinhood().endpoints["historicals"]
res = requests.get(
address,
headers=headers,
params={
"symbols": ",".join([CONFIG.get("FETCH", "test_ticker")]).upper(),
"interval": "day",
"span": "year",
"bounds": "regular",
},
)
hard_data = res.json()["results"]
data = Robinhood().get_historical_quotes(
[CONFIG.get("FETCH", "test_ticker")], "day", "year")
assert data == hard_data
def test_cancel_bad_order_id():
"""cancel a naughty order id"""
bad_id = "1234Dx"
if not LOGIN_OK:
pytest.xfail("cannot test without valid user/passwd")
rh_obj = Robinhood()
rh_obj.login(
username=CONFIG.get("LOGIN", "username"),
password=CONFIG.get("LOGIN", "password"),
)
with pytest.raises(ValueError):
rh_obj.cancel_order(bad_id)
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 __init__(self, logger: logging.Logger):
"""Authenticates Robinhood object and gathers the portfolio information to store it in a variable.
Args:
logger: Takes the class ``logging.Logger`` as an argument.
"""
rh = Robinhood()
rh.login(username=env.robinhood_user,
password=env.robinhood_pass,
qr_code=env.robinhood_qr)
raw_result = rh.positions()
self.logger = logger
self.result = raw_result['results']
self.rh = rh
def get(self, request):
#return HttpResponse(request.user.id)
#env = environ.Env(DEBUG=(bool, False))
# reading .env file
#environ.Env.read_env()
currentUser = Account.objects.get(user=request.user)
my_trader = Robinhood()
my_trader.login(username=currentUser.rhoodID,
password=currentUser.rhoodPWD,
qr_code=currentUser.rhQ)
data = my_trader.portfolios()
my_trader.logout()
return HttpResponse(data)
context = {}
return render(request, self.template_name, context)
def create_robinhood_instance(username=None, password=None):
try:
if not username:
username = os.getenv("USERNAME")
if not password:
password = os.getenv("PASSWORD")
rh = Robinhood()
rh.login(username, password)
return rh
except Exception:
logger.error("Failed to login, exiting...")
sys.exit()
def robinhood() -> None:
"""Gets investment details from robinhood API."""
if not all([env.robinhood_user, env.robinhood_pass, env.robinhood_qr]):
logger.warning("Robinhood username, password or QR code not found.")
support.no_env_vars()
return
sys.stdout.write("\rGetting your investment details.")
rh = Robinhood()
rh.login(username=env.robinhood_user,
password=env.robinhood_pass,
qr_code=env.robinhood_qr)
raw_result = rh.positions()
result = raw_result["results"]
stock_value = watcher(rh, result)
speaker.speak(text=stock_value)
def main(self, stock, action, quantity):
username = ""
password = ""
rh = Robinhood()
rh.login(username=username, password=password)
instrument = rh.instruments(stock)[0]
if (action == "buy"):
rh.place_buy_order(instrument, quantity)
self.enteredTrade = True
if (action == "sell"):
rh.place_sell_order(instrument, quantity)
self.enteredTrade = False
def test_login_happypath(config=CONFIG):
"""try to log in to robinhood"""
global LOGIN_OK
if (not config.get("LOGIN", "username")) or (not config.get("LOGIN", "password")):
LOGIN_OK = False
pytest.xfail("no login credentials given")
try:
LOGIN_OK = Robinhood().login(
username=config.get("LOGIN", "username"),
password=config.get("LOGIN", "password"),
)
except Exception as err_msg:
LOGIN_OK = False
raise err_msg
assert LOGIN_OK
class TestURLWrapper:
"""make sure get_url returns expected behavior"""
base_url = "https://api.robinhood.com/"
rh_obj = Robinhood()
def test_url_endpoint(self):
"""fetch url directly"""
global TEST_URL_RESULT
req = requests.get(self.base_url)
req.raise_for_status()
TEST_URL_RESULT = req.json()
def test_get_url(self):
"""fetch url with get_url"""
data = self.rh_obj.get_url(self.base_url)
assert data == TEST_URL_RESULT
def fetch_REST_directly(endpoint_name, arg_string, config):
"""fetch REST endpoint (instead of ?arg1=val1&arg2=val2)
Args:
endpoint_name (str): endpoint name in RH class
arg_string (str): additional args to pass onto endpoint
config (:obj:`configparser.ConfigParser`, optional): config for args
Returns:
(:obj:`dict`) JSON-parsed data from Robinhood endpoint
"""
rh_object = Robinhood()
address = rh_object.endpoints[endpoint_name]
address = address + arg_string + "/"
headers = {"User-Agent": config.get("FETCH", "user_agent")}
req = requests.get(address, headers=headers)
req.raise_for_status()
return req.json()
def login(username=False, password=False, device_token=False, force=False):
global my_trader
if not username:
username = config.get('user')
password = config.get('password')
device_token = config.get('token')
if not password:
password = getpass.getpass()
try:
my_trader = Robinhood(username=username,
password=password,
device_token=device_token)
print(my_trader)
except Exception as ex:
raise ex
print("Password incorrect. Please try again")
login(username, force)
class TestFundamentalsHelpers:
"""wrapper to test fundamental architecture in order"""
test_ticker = CONFIG.get("FETCH", "test_ticker")
fake_ticker = CONFIG.get("FETCH", "fake_ticker")
rh_obj = Robinhood()
def test_fundamental_endpoint(self, config=CONFIG):
"""get raw data from Robinhood to test against"""
global TEST_FUNDAMENTAL
TEST_FUNDAMENTAL = helpers.fetch_REST_directly("fundamentals",
self.test_ticker,
config)
TEST_FUNDAMENTAL["volume"] = "OVERWRITE" # flaky value
@flaky
def test_validate_fundamental(self):
"""validate fetcher"""
data = self.rh_obj.get_fundamentals(self.test_ticker)
data["volume"] = "OVERWRITE" # flaky value
assert data == TEST_FUNDAMENTAL
def test_validate_fail_fundamental(self):
"""validate bad-path exception"""
with pytest.raises(NameError):
data = self.rh_obj.get_fundamentals(self.fake_ticker)
@flaky
def test_validate_fundamental_wrapper(self):
main_data = self.rh_obj.fundamentals(self.test_ticker)
wrapped_data = self.rh_obj.fundamentals(self.test_ticker)
main_data["volume"] = "OVERWRITE" # flaky value
wrapped_data["volume"] = "OVERWRITE" # flaky value
assert wrapped_data == main_data
assert wrapped_data == TEST_FUNDAMENTAL
def rh_pull_orders_history(user_id, passwd):
pyrh_rb = Robinhood()
pyrh_rb.login(username=user_id, password=passwd, challenge_type="sms")
past_orders = RhWrapper.rh_pull_all_history_orders(pyrh_rb)
# keep past orders in reverse chronological order
past_orders_sorted = sorted(past_orders, key=itemgetter('last_transaction_at'), reverse=True)
orders_saved_to_db = 0
for order in past_orders_sorted:
# check if order already in db
if order['state'] == 'filled':
obj = robinhood_stock_order_history.objects.filter(timestamp=dateutil.parser.parse(order['last_transaction_at']))
if not obj:
obj = robinhood_stock_order_history()
obj.order_type = order['side']
obj.price = order['average_price']
obj.shares = order['cumulative_quantity']
obj.symbol, name = RhWrapper.rh_pull_symbol_from_instrument_url(order['instrument'])
obj.state = order['state']
obj.timestamp = dateutil.parser.parse(order['last_transaction_at'])
obj.save()
orders_saved_to_db = orders_saved_to_db + 1
else:
continue
logging.error('orders_saved_to_db: ' + str(orders_saved_to_db))
def __init__(self, credentials: str) -> None:
self._ext_equity = 0.0
# Set up connection to Robinhood's API.
self._rh = Robinhood()
self._rh.login(**read_credentials(credentials))
It then compares the price of the stock at a given moment with the initial bought value
If it's lower than some threshold, it will automatically sell
"""
import sys, time
sys.path.append('./pyrh')
from pyrh import Robinhood
from dotenv import load_dotenv
load_dotenv()
import os
USERNAME = os.getenv("RH_USERNAME")
PASSWORD = os.getenv("RH_PASSWORD")
rh = Robinhood(username=USERNAME, password=PASSWORD)
rh.login()
# Set how much you're willing to loss
PRICE_DIFF_LIMIT = -100
# How many seconds to wait before polling
REFRESH_TIME = 1800
def fetch_json_by_url(rh, url):
return rh.session.get(url).json()
def get_current_positions(rh):
positions = rh.positions()
class TestPortfolioMethods:
"""test wrappers on `portfolio` endpoint
NOTE: reliant on an active account to pull data from
"""
rh_obj = Robinhood()
try:
rh_obj.login(
username=CONFIG.get(
"LOGIN", "username"
), # NOTE: py.test fails w/o password
password=CONFIG.get("LOGIN", "password"),
)
except Exception:
pass
def test_portfolios(self):
"""check `portfolio` method"""
global TEST_PORTFOLIO
if not LOGIN_OK:
print("Unable to test Portfolio without auth")
pytest.xfail("cannot test without valid user/passwd")
print(self.rh_obj.auth_token)
data = self.rh_obj.portfolios()
# TODO validate data
TEST_PORTFOLIO = data
def test_validate_adjusted_equity(self):
"""test `adjusted_equity_previous_close` method"""
value = self.rh_obj.adjusted_equity_previous_close()
assert isinstance(value, float)
assert format(value, ".4f") == TEST_PORTFOLIO["adjusted_equity_previous_close"]
def test_validate_equity(self):
"""test `equity` method"""
value = self.rh_obj.equity()
assert isinstance(value, float)
assert format(value, ".4f") == TEST_PORTFOLIO["equity"]
def test_equity_previous_close(self):
"""test `equity_previous_close` method"""
value = self.rh_obj.equity_previous_close()
assert isinstance(value, float)
assert format(value, ".4f") == TEST_PORTFOLIO["equity_previous_close"]
def test_excess_margin(self):
"""test `excess_margin` method"""
value = self.rh_obj.excess_margin()
assert isinstance(value, float)
assert format(value, ".4f") == TEST_PORTFOLIO["excess_margin"]
def test_ex_hours_equity(self):
"""test `extended_hours_equity method"""
value = self.rh_obj.extended_hours_equity()
assert isinstance(value, float) or (value is None)
if value:
assert format(value, ".4f") == TEST_PORTFOLIO["extended_hours_equity"]
def test_ex_hours_market_value(self):
"""test `extended_hours_market_value` method"""
value = self.rh_obj.extended_hours_market_value()
assert isinstance(value, float) or (value is None)
if value:
assert format(value, ".4f") == TEST_PORTFOLIO["extended_hours_market_value"]
def test_last_core_equity(self):
"""test `last_core_equity` method"""
value = self.rh_obj.last_core_equity()
assert isinstance(value, float)
assert format(value, ".4f") == TEST_PORTFOLIO["last_core_equity"]
def test_last_core_market_value(self):
"""test `last_core_market_value` method"""
value = self.rh_obj.last_core_market_value()
assert isinstance(value, float)
assert format(value, ".4f") == TEST_PORTFOLIO["last_core_market_value"]
def test_market_value(self):
"""test `market_value` method"""
value = self.rh_obj.market_value()
assert isinstance(value, float)
assert format(value, ".4f") == TEST_PORTFOLIO["market_value"]
def test_investment_profile(self):
"""test `investment_profile` endpoint"""
data = self.rh_obj.investment_profile()
# TODO: validate keys
def test_get_account(self):
"""test `get_account` endpoing"""
data = self.rh_obj.get_account()
required=True)
parser.add_argument('--percent',
type=float,
help='Trailing percent',
required=False,
default=3)
#parser.add_argument(
# '--tight', type=float, help='Trailing percent when below average price', required=False, default=2)
# Array for all arguments passed to script
args = parser.parse_args()
# Assign args to variables
# server = args.server
#pprint(args)
#
rh = Robinhood()
logged_in = rh.login(username=args.username, password=args.password)
account = rh.get_account()
def load_positions():
_pos = {}
_ord = {}
next = rh.endpoints['positions'] + '?nonzero=true'
while True:
positions = rh.session.get(next).json()
for position in positions.get('results'):
instrument = rh.session.get(position['instrument']).json()
_pos[instrument['symbol']] = position
_ord[instrument['symbol']] = list(
filter(
def __init__(self, rh_account: RHAccount):
self.rh = Robinhood()
if not self.rh.login(username=rh_account.username,
password=rh_account.password,
qr_code=rh_account.qr_code):
raise Exception("Error in logging into robinhood account")