Position cost basis will not include commissions, so will realized and unrealized P/L. (Issue 147)

Author: fxdemolisher

doc/2011-04-02-v0.11-migrations.sql

@@ -5,12 +5,14 @@ DELETE FROM tax_lot;
 DELETE FROM position;
 
 ALTER TABLE tax_lot
-CHANGE COLUMN cost_price price double precision NOT NULL,
 MODIFY COLUMN as_of_date date,
+CHANGE COLUMN cost_price price double precision NOT NULL,
 MODIFY COLUMN quantity double precision NOT NULL,
-ADD COLUMN sold_as_of_date date AFTER price,
+ADD COLUMN total double precision NOT NULL,
+ADD COLUMN sold_as_of_date date AFTER total,
 MODIFY COLUMN sold_quantity double precision NOT NULL,
 MODIFY COLUMN sold_price double precision NOT NULL,
+ADD COLUMN sold_total double precision NOT NULL,
 RENAME lot
 ;
 
@@ -22,4 +24,8 @@ ADD INDEX lot_as_of_date (as_of_date),
 ADD INDEX lot_sold_as_of_date (sold_as_of_date)
 ;
 
+ALTER TABLE position
+ADD column cost_basis double precision NOT NULL after cost_price
+;
+
 -- END SEGMENT

frano/positions/models.py

@@ -27,6 +27,7 @@ class Position(models.Model):
   symbol = models.CharField(max_length = 10)
   quantity = models.FloatField()
   cost_price = models.FloatField()
+  cost_basis = models.FloatField()
   realized_pl = models.FloatField()
 
   class Meta:
@@ -40,21 +41,25 @@ class Lot(models.Model):
   as_of_date = models.DateField(null = True)
   quantity = models.FloatField()
   price = models.FloatField()
+  total = models.FloatField()
   sold_as_of_date = models.DateField(null = True)
   sold_quantity = models.FloatField()
   sold_price = models.FloatField()
+  sold_total = models.FloatField()
 
   class Meta:
     db_table = 'lot'
 
   def __unicode__(self):
-    return "Lot: Bought %.4f @ %.4f on %s, Sold %.4f @ %.4f on %s " % ( 
+    return "Lot: Bought %.4f @ %.4f on %s (%.4f), Sold %.4f @ %.4f on %s (%.4f)" % ( 
         self.quantity, 
         self.price, 
         self.as_of_date.strftime('%m/%d/%Y') if self.as_of_date != None else None,
+        self.total,
         self.sold_quantity,
         self.sold_price,
         self.sold_as_of_date.strftime('%m/%d/%Y') if self.sold_as_of_date != None else None,
+        self.sold_total
       )
 
   def __cmp__(self, other):
@@ -79,13 +84,12 @@ def latest_positions(portfolio):
     return []
 
 def decorate_position_with_prices(position, price, previous_price):
-  """Decorate the given position with various pieces of data that require pricing (p/l, cost_basis, market_value)"""
+  """Decorate the given position with various pieces of data that require pricing (p/l, market_value)"""
 
   position.price = price
   position.previous_price = previous_price
 
   position.market_value = position.quantity * position.price
-  position.cost_basis = position.quantity * position.cost_price
   position.previous_market_value = position.quantity * position.previous_price
   position.pl = (position.market_value - position.cost_basis)
   position.pl_percent = (((position.pl / position.cost_basis) * 100) if position.cost_basis != 0 else 0)
@@ -109,100 +113,115 @@ def refresh_positions(portfolio, transactions = None, force = False):
 
 class LotBuilder:
   def __init__(self):
-    self.long_lots = []
-    self.short_lots = []
+    self.long_half_lots = []
+    self.short_half_lots = []
     self.closed_lots = []
 
   def __repr__(self):
     return "Open (Long):\n %s\n\nOpen (Short):\n %s\n\nClosed:\n %s" % (self.long_lots, self.short_lots, self.closed_lots)
 
   def add_transaction(self, transaction):
-    if transaction.type == 'BUY':
-      quantity_to_buy = transaction.quantity
-      while quantity_to_buy > 0 and len(self.short_lots) > 0:
-        lot = self.short_lots.pop(0)
-        if (quantity_to_buy - lot.sold_quantity) > -0.000001:
-          lot.as_of_date = transaction.as_of_date
-          lot.quantity = lot.sold_quantity
-          lot.price = transaction.price
-          
-          insort(self.closed_lots, lot)          
-          quantity_to_buy = quantity_to_buy - lot.quantity
-          
-        else:
-          new_lot = Lot(as_of_date = transaction.as_of_date, 
-              quantity = quantity_to_buy, 
-              price = transaction.price, 
-              sold_as_of_date = lot.sold_as_of_date, 
-              sold_quantity = quantity_to_buy, 
-              sold_price = lot.sold_price
-            )
-          
-          lot.sold_quantity = lot.sold_quantity - quantity_to_buy
-          self.short_lots.insert(0, lot)
-          insort(self.closed_lots, new_lot)
-          quantity_to_buy = 0
-      
-      if quantity_to_buy > 0.000001:
-        self.long_lots.append(
-            Lot(as_of_date = transaction.as_of_date, 
-              quantity = quantity_to_buy, 
-              price = transaction.price,
-              sold_quantity = 0,
-              sold_price = 0,
-            )
-          )
-      
-    elif transaction.type == 'SELL':
-      quantity_to_sell = transaction.quantity
-      while quantity_to_sell > 0 and len(self.long_lots) > 0:
-        lot = self.long_lots.pop(0)
-        if (quantity_to_sell - lot.quantity) > -0.000001:
-          lot.sold_as_of_date = transaction.as_of_date
-          lot.sold_quantity = lot.quantity
-          lot.sold_price = transaction.price
-          
-          insort(self.closed_lots, lot)          
-          quantity_to_sell = quantity_to_sell - lot.sold_quantity
-          
-        else:
-          new_lot = Lot(as_of_date = lot.as_of_date, 
-              quantity = quantity_to_sell, 
-              price = lot.price, 
-              sold_as_of_date = transaction.as_of_date, 
-              sold_quantity = quantity_to_sell, 
-              sold_price = transaction.price
-            )
-          lot.quantity = lot.quantity - quantity_to_sell
-          self.long_lots.insert(0, lot)
-          insort(self.closed_lots, new_lot)
-          quantity_to_sell = 0
+    fees = transaction.total - (transaction.quantity * transaction.price)
+    quantity = transaction.quantity
+    poll = self.short_half_lots
+    push = self.long_half_lots
+    if transaction.type == 'SELL':
+      push = poll
+      poll = self.long_half_lots
 
-      if quantity_to_sell > 0.000001:
-        self.short_lots.append(
-            Lot(quantity = 0,
-              price = 0,
-              sold_as_of_date = transaction.as_of_date, 
-              sold_quantity = quantity_to_sell, 
-              sold_price = transaction.price
-            )
-          )
-        
+    while quantity > 0 and len(poll) > 0:
+      half_lot = poll.pop(0)
+      if (quantity - half_lot.quantity) > -QUANTITY_TOLERANCE:
+        partial_fees = fees * (half_lot.quantity / quantity)
+        fees = fees - partial_fees
+        quantity -= half_lot.quantity
+        insort(self.closed_lots, half_lot.close(transaction.as_of_date, transaction.price, partial_fees))
+         
+      else:
+        closed = half_lot.partial_close(transaction.as_of_date, quantity, transaction.price, fees)
+        poll.insert(0, half_lot)
+        insort(self.closed_lots, closed)
+        quantity = 0
+        fees = 0
+    
+    if quantity > QUANTITY_TOLERANCE:
+      push.append(HalfLot(type = transaction.type,
+          as_of_date = transaction.as_of_date,
+          quantity = quantity,
+          price = transaction.price,
+          total = (quantity * transaction.price) + fees
+        ))
+    
     return self
 
   def get_lots(self):
     out = []
     for lot in self.closed_lots:
       insort(out, _clone_lot(lot))
 
-    for lot in self.long_lots:
-      insort(out, _clone_lot(lot))
-
-    for lot in self.short_lots:
-      insort(out, _clone_lot(lot))
+    for half_lot in (self.long_half_lots + self.short_half_lots):
+      insort(out, half_lot.to_lot(None, 0.0, 0.0, 0.0))
 
     return out
 
+class HalfLot():
+  def __init__(self, type, as_of_date, quantity, price, total):
+    self.type = type
+    self.as_of_date = as_of_date
+    self.quantity = quantity
+    self.price = price
+    self.total = total
+    
+  def __repr__(self):
+    return "%s: %.4f @ %.4f on %s (%.4f)" % (
+        self.type,
+        self.quantity,
+        self.price,
+        self.as_of_date.strftime('%m/%d/%Y'),
+        self.total,
+      )
+    
+  def close(self, as_of_date, price, fees):
+    return self.to_lot(as_of_date, self.quantity, price, fees)
+  
+  def partial_close(self, as_of_date, quantity, price, fees):
+    split_lot = HalfLot(type = self.type,
+        as_of_date = self.as_of_date,
+        quantity = quantity,
+        price = self.price,
+        total = None,
+      )
+    
+    split_lot.total = self.total * (split_lot.quantity / self.quantity)
+    self.total -= split_lot.total
+    self.quantity -= quantity
+    return split_lot.close(as_of_date, price, fees)
+  
+  def to_lot(self, as_of_date, quantity, price, fees):
+    lot = None
+    if self.type == 'BUY':
+      lot = Lot(as_of_date = self.as_of_date,
+          quantity = self.quantity,
+          price = self.price,
+          total = self.total,
+          sold_as_of_date = as_of_date,
+          sold_quantity = quantity,
+          sold_price = price,
+          sold_total = (quantity * price) + fees,
+        )
+    else:
+      lot = Lot(as_of_date = as_of_date,
+          quantity = quantity,
+          price = price,
+          total = (quantity * price) + fees,
+          sold_as_of_date = self.as_of_date,
+          sold_quantity= self.quantity,
+          sold_price = self.price,
+          sold_total = self.total,
+        )
+    
+    return lot
+      
 #-------------------\
 #  LOCAL FUNCTIONS  |
 #-------------------/
@@ -226,6 +245,7 @@ def _refresh_positions_from_transactions(transactions):
       symbol = CASH_SYMBOL,
       quantity = 0,
       cost_price = 1.0,
+      cost_basis = 0.0,
       realized_pl = 0.0
     )
 
@@ -256,7 +276,9 @@ def _refresh_positions_from_transactions(transactions):
         builder.add_transaction(transaction)
 
     # add current cash to positions.
-    positions.append(_clone_position(cash, date))
+    days_cash = _clone_position(cash, date)
+    days_cash.cost_basis = days_cash.quantity
+    positions.append(days_cash)
 
     # compose current lots into a position.
     lots = []
@@ -266,7 +288,8 @@ def _refresh_positions_from_transactions(transactions):
           symbol = symbol, 
           quantity = 0.0, 
           cost_price = 0.0, 
-          realized_pl = 0.0
+          cost_basis = 0.0,
+          realized_pl = 0.0,
         )
 
       for lot in builder.get_lots():
@@ -278,12 +301,13 @@ def _refresh_positions_from_transactions(transactions):
           quantity = 0.0
 
         if abs(quantity) > QUANTITY_TOLERANCE:
+          position.cost_basis += (lot.total - lot.sold_total)
           total = (position.quantity * position.cost_price) + (quantity * lot.price)
           position.quantity += quantity
           position.cost_price = (total / position.quantity if quantity <> 0.0 else 0.0)
-      
-        if abs(lot.sold_quantity) > QUANTITY_TOLERANCE:
-          position.realized_pl += (lot.sold_quantity * (lot.sold_price - lot.price))
+          
+        else:
+          position.realized_pl += lot.sold_total - lot.total
 
       if abs(position.quantity) < QUANTITY_TOLERANCE:
         position.quantity = 0.0
@@ -309,9 +333,11 @@ def _clone_lot(lot):
   return Lot(as_of_date = lot.as_of_date,
       quantity = lot.quantity,
       price = lot.price,
+      total = lot.total,
       sold_as_of_date = lot.sold_as_of_date,
       sold_quantity = lot.sold_quantity,
-      sold_price = lot.sold_price
+      sold_price = lot.sold_price,
+      sold_total = lot.sold_total
     )
 
 def _clone_position(position, new_as_of_date = None):
@@ -323,4 +349,4 @@ def _clone_position(position, new_as_of_date = None):
   out.cost_price = position.cost_price
   out.realized_pl = position.realized_pl
 
-  return out;
+  return out

frano/positions/templates/positions.html

@@ -159,11 +159,11 @@
                             <td class="center">{{ lot.as_of_date|date:'m/d/Y' }}</td>
                             <td>{{ lot.quantity|num_format:"4" }}</td>
                             <td>${{ lot.price|num_format }}</td>
-                            <td>${{ lot.buy_total|num_format }}</td>
+                            <td>${{ lot.total|num_format }}</td>
                             <td class="center">{{ lot.sold_as_of_date|date:'m/d/Y' }}</td>
                             <td>{{ lot.sold_quantity|num_format:"4" }}</td>
                             <td>${{ lot.sold_price|num_format }}</td>
-                            <td>${{ lot.sell_total|num_format }}</td>
+                            <td>${{ lot.sold_total|num_format }}</td>
                             <td class="{{ lot.pl|sign_choice:'pos,neg,' }}">${{ lot.pl|num_format }}</td>
                             <td class="{{ lot.pl|sign_choice:'pos,neg,' }}">{{ lot.pl_percent|floatformat:2 }}%</td>
                           </tr>

frano/positions/views.py

@@ -156,20 +156,17 @@ def _decorate_positions_with_lots(positions):
   for position in positions:
     lots = []
     for lot in position.lot_set.order_by('-as_of_date'):
-      lot.buy_total = lot.price * lot.quantity
-      lot.sell_total = lot.sold_price * lot.sold_quantity
-      total = max(lot.buy_total, lot.sell_total)
+      total = max(lot.total, lot.sold_total)
 
       days_open = (datetime.now().date() - (lot.as_of_date if lot.as_of_date != None else lot.sold_as_of_date)).days
       if abs(lot.quantity - lot.sold_quantity) < 0.0001:
         lot.status = 'Closed'
-        lot.pl = lot.sold_quantity * (lot.sold_price - lot.price)
+        lot.pl = lot.sold_total - lot.total
       else:
         lot.status = 'Open'
-        open_price = (lot.price if lot.quantity > lot.sold_quantity else lot.sold_price)
-        lot.pl = abs(lot.quantity - lot.sold_quantity) * (position.price - open_price)
+        lot.pl = ((lot.quantity - lot.sold_quantity) * position.price) - (lot.total - lot.sold_total)
 
-      lot.pl_percent = ((lot.pl / total) if total <> 0.0 else 0)
+      lot.pl_percent = (((lot.pl / total) * 100) if total <> 0.0 else 0)
       lots.append(lot)
 
     position.lots = lots
@@ -191,7 +188,7 @@ def _get_summary(positions, transactions):
   previous_market_value = 0
   for position in positions:
     market_value += position.market_value
-    cost_basis += position.cost_price * position.quantity
+    cost_basis += position.cost_basis
     realized_pl += position.realized_pl
     previous_market_value += position.previous_market_value