class TestPositionService(unittest.TestCase):
    """
    Test parsing of positions
    """

    @classmethod
    def setUpClass(self):
        self.pyTradeMonster = PyTradeMonster('../cred.dat')
        self.positionService = PositionServices(self.pyTradeMonster)
        self.accountsService = AccountServices(self.pyTradeMonster)
        self.accounts = self.accountsService.getParsedAccountObjects()


    def testGetSinglePosition(self):
        positions = self.positionService.getParsedPositionsDetail(self.accounts[ACCOUNT_NUMBER].accountId)
        if len(positions) > 0:
            print 'Found positions'
        else :
            self.fail('No positions found or unable to parse, please have a live position in the account first!')
Ejemplo n.º 2
0
class TestPositionService(unittest.TestCase):
    """
    Test parsing of positions
    """
    @classmethod
    def setUpClass(self):
        self.pyTradeMonster = PyTradeMonster('../cred.dat')
        self.positionService = PositionServices(self.pyTradeMonster)
        self.accountsService = AccountServices(self.pyTradeMonster)
        self.accounts = self.accountsService.getParsedAccountObjects()

    def testGetSinglePosition(self):
        positions = self.positionService.getParsedPositionsDetail(
            self.accounts[ACCOUNT_NUMBER].accountId)
        if len(positions) > 0:
            print 'Found positions'
        else:
            self.fail(
                'No positions found or unable to parse, please have a live position in the account first!'
            )
Ejemplo n.º 3
0
def plotAccountPnl(pyTradeMonster,
                   transactionType,
                   accountNumber,
                   start,
                   end,
                   filterTicker=None):
    '''
    Retrieve all live accounts' activity and plot cumulative pnl for a given transaction type and account
    Filter ticker filters out PNL by an individual ticker, i.e. 'GOOG'
    '''
    accountService = AccountServices(pyTradeMonster)
    accounts = accountService.getParsedAccountObjects()
    graphFrame = pd.DataFrame()
    for account in accounts.itervalues():
        if account.accountNumber == accountNumber and account.accountType != TradeMonsterConstants.AccountRequests.ACCOUNT_TYPES.OPTION:
            log.info('Processing account: {0}'.format(account))
            accountHistory = accountService.getParsedAccountHistory(
                account, MAX_TRANSACTIONS, transactionType, start, end)
            historyList = [{
                key: value
                for key, value in x.__dict__.items()
                if not key.startswith('__') and not callable(key)
            } for x in accountHistory]
            historyFrame = pd.DataFrame(historyList)
            historyFrame = historyFrame.reindex(
                index=historyFrame.index[::-1]
            )  #make dataframe sorted in ascending chronological order
            historyFrame.transactionDate = historyFrame.transactionDate.str[:
                                                                            -6]
            if filterTicker:
                historyFrame = historyFrame[
                    historyFrame['symbol'].str.contains(filterTicker)]
            historyFrame['date'] = historyFrame.transactionDate.apply(
                lambda d: datetime.strptime(
                    d, TradeMonsterConstants.TRANSACTION_TIME))
            historyFrame['cumPnl'] = historyFrame.amount.astype(float).cumsum()
            graphFrame = graphFrame.append(historyFrame)
    plot = ggplot(aes(x='date', y='cumPnl'), data=graphFrame) + geom_line()
    print plot
Ejemplo n.º 4
0
def plotAccountPnl(pyTradeMonster, transactionType, accountNumber, start, end, filterTicker = None):
    '''
    Retrieve all live accounts' activity and plot cumulative pnl for a given transaction type and account
    Filter ticker filters out PNL by an individual ticker, i.e. 'GOOG'
    '''
    accountService = AccountServices(pyTradeMonster)
    accounts = accountService.getParsedAccountObjects()
    graphFrame = pd.DataFrame()
    for account in accounts.itervalues():
        if account.accountNumber == accountNumber and account.accountType != TradeMonsterConstants.AccountRequests.ACCOUNT_TYPES.OPTION:
            log.info('Processing account: {0}'.format(account))
            accountHistory = accountService.getParsedAccountHistory(account, MAX_TRANSACTIONS, transactionType, start, end )
            historyList = [{key:value for key, value in x.__dict__.items() if not key.startswith('__') and not callable(key)} for x in accountHistory]
            historyFrame = pd.DataFrame(historyList)
            historyFrame = historyFrame.reindex(index=historyFrame.index[::-1]) #make dataframe sorted in ascending chronological order
            historyFrame.transactionDate = historyFrame.transactionDate.str[:-6]
            if filterTicker:
                historyFrame = historyFrame[historyFrame['symbol'].str.contains(filterTicker)]
            historyFrame['date'] = historyFrame.transactionDate.apply(lambda d : datetime.strptime(d,TradeMonsterConstants.TRANSACTION_TIME))
            historyFrame['cumPnl'] = historyFrame.amount.astype(float).cumsum()
            graphFrame = graphFrame.append(historyFrame)
    plot = ggplot(aes(x='date',y='cumPnl'), data=graphFrame) + geom_line()
    print plot
Ejemplo n.º 5
0
class TestOrderService(unittest.TestCase):
    """
    Test most functionality surrounding submission, execution, and retrieval of orders
    """
    @classmethod
    def setUpClass(self):
        self.pyTradeMonster = PyTradeMonster('../cred.dat')
        self.orderService = OrderServices(self.pyTradeMonster)
        self.accountsService = AccountServices(self.pyTradeMonster)
        self.accounts = self.accountsService.getParsedAccountObjects()

    @classmethod
    def tearDownClass(self):
        '''
        Cancel all outstanding orders
        :return:
        '''
        print 'Going to cancel all outstanding orders from unit testing...'
        self.orderService.sendCancelAllOrders(
            self.accounts[ACCOUNT_NUMBER].accountNumber)

    def createSimpleLimitOrder(self):
        order = LimitOrder()
        orderLeg = OrderLeg()
        orderLeg.instrumentType = TradeMonsterConstants.INSTRUMENTS.EQUITY
        orderLeg.symbol = 'SPY'
        orderLeg.orderSide = OrderLeg.side.BUY
        order.price = 0.01
        order.quantity = 1
        order.orderLegs = [orderLeg]
        order.instrumentType = TradeMonsterConstants.INSTRUMENTS.EQUITY
        order.timeInForce = LimitOrder.timeInForceEnum.DAY
        order.marketSession = LimitOrder.marketSessionEnum.REG
        return order

    def testSingleLimitOrder(self):
        self.orderService.sendCancelAllOrders(
            self.accounts[ACCOUNT_NUMBER].accountNumber
        )  #cancel everything first just in case

        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)

        status = orderResponse.status
        print 'Status of order is {0}'.format(status)
        self.assertTrue(status in OrderStatus.status.__dict__.keys())

    def testGetOrderConfirmation(self):
        self.orderService.sendCancelAllOrders(
            self.accounts[ACCOUNT_NUMBER].accountNumber
        )  #cancel everything first just in case

        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)

        print 'Trying to confirm order...'
        result = self.orderService.getOrderConfirmation(
            self.accounts[ACCOUNT_NUMBER], order, orderResponse)
        confirm = result[TradeMonsterConstants.ResponseRoots.
                         RETRIEVE_ORDER_CONFIRMATION_ROOT]
        self.assertTrue(confirm['orderDescription'] != None)

    def testSpreadOrder(self):
        '''
        Test a simple buy spread (debit)
        :return:
        
        '''
        self.orderService.sendCancelAllOrders(
            self.accounts[ACCOUNT_NUMBER].accountNumber
        )  #cancel everything first just in case

        order = LimitOrder()
        shortLeg = OrderLeg()
        longLeg = OrderLeg()

        shortLeg.instrumentType = TradeMonsterConstants.INSTRUMENTS.OPTION
        shortLeg.symbol = 'SPYX1517C300000'
        shortLeg.orderSide = OrderLeg.side.SELL
        shortLeg.quantityRatio = 1

        longLeg.instrumentType = TradeMonsterConstants.INSTRUMENTS.OPTION
        longLeg.symbol = 'SPYX1517C310000'
        longLeg.orderSide = OrderLeg.side.BUY
        longLeg.quantityRatio = 1

        order.price = 0.01
        order.quantity = 1
        order.instrumentType = TradeMonsterConstants.INSTRUMENTS.OPTION
        order.timeInForce = LimitOrder.timeInForceEnum.DAY
        order.marketSession = LimitOrder.marketSessionEnum.REG
        order.orderLegs = []
        order.orderLegs.append(shortLeg)
        order.orderLegs.append(longLeg)
        order.spreadName = TradeMonsterConstants.OrderRequests.ORDER_SPREAD_TYPES.PUT_VERTICAL

        #send a live order with a silly price
        result = self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)

        status = result.status
        print 'Status of order is {0}'.format(status)

        self.assertTrue(status in OrderStatus.status.__dict__.keys())

    def testCancelSingleOrder(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to cancel order', orderResponse.orderId, '...'
        time.sleep(1)
        result = self.orderService.sendCancelOrder(orderResponse.orderId)
        self.assertTrue(TradeMonsterConstants.ResponseRoots.
                        RETRIEVE_ORDER_CANCELLED_ROOT in result)

    def testCancelAllOrders(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to cancel all orders', orderResponse.orderId, '...'
        time.sleep(1)
        result = self.orderService.sendCancelAllOrders(
            self.accounts[ACCOUNT_NUMBER].accountNumber)
        self.assertTrue(TradeMonsterConstants.ResponseRoots.
                        RETRIEVE_ALL_CANCELLED_ROOT in result)

    def testCancelDayOrder(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to cancel day order', orderResponse.orderId, '...'
        time.sleep(1)
        result = self.orderService.sendCancelDayOrders(
            self.accounts[ACCOUNT_NUMBER].accountNumber)
        self.assertTrue(TradeMonsterConstants.ResponseRoots.
                        RETRIEVE_DAY_CANCELLED_ROOT in result)

    def testCountAllOrders(self):
        order = self.createSimpleLimitOrder()
        self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)
        order = self.createSimpleLimitOrder()
        self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to count all orders...'
        time.sleep(1)
        result = self.orderService.sendCountAllOpenOrders(
            self.accounts[ACCOUNT_NUMBER].accountNumber)
        print 'Counted', result, 'orders total'
        self.assertEquals(result, 2)

    def testCountDayOrders(self):
        self.orderService.sendCancelAllOrders(
            self.accounts[ACCOUNT_NUMBER].accountNumber
        )  #cancel everything first just in case
        order = self.createSimpleLimitOrder()
        self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to count day orders...'
        time.sleep(1)
        result = self.orderService.sendCountDayOrders(
            self.accounts[ACCOUNT_NUMBER].accountNumber)
        print 'Counted', result, 'day orders'
        self.assertEquals(result, 1)

    def testGetOrderHistory(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)
        result = self.orderService.sendGetOrderHistory(orderResponse.orderId)
        self.fail(
            'TradeMonster call getOrderHistory not yet working - followup with them...'
        )

    def testGetOrderDetails(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(
            self.accounts[ACCOUNT_NUMBER], order)
        result = self.orderService.sendGetOrderDetail(orderResponse.orderId)
        self.assertTrue(TradeMonsterConstants.ResponseRoots.
                        RETRIEVE_ORDER_DETAILS_ROOT in result)
class TestOrderService(unittest.TestCase):
    """
    Test most functionality surrounding submission, execution, and retrieval of orders
    """

    @classmethod
    def setUpClass(self):
        self.pyTradeMonster = PyTradeMonster('../cred.dat')
        self.orderService = OrderServices(self.pyTradeMonster)
        self.accountsService = AccountServices(self.pyTradeMonster)
        self.accounts = self.accountsService.getParsedAccountObjects()

    @classmethod
    def tearDownClass(self):
        '''
        Cancel all outstanding orders
        :return:
        '''
        print 'Going to cancel all outstanding orders from unit testing...'
        self.orderService.sendCancelAllOrders(self.accounts[ACCOUNT_NUMBER].accountNumber)



    def createSimpleLimitOrder(self):
        order = LimitOrder()
        orderLeg = OrderLeg()
        orderLeg.instrumentType = TradeMonsterConstants.INSTRUMENTS.EQUITY
        orderLeg.symbol = 'SPY'
        orderLeg.orderSide = OrderLeg.side.BUY
        order.price = 0.01
        order.quantity = 1
        order.orderLegs = [orderLeg]
        order.instrumentType = TradeMonsterConstants.INSTRUMENTS.EQUITY
        order.timeInForce = LimitOrder.timeInForceEnum.DAY
        order.marketSession = LimitOrder.marketSessionEnum.REG
        return order

    def testSingleLimitOrder(self):
        self.orderService.sendCancelAllOrders(self.accounts[ACCOUNT_NUMBER].accountNumber) #cancel everything first just in case
        
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)

        status = orderResponse.status
        print 'Status of order is {0}'.format(status)
        self.assertTrue(status in OrderStatus.status.__dict__.keys() )

    def testGetOrderConfirmation(self):
        self.orderService.sendCancelAllOrders(self.accounts[ACCOUNT_NUMBER].accountNumber) #cancel everything first just in case
        
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)

        print 'Trying to confirm order...'
        result = self.orderService.getOrderConfirmation(self.accounts[ACCOUNT_NUMBER], order, orderResponse)
        confirm = result[TradeMonsterConstants.ResponseRoots.RETRIEVE_ORDER_CONFIRMATION_ROOT]
        self.assertTrue(confirm['orderDescription'] != None)

    def testSpreadOrder(self):
        '''
        Test a simple buy spread (debit)
        :return:
        
        '''
        self.orderService.sendCancelAllOrders(self.accounts[ACCOUNT_NUMBER].accountNumber) #cancel everything first just in case
        
        order = LimitOrder()
        shortLeg = OrderLeg()
        longLeg = OrderLeg()


        shortLeg.instrumentType = TradeMonsterConstants.INSTRUMENTS.OPTION
        shortLeg.symbol = 'SPYX1517C300000'
        shortLeg.orderSide = OrderLeg.side.SELL
        shortLeg.quantityRatio = 1

        longLeg.instrumentType = TradeMonsterConstants.INSTRUMENTS.OPTION
        longLeg.symbol = 'SPYX1517C310000'
        longLeg.orderSide = OrderLeg.side.BUY
        longLeg.quantityRatio = 1

        order.price = 0.01
        order.quantity = 1
        order.instrumentType = TradeMonsterConstants.INSTRUMENTS.OPTION
        order.timeInForce = LimitOrder.timeInForceEnum.DAY
        order.marketSession = LimitOrder.marketSessionEnum.REG
        order.orderLegs = []
        order.orderLegs.append(shortLeg)
        order.orderLegs.append(longLeg)
        order.spreadName = TradeMonsterConstants.OrderRequests.ORDER_SPREAD_TYPES.PUT_VERTICAL

        #send a live order with a silly price
        result = self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)

        status = result.status
        print 'Status of order is {0}'.format(status)

        self.assertTrue(status in OrderStatus.status.__dict__.keys())



    def testCancelSingleOrder(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to cancel order',orderResponse.orderId,'...'
        time.sleep(1)
        result = self.orderService.sendCancelOrder(orderResponse.orderId)
        self.assertTrue(TradeMonsterConstants.ResponseRoots.RETRIEVE_ORDER_CANCELLED_ROOT in result)


    def testCancelAllOrders(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to cancel all orders',orderResponse.orderId,'...'
        time.sleep(1)
        result = self.orderService.sendCancelAllOrders(self.accounts[ACCOUNT_NUMBER].accountNumber)
        self.assertTrue(TradeMonsterConstants.ResponseRoots.RETRIEVE_ALL_CANCELLED_ROOT in result)


    def testCancelDayOrder(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to cancel day order',orderResponse.orderId,'...'
        time.sleep(1)
        result = self.orderService.sendCancelDayOrders(self.accounts[ACCOUNT_NUMBER].accountNumber)
        self.assertTrue(TradeMonsterConstants.ResponseRoots.RETRIEVE_DAY_CANCELLED_ROOT in result)


    def testCountAllOrders(self):
        order = self.createSimpleLimitOrder()
        self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)
        order = self.createSimpleLimitOrder()
        self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to count all orders...'
        time.sleep(1)
        result = self.orderService.sendCountAllOpenOrders(self.accounts[ACCOUNT_NUMBER].accountNumber)
        print 'Counted', result, 'orders total'
        self.assertEquals(result,2)

    def testCountDayOrders(self):
        self.orderService.sendCancelAllOrders(self.accounts[ACCOUNT_NUMBER].accountNumber) #cancel everything first just in case
        order = self.createSimpleLimitOrder()
        self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)
        print 'Going to count day orders...'
        time.sleep(1)
        result = self.orderService.sendCountDayOrders(self.accounts[ACCOUNT_NUMBER].accountNumber)
        print 'Counted', result, 'day orders'
        self.assertEquals(result,1)

    def testGetOrderHistory(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)
        result = self.orderService.sendGetOrderHistory(orderResponse.orderId)
        self.fail('TradeMonster call getOrderHistory not yet working - followup with them...')

    def testGetOrderDetails(self):
        order = self.createSimpleLimitOrder()
        orderResponse = self.orderService.sendOrderAndGetParsedResponse(self.accounts[ACCOUNT_NUMBER], order)
        result = self.orderService.sendGetOrderDetail(orderResponse.orderId)
        self.assertTrue(TradeMonsterConstants.ResponseRoots.RETRIEVE_ORDER_DETAILS_ROOT in result)