Python Order.m_lmtPrice方法代码示例

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
            def close(orderty = "MKT", price = None, timeout = None):
                position = self["position"]
                order = Order()
                if position > 0:
                    order.m_action = "SELL"
                else:
                    order.m_action = "BUY"
                order.m_tif = "DAY"
                order.m_orderType = orderty
                order.m_totalQuantity = abs(position)
                order.m_openClose = "C"
                if price <> None: order.m_lmtPrice = price

                if price == None and orderty <> "MKT": order.m_lmtPrice = self.best_price(position)
                
                if timeout == None:
                    oid = self.con.placeOrder(self.contract, order, None)
                    self.oids.append(oid)
                    return oid
                else:
                    oid = self.con.placeOrder(self.contract, order, timedelta(seconds=timeout))
                    if oid == None:
                        return None
                    else:
                        self.oids.append(oid)
                        return oid

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
            def order(position = "BUY", orderty = "MKT", quantity = 100, price = None, timeout = None, openClose = "O"):
                order = Order()
                order.m_action = position
                order.m_tif = "DAY"
                order.m_orderType = orderty
                order.m_totalQuantity = quantity
                order.m_openClose = openClose
                if price <> None: order.m_lmtPrice = price

                if position == "BUY":
                    pos = quantity
                else:
                    pos = -quantity

                if price == None and orderty <> "MKT": order.m_lmtPrice = self.best_price(pos)
                
                if timeout == None:
                    oid = self.con.placeOrder(self.contract, order, None)
                    self.oids.append(oid)
                    
                    return oid
                else:
                    oid = self.con.placeOrder(self.contract, order, timedelta(seconds=timeout))
                    if oid == None:
                        return None
                    else:
                        self.oids.append(oid)
                        return oid

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
    def order(self, sid, amount, limit_price, stop_price, order_id=None):
        id = super(LiveBlotter, self).order(sid, amount, limit_price, stop_price, order_id=None)
        order_obj = self.orders[id]

        ib_order = IBOrder()
        ib_order.m_transmit = True
        ib_order.m_orderRef = order_obj.id
        ib_order.m_totalQuantity = order_obj.amount
        ib_order.m_action = ["BUY" if ib_order.m_totalQuantity > 0 else "SELL"][0]
        ib_order.m_tif = "DAY"
        # Todo: make the FA params configurable
        ib_order.m_faGroup = "ALL"
        ib_order.m_faMethod = "AvailableEquity"

        # infer order type
        if order_obj.stop and not order_obj.limit:
            ib_order.m_orderType = "STP"
            ib_order.m_auxPrice = float(order_obj.stop)

        elif order_obj.limit and not order_obj.stop:
            ib_order.m_orderType = "LMT"
            ib_order.m_lmtPrice = float(order_obj.limit)

        elif order_obj.stop and order_obj.limit:
            ib_order.m_orderType = "STPLMT"
            ib_order.m_auxPrice = float(order_obj.stop)
            ib_order.m_lmtPrice = float(order_obj.limit)

        else:
            ib_order.m_orderType = "MKT"

        contract = Contract()
        contract.m_symbol = order_obj.sid
        contract.m_currency = "USD"

        if hasattr(order_obj, "contract"):
            # This is a futures contract
            contract.m_secType = "FUT"
            contract.m_exchange = "GLOBEX"
            contract.m_expiry = order_obj.contract

        else:
            # This is a stock
            contract.m_secType = "STK"
            contract.m_exchange = "SMART"

        ib_id = self.place_order(contract, ib_order)
        self.id_map[order_obj.id] = ib_id

        return order_obj.id

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
def createOrder(orderId,shares,limit = None, transmit=0):
    ''' 
    create order object 
 
    Parameters
    -----------
    orderId : The order Id. You must specify a unique value. 
              When the order status returns, it will be identified by this tag. 
              This tag is also used when canceling the order.
 
    shares: number of shares to buy or sell. Negative for sell order.  
    limit : price limit, None for MKT order
    transmit: transmit immideatelly from tws
    '''
 
    action = {-1:'SELL',1:'BUY'}    
 
    o = Order()
 
    o.m_orderId = orderId
    o.m_action = action[sign(shares)]
    o.m_totalQuantity = abs(shares)
    o.m_transmit = transmit
 
    if limit is not None:
        o.m_orderType = 'LMT'
        o.m_lmtPrice = limit
    else:
        o.m_orderType = 'MKT'
 
    return o    

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
def create_order(order_type, quantity, action, limitprice, transmitf, auxprice, stopprice, rptype):
    order = Order()
    order.m_action = action
    order.m_totalQuantity = quantity
    order.m_transmit = transmitf
    order.m_orderType = order_type
    if order_type == 'LMT':
        order.m_lmtPrice = limitprice
        pass
    elif order_type  == 'STP':
        order.m_stpPrice = stopprice
        pass
    else:
        print'failing on price...need one'
    return order
