There are several ways, which one you will use depends on the specifics of your problem. Generally you don't want to open any new buy orders while you still have a pending sell order because if the sell order fills you could use the money for your buy order. You also don't want to open any order for a security that another order already exists for. With proper order management you can perfectly control your leverage (pending liquidity)

1) Check for any open orders before opening a new order

if get_open_orders(): return  
for stock in list:  
    #ordering logic  

2) check for open orders on a security before attempting to sell

for stock in list:  
    if get_open_orders(stock): continue  
    #sell logic  

3) Canceling all orders at the start of rebalancing (this can be modified for canceling only sell orders or only buy orders)

def cancel_open_orders(context, data):  
    oo = get_open_orders()  
    if len(oo) == 0:  
        return  
    for stock, orders in oo.iteritems():  
        for order in orders:  
            #message = 'Canceling order of {amount} shares in {stock}'  
            #log.info(message.format(amount=order.amount, stock=stock))  
            cancel_order(order)  

4) cancel any existing order for a security before you attempt to open a new order on it.

def cancel_open_order(sec):  
    oo = get_open_orders(sec)  
    if len(oo) == 0:  
        return  
    for order in oo:  
        if order.sid == sec:  
            cancel_order(order)  

Luke,
Thanks for responding to my request positively!
While I've used the functions you've listed in certain situations,
it hasn't been clear to me why, when and in what order I need them, but will now think about it more.

I'm thinking of creating a user's portfolio and order tracking class, with an eye towards tracking, monitoring, and restricting certain actions
perhaps on a minutely basis:
- liquidity effects on portfolio assets (buy/sell/filled/slippage and commission ),
- portfolio rebalancing constraints and measurements (resolve ordering conflicts with respect to a golden target portfolio)
-internal/external split/delisting functions (i.e. neuter out assets that'll be delisted in the future, or validate a split against some external data source.)

This is probably too much to bite off, but something simple that applies a discipline across algorithms would be useful for me.
I guess that I need this class to get a grip on how a portfolio actually gets rebalanced, through time, given a target, and how to self-correct "mistakes" in
the asynchronous nature of the transactions.

Been looking at:
https://github.com/quantopian/zipline/tree/master/zipline/finance
https://www.quantopian.com/posts/helper-functions-getting-started-on-quantopian

Again, thanks for your help!
alan