def _possible_args(self):

return self._required_columns()+self._optional_columns()

def _required_columns(self):

return ['Code', 'Commission', 'Price', 'Quantity', 'Tax', 'Date', 'Currency']

def _optional_columns(self):

return self._optional_columns_misc()+self._optional_columns_values()+self._optional_columns_preprocess()+ \

self._optional_columns_allocation()

def _optional_columns_misc(self):

return ['AssetClass', 'parent', 'nextchild','original']

def _optional_columns_values(self):

return [ 'BS']

def _optional_columns_preprocess(self):

return ['FXRate', 'TradeID', 'Value', 'SignQuantity']

def _optional_columns_allocation(self):

return ['tradetype', 'pseudotrade','sharedtrade']

def _has_preprocess_data(self):

return all([x in self.argsused for x in self._optional_columns_preprocess()])

def _has_allocation_data(self):

return all([x in self.argsused for x in self._optional_columns_allocation()]) and \

"SignQuantity" in self.argsused

def _ready_for_split(self):

"""

Can this trade be split?

"""

return self._has_preprocess_data() and self._has_allocation_data()

def _type_check(self):

arg_types=dict(Code=str, Commission=float, Price=float, Quantity=float, Tax=float, Date=datetime.datetime,

BS=str, Currency=str, Value=float,

SignQuantity=float, FXRate=float, AssetClass=str,

tradetype=str, pseudotrade=bool, sharedtrade=bool, TradeID=str, parent=Trade, nextchild=str,

original=Trade)

return arg_types

def _check_inputs(self):

if self.Commission<0.0:

raise Exception("can't have negative commssion")

if self.Tax<0.0:

raise Exception("can't have negative tax")

if self.Quantity<0:

raise Exception("Quantity can't be negative (you're confusing with SignQuantity")

if "SignQuantity" in self.argsused:

if "Quantity" in self.argsused and "BS" in self.argsused:

checksignquant = self._signed_quantity()

if checksignquant!=self.SignQuantity:

raise Exception("Signed quantity of %d not consistent with quantity of %d and BS of %s" %

(self.SignQuantity, self.Quantity, self.BS))

if "typestring" in self.argsused:

assert self.typestring in ["Open", "Close", "OverClose"]

if "Value" in self.argsused:

if not self.Value==0.0 and self.SignQuantity==0.0:

assert not signs_match(self.Value, self.SignQuantity)

def __init__(self, **kwargs):

'''

Constructor

'''

type_and_sense_check_arguments(self, kwargs)

argsused=[]

for key in kwargs:

argsused.append(key)

setattr(self, key, kwargs[key])

setattr(self, 'argsused', argsused)

self._check_inputs()

def modify(self, **kwargs):

modorderfill=type_and_sense_check_arguments(self, kwargs, checkrequired=False)

argsused=self.argsused

for key in modorderfill:

setattr(self, key, modorderfill[key])

argsused.append(key)

argsused=list(set(argsused))

setattr(self, 'argsused', argsused)

self._check_inputs()

def __repr__(self):

return "ID %s Code %s Date %s Quantity %s Price %s Value per block %s" % \

(getattr(self, "TradeID",""), self.Code, str(self.Date), pretty(self.SignQuantity),

pretty(self.Price), pretty(abs(self.Value/self.SignQuantity)))

def brief(self):

return "ID %s Quantity %s" % (getattr(self, "TradeID",""), pretty(self.SignQuantity))

def full(self):

print repr_class(self)

def add_value(self, raiseerror=True):

if "Value" in self.argsused and raiseerror:

raise Exception("Can't add_value on trade as Value field already set")

if not "SignQuantity" in self.argsused:

self.add_signed_quantity()

## Cash flow method. Negative means buy ...

value= - self.Price * self.SignQuantity

self.modify(Value=value)

return self

def bslabel(self):

if "BS" in self.argsused:

return self.BS

if "SignQuantity" in self.argsused:

if self.SignQuantity>0:

return "BUY"

elif self.SignQuantity<0:

return "SELL"

return "Unknown"

def _signed_quantity(self):

if "BS" not in self.argsused:

raise Exception("can't add signed quantity without BUY or SELL")

if self.BS=="BUY":

multiplier=1

elif self.BS=="SELL":

multiplier=-1

else:

raise Exception("BS can't be %s" % self.BS)

sign_quantity=multiplier * self.Quantity

return sign_quantity

def add_signed_quantity(self):

if "SignQuantity" in self.argsused:

raise Exception("Already have signed quantity")

sign_quantity=self._signed_quantity()