#####################
##if ordernumx == 'filled':
##    launch profittake and stopbracket with ocaGroup
##reqIds()
##orderStatus()
##ParentID
##ocaType
##ocaGroup
###############################
##datahandler for snapshots
##reqmktdata live data
##req live recent bars
##PlaceOrder(entryorder)
##if entryorder filled:
##    PlaceOrder(profitorder)
##    get orderid
##    PlaceOrder(profitorder by number, transmit)
##    PlaceOrder(stopbracket) # with transmit true 
    '''

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
    def placeOrder(self, symbol, shares, limit=None, exchange='SMART', transmit=0):
        """ place an order on already subscribed contract """


        if symbol not in self.contracts.keys():
            self.log.error("Can't place order, not subscribed to %s" % symbol)
            return


        action = {-1: 'SELL', 1: 'BUY'}


        o = Order()
        o.m_orderId = self.getOrderId()
        o.m_action = action[cmp(shares, 0)]
        o.m_totalQuantity = abs(shares)
        o.m_transmit = transmit


        if limit is not None:
            o.m_orderType = 'LMT'
            o.m_lmtPrice = limit


        self.log.debug('Placing %s order for %i %s (id=%i)' % (o.m_action, o.m_totalQuantity, symbol, o.m_orderId))

        self.tws.placeOrder(o.m_orderId, self.contracts[symbol], o)

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
 def sendOrder(self, orderReq):
     """发单"""
     # 增加报单号1，最后再次进行查询
     # 这里双重设计的目的是为了防止某些情况下，连续发单时，nextOrderId的回调推送速度慢导致没有更新
     self.orderId += 1
     
     # 创建合约对象
     contract = Contract()
     contract.m_symbol = str(orderReq.symbol)
     contract.m_exchange = exchangeMap.get(orderReq.exchange, '')
     contract.m_secType = productClassMap.get(orderReq.productClass, '')
     contract.m_currency = currencyMap.get(orderReq.currency, '')
     
     contract.m_expiry = orderReq.expiry
     contract.m_strike = orderReq.strikePrice
     contract.m_right = optionTypeMap.get(orderReq.optionType, '')
     
     # 创建委托对象
     order = Order()
     order.m_orderId = self.orderId
     order.m_clientId = self.clientId
     
     order.m_action = directionMap.get(orderReq.direction, '')
     order.m_lmtPrice = orderReq.price
     order.m_totalQuantity = orderReq.volume
     order.m_orderType = priceTypeMap.get(orderReq.priceType, '')
     
     # 发送委托
     self.connection.placeOrder(self.orderId, contract, order)
     
     # 查询下一个有效编号
     self.connection.reqIds(1)

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
def create_order(order_type, quantity, limit_price=None):
    """
    Creates an (ib.ext.Order) object to send to IB
    :param order_type: (string) "MARKET" or "LIMIT"
    :param quantity: (int)
    :return: (ib.ext.Order)
    """
    order = Order()
    if order_type is "MARKET":
        order.m_orderType = "MKT"
    elif order_type is "LIMIT":
        order.m_orderType = "LMT"
        order.m_lmtPrice = limit_price
    assert(order.m_orderType is not None), "Invalid order_type!"

    if quantity == 0:
        raise Exception('Order quantity is 0!')
    elif quantity > 0:
        order.m_action = "BUY"
    elif quantity < 0:
        order.m_action = "SELL"
    assert(order.m_action is not None), "Invalid order action!"
    order.m_totalQuantity = abs(quantity)
    assert(abs(order.m_totalQuantity) > 0), "Invalid order quantity!"

    return order

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
def make_order(limit_price):
    order = Order()
    order.m_minQty = 100
    order.m_lmtPrice = limit_price
    order.m_orderType = 'MKT'
    order.m_totalQuantity = 100
    order.m_action = 'BUY'
    return order

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
 def _create_order(action, qty, order_type, limit_price, stop_price):
     order = Order()
     order.m_action = action
     order.m_totalQuantity = qty
     order.m_auxPrice = stop_price
     order.m_lmtPrice = limit_price
     order.m_orderType = order_type
     return order

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
def make_order(qty, limit_price, action):
    order = Order()
    order.m_minQty = qty
    order.m_lmtPrice = limit_price
    order.m_orderType = 'LMT'
    order.m_totalQuantity = qty
    order.m_action = action
    order.m_tif = 'GTC'
    order.m_outsideRth = True
    return order

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
def create_order(action, quantity, price=None):
    order = Order()
    order.m_action = action
    order.m_totalQuantity = quantity
    if price is not None:
        order.m_orderType = 'LMT'
        order.m_lmtPrice = price
    else:
        order.m_orderType = 'MKT'
    return order

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
    def addOrder(
        self,
        symbol,
        lmtPrice=0,
        minQty=100,
        action="BUY",
        orderType="LMT",
        tif="DAY",
        outsideRTH=False,
        totalQuantity=False,
    ):
        """Generate and store an order for the given symbol"""

        validAction = ["BUY", "SELL", "SSHORT"]
        if action not in validAction:
            raise Exception(
                "{0} is not a valid order action. " + "Valid actions are: {1}.".format(action, ", ".join(validAction))
            )

        validType = [
            "LMT",
            "MKT",
            "MKTCLS",
            "LMTCLS",
            "PEGMKT",
            "SCALE",
            "STP",
            "STPLMT",
            "TRAIL",
            "REL",
            "VWAP",
            "TRAILLIMIT",
        ]
        if orderType not in validType:
            raise Exception(
                "{0} is not a valid order type. " + "Valid types are: {1}.".format(orderType, ", ".join(validType))
            )

        validTIF = ["DAY", "GTC", "IOC", "GTD"]
        if tif not in validTIF:
            raise Exception("{0} is not a valid TIF." + "Valid TIFs are: {1}.".format(tif, ", ".join(validTIF)))

        o = Order()
        o.m_minQty = minQty
        o.m_totalQuantity = totalQuantity if totalQuantity else minQty
        o.m_lmtPrice = lmtPrice
        o.m_action = action
        o.m_tif = tif
        o.m_orderType = orderType
        o.m_outsideRth = outsideRTH

        self._orders[symbol] = self._next_valid_id, o

        self._next_valid_id += 1
        return self._next_valid_id - 1

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
def create_order(order_type, quantity, action, limitprice):
    """Create an Order object (Market/Limit) to go long/short.
    order_type - 'MKT', 'LMT' for Market or Limit orders
    quantity - Integral number of assets to order
    action - 'BUY' or 'SELL'"""
    order = Order()
    order.m_orderType = order_type
    order.m_totalQuantity = quantity
    order.m_action = action
    order.m_lmtPrice = limitprice
    return order

# 需要导入模块: from ib.ext.Order import Order [as 别名]
# 或者: from ib.ext.Order.Order import m_lmtPrice [as 别名]
	def addlmtorder(self, action, qty, oc, price, cid, tif = "DAY", date = ""):
		o = Order()
		o.m_action = action
		#print tif
		o.m_tif = tif
		o.m_orderType = 'LMT'
		o.m_totalQuantity = qty
		o.m_openClose = oc
		o.m_lmtPrice = float(round(price,2))
		o.m_goodTillDate = date
		res = self.placeOrder(cid, o)
		return(res)