portfolio columnchart json

src/rethink/portfolio_item.py

@@ -22,7 +22,7 @@ class PortfolioRules():
                 'symbol': {'HSI' : 'FUT', 'MHI' : 'FUT', 'QQQ' : 'STK'},
                 'expiry': {'HSI' : 'same_month', 'MHI': 'same_month', 'STK': 'leave_blank'},
                 'option_structure': {
-                                        'HSI': {'spd_size': 200, 'multiplier': 50, 'rate': 0.0012, 'div': 0, 'trade_vol':0.15},
+                                        'HSI': {'spd_size': 200, 'multiplier': 50.0, 'rate': 0.0012, 'div': 0, 'trade_vol':0.15},
                                         'MHI': {'spd_size': 200, 'multiplier': 10, 'rate': 0.0012, 'div': 0, 'trade_vol':0.15}
                                         
                                     },
@@ -247,6 +247,9 @@ class Portfolio(AbstractTableModel):
         except KeyError:
             return None
         
+    def get_portfolio_port_items(self):
+            return self.port['port_items']
+        
     def create_empty_portfolio(self):
         self.port = {}
         self.port['port_items']=  {}
@@ -489,50 +492,96 @@ class PortfolioColumnChart:
         row1: <strike>, <month-contract_type-
         
     '''
-    def __init__(self, port):
-        self.port = port
+    def __init__(self, pf):
+        self.pf = pf
         
     
     def get_JSON(self):  
         
         
-        p_items = self.port['port_items'].items()
+        p2_items = self.pf.get_portfolio_port_items().values()
+        p1_items = filter(lambda x: x.get_symbol_id() in PortfolioRules.rule_map['interested_position_types']['symbol'], p2_items)
+        p_items = filter(lambda x: x.get_instrument_type() in  PortfolioRules.rule_map['interested_position_types']['instrument_type'], p1_items)
         
+        print ','.join(str(x.get_strike()) for x in p_items)
         # row values domain
         # find out the strikes of all contracts purchased, for futures, use the average cost 
         x_range  = set(
-                    map(lambda x:x.get_strike(), filter(lambda x: x.get_right() in 'OPT', p_items)) +   
-                    map(lambda x:x.get_port_field(PortfolioItem.AVERAGE_COST), filter(lambda x: x.get_right() in 'FUT', p_items))
+                    map(lambda x:int(round(x.get_strike(),-1)), filter(lambda x: x.get_instrument_type() in 'OPT', p_items)) +   
+                    map(lambda x:int(round(x.get_port_field(PortfolioItem.AVERAGE_PRICE),-1)), filter(lambda x: x.get_instrument_type() in 'FUT', p_items))
                    )
     
-        # column values domain (month,symbol,contract_type)
-        y_range = set(map(lambda x:'%s-%s-%s' % (x.get_expiry(),  x.get_symbol_id(), x.get_instrument_type() ), p_items))
+        # column values domain (month,symbol,contract_type, right)
+        y_range = set(map(lambda x:'%s-%s-%s-%s' % (x.get_expiry(),  x.get_symbol_id(), 
+                                                    x.get_instrument_type(), x.get_right() ), p_items))
         
+
+
         # sort the list then create a map that stores kv pairs of value:index_pos
         x_range = sorted(list(x_range))
+        print x_range
         x_map = {}
+        x_map_reverse = {}
         for i in range(len(x_range)):
             x_map[x_range[i]] = i
-        
+            x_map_reverse[i] = x_range[i]
+        print '---xmap and xmap reverse' 
+        print x_map
+        print x_map_reverse
+        print '----'
 
         y_range = sorted(list(y_range))
         y_map = {}
+        y_map_reverse = {}
         for i in range(len(y_range)):
-            y_map[y_range[i]] = i  
-        
+            y_map[y_range[i]] = i
+            y_map_reverse[i]= y_range[i]  
         
+        print '---ymap and ymap reverse' 
+        print y_map
+        print y_map_reverse
+        print '----'
         def set_ij(p_item):
-            i = x_map[p_item.get_strike()]
-            j = y_map['%s-%s-%s' % (p_item.get_expiry(),  p_item.get_symbol_id(), p_item.get_instrument_type())]
-            v = p_item.get_quantity()
+            if p_item.get_instrument_type() == 'FUT':
+                i = x_map[int(round(p_item.get_port_field(PortfolioItem.AVERAGE_PRICE), -1))]
+                #
+                # hard code logic below to convert number of MHI in HSI unit (that is 5:1)
+                v = p_item.get_quantity() *\
+                 (PortfolioRules.rule_map['option_structure'][p_item.get_symbol_id()]['multiplier'] /
+                  PortfolioRules.rule_map['option_structure']['HSI']['multiplier'] 
+                  )
+                
+                
+            else:
+                i = x_map[int(round(p_item.get_strike(), -1))]
+                v = p_item.get_quantity()
+            j = y_map['%s-%s-%s-%s' % (p_item.get_expiry(),  p_item.get_symbol_id(), p_item.get_instrument_type(), p_item.get_right())]
+            
             return (i,j,v)
         
         ijv_dist = map(set_ij, p_items)
-        xy_arr = np.array((len(x_range), len(y_range)))
+        print ijv_dist
+        xy_arr = np.zeros((len(x_range), len(y_range)))
         
         def update_ijv(ijv):
             xy_arr[ijv[0], ijv[1]] = ijv[2]
             return 1
         
         map(update_ijv, ijv_dist)
-        
+        print xy_arr
+        
+        def gen_datatable():
+            ccj = {'cols':[{'id': 'strike', 'label': 'strike', 'type': 'number'}], 'rows':[]}
+            for j in range(len(y_map_reverse)):
+                ccj['cols'].append({'id': y_map_reverse[j], 'label': y_map_reverse[j], 'type': 'number' })
+                
+            def row_item(i):
+                for m in range(xy_arr.shape[1]):
+                    ccj['rows'][i]['c'].append({'v':xy_arr[i][m]})     
+                               
+            for i in range(len(x_map_reverse)):
+                ccj['rows'].append({'c':[{'v':x_map_reverse[i]}]})
+                row_item(i)
+            return ccj    
+                
+        return gen_datatable()

src/rethink/portfolio_monitor.py

@@ -10,7 +10,7 @@ from misc2.helpers import ContractHelper
 from finopt.instrument import Symbol, Option
 from rethink.option_chain import OptionsChain
 from rethink.tick_datastore import TickDataStore
-from rethink.portfolio_item import PortfolioItem, PortfolioRules, Portfolio
+from rethink.portfolio_item import PortfolioItem, PortfolioRules, Portfolio, PortfolioColumnChart
 from rethink.table_model import AbstractTableModel, AbstractPortfolioTableModelListener
 from comms.ibc.tws_client_lib import TWS_client_manager, AbstractGatewayListener
 
@@ -57,6 +57,7 @@ class PortfolioMonitor(AbstractGatewayListener, AbstractPortfolioTableModelListe
                 menu['4']="Request account updates"
                 menu['5']="Table chart JSON"
                 menu['6']="Table index mapping"
+                menu['7']="Position Distribution JSON"
                 menu['9']="Exit"
         
                 choices=menu.keys()
@@ -100,6 +101,10 @@ class PortfolioMonitor(AbstractGatewayListener, AbstractPortfolioTableModelListe
                     elif selection == '6':
                         for acct in self.portfolios.keys():
                             print self.portfolios[acct].dump_table_index_map() 
+                    elif selection == '7':
+                        for acct in self.portfolios.keys():
+                            pc = PortfolioColumnChart(self.portfolios[acct])
+                            print pc.get_JSON()
                             
                     elif selection == '9': 
                         self.twsc.gw_message_handler.set_stop()
@@ -113,7 +118,11 @@ class PortfolioMonitor(AbstractGatewayListener, AbstractPortfolioTableModelListe
             logging.error('PortfolioMonitor: caught user interrupt. Shutting down...')
             self.twsc.gw_message_handler.set_stop() 
             logging.info('PortfolioMonitor: Service shut down complete...')               
-    
+        except:
+            logging.error('PortfolioMonitor. caught user interrupt. Shutting down...%s' % traceback.format_exc())
+ 
+            self.twsc.gw_message_handler.set_stop() 
+            logging.info('PortfolioMonitor: Service shut down complete...')               
         
     def get_kproducer(self):
         # returns a reference to the kafka base producer that we can