self.modify(SignQuantity=sign_quantity)

return self

def _init_allocation(self, tradetype):

assert self._has_preprocess_data()

self.modify(tradetype=tradetype, pseudotrade=False, sharedtrade=False)

def _share_of_trade(self, share=None, pro_rata=None):

"""

Returns a trade, a clones of self, with quantity share or a pro_rata proportion

"""

assert not (share is None and pro_rata is None)

newtrade=copy(self)

oldquantity=copy(self.SignQuantity)

if pro_rata is None:

assert type(share) is float

assert signs_match(share, oldquantity)

assert abs(share)<=abs(oldquantity)

pro_rata=share/oldquantity

if share is None:

assert type(pro_rata) is float

assert pro_rata>=0.0 and pro_rata<=1.0

share=oldquantity*pro_rata

if pro_rata==0.0:

newtrade.modify(Value=0.0, Commission=0.0, Tax=0.0,

SignQuantity=0.0, Quantity=0.0,

)

else:

newtrade.modify(Value=self.Value*pro_rata, Commission=self.Commission*pro_rata, Tax=self.Tax*pro_rata,

SignQuantity=share, Quantity=abs(share),

)

return newtrade

def spawn_pseudo_trades(self, tradetoclose):

"""

Returns a new clone trade with tradetoclose, and a residual clone trade

"""

assert self._ready_for_split()

assert not self.pseudotrade

oldquantity=copy(self.SignQuantity)

residualtrade=oldquantity - tradetoclose

assert type(tradetoclose) is float

assert signs_match(tradetoclose, oldquantity)

assert abs(tradetoclose)<=abs(oldquantity)

assert abs(tradetoclose)>0.0

neworder=self._share_of_trade(share=tradetoclose)

changedorder=self._share_of_trade(share=residualtrade)

neworder.modify(tradetype="Close")

changedorder.modify(tradetype="Open")

neworder.modify(pseudotrade=True)

changedorder.modify(pseudotrade=True)

oldtradeid=self.TradeID

neworder.modify(TradeID=oldtradeid+":1")

changedorder.modify(TradeID=oldtradeid+":2")

## To avoid duplications we make the opening order a second after the old one

newdate=changedorder.Date+datetime.timedelta(seconds=1)

changedorder.modify(Date=newdate)

return [changedorder, neworder]

def spawn_child_trade(self, share=None, pro_rata=None):

"""

Return a child order, which is a shared trade with a letter suffix, and the parent trade in attribute

and a smaller parent order.

If this is an only child, then the child becomes the parent

"""

assert self._ready_for_split()

assert not self.sharedtrade

thischildid=(getattr(self, "nextchild",None))

if thischildid is None:

firstchild=True

thischildid="a"

else:

firstchild=False

if share is not None:

residual_share = self.SignQuantity - share

residual_pro_rata=None

elif pro_rata is not None:

if pro_rata==1.0:

residual_pro_rata=0.0

else:

residual_pro_rata = 1.0 - pro_rata

residual_share=None

else:

raise Exception("Tried to spawn child order without share or pro rata")

original_trade=(getattr(self, "original",None))

if original_trade is None:

## We keep this so we know the original size of the allocation

original_trade=copy(self)

self.modify(original=original_trade)

child_trade=self._share_of_trade(share=share, pro_rata=pro_rata)

parent_trade=self._share_of_trade(share=residual_share, pro_rata=residual_pro_rata)

parent_trade.modify(nextchild=next_letter_code(thischildid))

if firstchild and self._last_child(share=share, pro_rata=pro_rata):

## only child- will be same as parent

childid=parent_trade.TradeID

child_trade.modify(sharedtrade=False, TradeID=childid)

else:

childid=parent_trade.TradeID+thischildid

child_trade.modify(sharedtrade=True, TradeID=childid, parent=original_trade)

return (parent_trade, child_trade)

def _last_child(self,share=None, pro_rata=None):

oldquantity=self.SignQuantity

if pro_rata is not None:

assert type(pro_rata) is float

assert pro_rata>=0.0 and pro_rata<=1.0

if abs(pro_rata - 1.0)<THRESHOLD:

return True

else:

return False

if share is not None:

assert type(share) is float

assert signs_match(share, oldquantity)

assert abs(share)<=abs(oldquantity)

if abs(share - oldquantity)<THRESHOLD:

return True

else:

return False

raise Exception("no share or pro rata")

def total_mine_or_parent(self):

parent=(getattr(self, "parent",None))

if parent is None:

return self.SignQuantity

else: