def set_trade(trading_robot: PyRobot, trading_symbol: str,
current_price: int,
available_funds,
max_percent: float = None) -> dict:
"""
Create order legs and set the qty based on how much of my portfolio
I want to trade at one time
:param trading_robot: the robot
:param trading_symbol: the ticker symbol for the trades
:param max_percent: max percentage of my portfolio I want for a single trade
:param current_price: current candle open price
:param available_funds: current amount I can trade with
:return: trade dictionary
"""
qty = round((available_funds * max_percent) / current_price) if max_percent else 1
new_enter_trade = trading_robot.create_trade(
trade_id='long_enter',
enter_or_exit='enter',
long_or_short='long',
order_type='mkt'
)
# Add an Order Leg
new_enter_trade.instrument(
symbol=trading_symbol,
quantity=qty,
asset_type='EQUITY'
)
# Create a new Trade Object for Exiting position
new_exit_trade = trading_robot.create_trade(
trade_id='long_exit',
enter_or_exit='exit',
long_or_short='long',
order_type='mkt'
)
# Add an Order Leg
new_exit_trade.instrument(
symbol=trading_symbol,
quantity=qty,
asset_type='EQUITY'
)
return {
trading_symbol: {
'buy': {
'trade_func': trading_robot.trades['long_enter'],
'trade_id': trading_robot.trades['long_enter'].trade_id
},
'sell': {
'trade_func': trading_robot.trades['long_exit'],
'trade_id': trading_robot.trades['long_exit'].trade_id
},
}
}
def sell_out_trade_to_execute(trading_symbol: str, trading_robot: PyRobot):
# Set the cancel time to 1 day out
gtc_date = datetime.now() - timedelta(days=1)
# Create a new Trade Object for Exiting position
new_exit_trade = trading_robot.create_trade(
trade_id='sell_out_exit',
enter_or_exit='exit',
long_or_short='long',
order_type='mkt'
)
# Make the trade good till cancel
new_exit_trade.good_till_cancel(gtc_date)
# todo set the quantity to be the currently held quantity
# Add an Order Leg
new_exit_trade.instrument(
symbol=trading_symbol,
quantity=1,
asset_type='EQUITY'
)
return {
trading_symbol: {
'buy': {},
'sell': {
'trade_func': trading_robot.trades['sell_out_exit'],
'trade_id': trading_robot.trades['sell_out_exit'].trade_id
},
}
}
pprint.pprint(current_quotes)
# Let's see if our Microsoft Position is profitable.
is_msft_porfitable = trading_robot.portfolio.is_profitable(
symbol="MSFT", current_price=current_quotes['MSFT']['lastPrice'])
print("Is Microsoft Profitable: {answer}".format(answer=is_msft_porfitable))
# Let's get the projected Market Value.
portfolio_summary = trading_robot.portfolio.projected_market_value(
current_prices=current_quotes)
pprint.pprint(portfolio_summary)
# Create a new Trade Object.
new_trade = trading_robot.create_trade(trade_id='long_msft',
enter_or_exit='enter',
long_or_short='short',
order_type='lmt',
price=150.00)
# Make it Good Till Cancel.
new_trade.good_till_cancel(cancel_time=datetime.now())
# Change the session
new_trade.modify_session(session='am')
# Add an Order Leg.
new_trade.instrument(symbol='MSFT', quantity=2, asset_type='EQUITY')
# Add a Stop Loss Order with the Main Order.
new_trade.add_stop_loss(stop_size=.10, percentage=False)
# pprint.pprint(trading_robot.grab_current_quotes())
# pprint.pprint(trading_robot.grab_single_current_quote())
# Grab historical prices of all symbols in portfolio
historical_prices = trading_robot.grab_historical_prices()
# Convert data into a StockFrame
stock_frame = trading_robot.create_stock_frame(data=historical_prices['aggregated'])
# Print the head of the StockFrame
# pprint.pprint(stock_frame.frame)
# create a trade
new_trade = trading_robot.create_trade(
trade_id = 'long_ethusd',
enter_or_exit = 'enter',
long_or_short= 'long',
order_type= 'mkt',
price = 4.0
)
new_trade.good_till_cancel(datetime.now() + timedelta(minutes = 10))
new_trade.instrument(
symbol = 'ethusd',
quantity = 2,
asset_type = 'altcoin'
)
new_trade.add_stop_loss(
stop_size = 0.10,
percentage = False
class PyRobotSession(TestCase):
"""Will perform a unit test for the Azure session."""
def setUp(self) -> None:
"""Set up the Robot."""
# Grab configuration values.
config = ConfigParser()
config.read('configs/config.ini')
CLIENT_ID = config.get('main', 'CLIENT_ID')
REDIRECT_URI = config.get('main', 'REDIRECT_URI')
CREDENTIALS_PATH = config.get('main', 'JSON_PATH')
self.ACCOUNT_NUMBER = config.get('main', 'ACCOUNT_NUMBER')
self.robot = PyRobot(client_id=CLIENT_ID,
redirect_uri=REDIRECT_URI,
credentials_path=CREDENTIALS_PATH)
def test_create_new_market_order(self):
"""Create a new market order."""
# Create a new Trade Object.
new_trade = self.robot.create_trade(enter_or_exit='enter',
long_or_short='short',
order_type='mkt')
self.assertIsInstance(new_trade, Trade)
self.assertEqual(new_trade.order_type, 'mkt')
def test_create_new_limit_order(self):
"""Create a new limit order."""
# Create a new Trade Object.
new_trade = self.robot.create_trade(enter_or_exit='enter',
long_or_short='short',
order_type='lmt')
self.assertIsInstance(new_trade, Trade)
self.assertEqual(new_trade.order_type, 'lmt')
def test_create_new_stop_order(self):
"""Create a new stop order."""
# Create a new Trade Object.
new_trade = self.robot.create_trade(enter_or_exit='enter',
long_or_short='short',
order_type='stop')
self.assertIsInstance(new_trade, Trade)
self.assertEqual(new_trade.order_type, 'stop')
def test_add_instrument(self):
"""Tests adding an instrument to an order after creating it."""
# Create a new Trade Object.
new_trade = self.robot.create_trade(enter_or_exit='enter',
long_or_short='long',
order_type='lmt',
price=12.00)
# Define the Order Leg it should be.
order_leg = {
"instruction": 'BUY',
"quantity": 2,
"instrument": {
"symbol": 'MSFT',
"assetType": 'EQUITY'
}
}
# Add an instrument to the Trade.
new_trade.instrument(symbol='MSFT', quantity=2, asset_type='EQUITY')
self.assertDictEqual(new_trade.order['orderLegCollection'][0],
order_leg)
def test_add_stop_loss_percentage(self):
"""Tests adding a stop Loss Order to an exisiting Limit Order."""
# Create a new Trade Object.
new_trade = self.robot.create_trade(enter_or_exit='enter',
long_or_short='long',
order_type='lmt',
price=12.00)
new_trade.instrument(symbol='MSFT', quantity=2, asset_type='EQUITY')
new_trade.add_stop_loss(stop_size=.10, percentage=True)
stop_loss_order = {
"orderType":
"STOP",
"session":
"NORMAL",
"duration":
"DAY",
"stopPrice":
10.8,
"orderStrategyType":
"SINGLE",
"orderLegCollection": [{
"instruction": 'SELL',
"quantity": 2,
"instrument": {
"symbol": 'MSFT',
"assetType": 'EQUITY'
}
}]
}
self.assertEqual(new_trade.order_type, 'lmt')
self.assertIn('childOrderStrategies', new_trade.order)
self.assertDictEqual(new_trade.stop_loss_order, stop_loss_order)
def test_add_stop_loss_dollar(self):
"""Tests adding a stop Loss Order to an exisiting Limit Order."""
# Create a new Trade Object.
new_trade = self.robot.create_trade(enter_or_exit='enter',
long_or_short='long',
order_type='lmt',
price=12.00)
new_trade.instrument(symbol='MSFT', quantity=2, asset_type='EQUITY')
new_trade.add_stop_loss(stop_size=.10, percentage=False)
stop_loss_order = {
"orderType":
"STOP",
"session":
"NORMAL",
"duration":
"DAY",
"stopPrice":
11.90,
"orderStrategyType":
"SINGLE",
"orderLegCollection": [{
"instruction": 'SELL',
"quantity": 2,
"instrument": {
"symbol": 'MSFT',
"assetType": 'EQUITY'
}
}]
}
self.assertEqual(new_trade.order_type, 'lmt')
self.assertIn('childOrderStrategies', new_trade.order)
self.assertDictEqual(new_trade.stop_loss_order, stop_loss_order)
# def test_price_calculation(self):
# """Tests calculating the new price for Stop Orders."""
# new_price = Trade()._calculate_new_price(price=12.00,adjustment=.1, percentage=True)
def tearDown(self) -> None:
"""Teardown the Robot."""
self.robot = None
class PyRobotTest(TestCase):
"""Will perform a unit test for the PyRobot Object."""
def setUp(self) -> None:
"""Set up the Robot."""
# Grab configuration values.
config = ConfigParser()
config.read('configs/config.ini')
CLIENT_ID = config.get('main', 'CLIENT_ID')
REDIRECT_URI = config.get('main', 'REDIRECT_URI')
CREDENTIALS_PATH = config.get('main', 'JSON_PATH')
self.ACCOUNT_NUMBER = config.get('main', 'ACCOUNT_NUMBER')
self.robot = PyRobot(client_id=CLIENT_ID,
redirect_uri=REDIRECT_URI,
credentials_path=CREDENTIALS_PATH)
def test_creates_instance_of_session(self):
"""Create an instance and make sure it's a robot."""
self.assertIsInstance(self.robot, PyRobot)
def test_create_portofolio(self):
"""Call `create_portfolio` and make sure it's a Portfolio."""
new_portfolio = self.robot.create_portfolio()
self.assertIsInstance(new_portfolio, Portfolio)
def test_regular_market_open(self):
"""Tests whether Market is Open"""
right_now = datetime.now().replace(tzinfo=timezone.utc).timestamp()
regular_market_start_time = datetime.now().replace(
hour=14, minute=30, second=00, tzinfo=timezone.utc).timestamp()
regular_market_end_time = datetime.now().replace(
hour=21, minute=00, second=00, tzinfo=timezone.utc).timestamp()
if regular_market_end_time >= right_now >= regular_market_start_time:
open = True
else:
open = False
self.assertEqual(open, self.robot.regular_market_open)
"""
Pre
09:00
14:30
Regular
14:30
21:00
Post
21:00
01:00
"""
def test_pre_market_open(self):
"""Tests whether US Pre-Market is Open"""
right_now = datetime.now().replace(tzinfo=timezone.utc).timestamp()
pre_market_start_time = datetime.now().replace(
hour=9, minute=00, second=00, tzinfo=timezone.utc).timestamp()
pre_market_end_time = datetime.now().replace(
hour=14, minute=30, second=00, tzinfo=timezone.utc).timestamp()
if pre_market_end_time >= right_now >= pre_market_start_time:
open = True
else:
open = False
self.assertEqual(open, self.robot.pre_market_open)
def test_post_market_open(self):
"""Tests whether US Post-Market is Open"""
right_now = datetime.now().replace(tzinfo=timezone.utc).timestamp()
post_market_start_time = datetime.now().replace(
hour=21, minute=00, second=00, tzinfo=timezone.utc).timestamp()
post_market_end_time = datetime.now().replace(
hour=1, minute=00, second=00, tzinfo=timezone.utc).timestamp()
if post_market_end_time >= right_now >= post_market_start_time:
open = True
else:
open = False
self.assertEqual(open, self.robot.post_market_open)
def test_historical_prices(self):
"""Tests Grabbing historical prices."""
# Grab historical prices, first define the start date and end date.
start_date = datetime.today()
end_date = start_date - timedelta(days=30)
# Grab the historical prices.
self.robot.grab_historical_prices(start=end_date,
end=start_date,
bar_size=1,
bar_type='minute',
symbols=['AAPL'])
self.assertIn('aggregated', self.robot.historical_prices)
def test_build_portfolio(self):
"""Test building a Portfolio object."""
# Create a Portfolio
porfolio_obj = self.robot.create_portfolio()
self.assertIsInstance(porfolio_obj, Portfolio)
def test_build_trade(self):
"""Test building a Trade object."""
# Create a Trade
trade_obj = self.robot.create_trade(trade_id='long_msft',
enter_or_exit='enter',
long_or_short='short',
order_type='lmt',
price=150.00)
self.assertIsInstance(trade_obj, Trade)
def tearDown(self) -> None:
"""Teardown the Robot."""
self.robot = None
