def testFairSpread(self):
       marketDataContainer = MarketDataContainer()
       marketData = self._pos.marketData(self._pricingDate, self._marketId)
       marketDataContainer.add(marketData)
       self._pos.setMarketDataContainer(marketDataContainer)
 #      print round(self._pos.fairSpread(self._pricingDate, self._marketId),2)
       self.failIf(round(self._pos.fairSpread(self._pricingDate, self._marketId),2) <> 0.0)
 def testNPV(self):
     marketDataContainer = MarketDataContainer()
     marketData = self._pos.marketData(self._pricingDate, self._marketId)
     marketDataContainer.add(marketData)
     self._pos.setMarketDataContainer(marketDataContainer)
 #    print round(self._pos.NPV(self._pricingDate, self._marketId),2)
     self.failIf(round(self._pos.NPV(self._pricingDate, self._marketId),2) <> -5044.78)
Exemple #3
0
    def fct1(self,x):
#        print '__________________' + str(x)
        
        position = BondPosition(amount=1,tCBond=self.tCBond)
        marketDataContainer = MarketDataContainer()
        marketData = position.marketData(self.pricingDate, self.marketId)
#         #print marketData
        for m in marketData:
            if m.__class__ == BondOAS:
                m.mid = x[0]
        marketDataContainer.add(marketData)
        position.setMarketDataContainer(marketDataContainer)
        npv = position.NPV(self.pricingDate, self.marketId)
        result = math.fabs(npv-self.price)
#        print npv
 #       print self.price
        return result
    def calc(self):
#        print 'in calc'
        startDjangoPositions = ModelPosition.objects.filter(portfolio=self.portfolio, asOf=self.start)
        for djangoPosition in startDjangoPositions:
            position = CreatePosition(djangoPosition)
            self.portfolio.addPosition(position)
        marketDataContainer = MarketDataContainer()
        for position in self.portfolio.positions:
 #           print position
            marketDataContainer.add(position.marketData(pricingDate=self.start, marketId=self.marketId))
        for position in self.portfolio.positions:
            position.marketDataContainer = marketDataContainer
        self.startValue = self.portfolio.NPV(pricingDate=self.start,marketId=self.marketId)
  #      print 'Start value = %f' % self.startValue
        
        endPortfolio =Portfolio.objects.get(name=self.portfolio.name,user=self.portfolio.user)
        endDjangoPositions = ModelPosition.objects.filter(portfolio=endPortfolio, asOf=self.end)
        for djangoPosition in endDjangoPositions:
            position = CreatePosition(djangoPosition)
            endPortfolio.addPosition(position)
        marketDataContainer = MarketDataContainer()
        for position in endPortfolio.positions:
            marketDataContainer.add(position.marketData(pricingDate=self.end, marketId=self.marketId))
        for position in endPortfolio.positions:
            position.marketDataContainer = marketDataContainer
        self.endValue = endPortfolio.NPV(pricingDate=self.end,marketId=self.marketId)
   #     print 'End portfolio value = %f' % self.endValue

        #Adjust all positions but Cash ADD and REMOVE transactions so that I do not count them
        #We ignore the interest effect of these transactions
        transactions = Transaction.objects.filter(portfolio=endPortfolio,
                                                  transactionType = TransactionType('ADD'),
                                                  positionType = PositionType('CASH'),
                                                  ticker = 'Cash',
                                                  transactionDate__range=[self.start,self.end])

        #print transactions
        for transaction in transactions:
            self.transactionValue -= transaction.amount
            
        transactions = Transaction.objects.filter(portfolio=endPortfolio,
                                                  transactionType = TransactionType('REMOVE'),
                                                  positionType = PositionType('CASH'),
                                                  ticker = 'Cash',
                                                  transactionDate__range=[self.start,self.end])
        #print transactions
        for transaction in transactions:
            self.transactionValue += transaction.amount

        self.endValue += self.transactionValue
        #print 'Effective end value = %f' % self.endValue
        try:
            self.annualPerformance = ((self.endValue - self.startValue) / self.startValue) * \
                                    365.0 / (self.end.ql() - self.start.ql())   
        except ZeroDivisionError:
            self.annualPerformance = 0
        self.periodPerformance = self.annualPerformance * (self.end.ql() - self.start.ql()) / 365.0
        #print 'Annualized Performance is %f' % self.annualPerformance
        self.upToDate = True
 def __init__(self, pricingDate = None, portfolio = None, timeSteps = None,
              confidenceInterval = None, marketId = ''):
     '''
     Input: pricingDate, portfolio, timeSteps
     timeSteps is HVARTimeStepData object and defines start, end, and all dates
     '''
     if timeSteps == None:
         raise OtherException('timeSteps cannot be none')
     self.pricingDate = pricingDate
     self.start = timeSteps.start
     self.end = timeSteps.end
     self.timeStepDataList = []
     for item in timeSteps.timeSteps:
         self.timeStepDataList.append(HVARTimeStepData(date = item))
     self.portfolio = portfolio
     self.marketId = marketId
     self.todaysMarketDataContainer = MarketDataContainer()
     self.confidenceInterval = confidenceInterval
     self.upToDate = False
     self.pnls = []
     self.returns = []
    def testPriceWith2Curves(self):
        marketDataContainer = MarketDataContainer()
        marketData = self._pos.marketData(self._pricingDate, self._marketId)
#        print marketData[0].buildZeroCurve().nodes()
        marketDataContainer.add(marketData)
        self._pos.setMarketDataContainer(marketDataContainer)
        price1 = round(self._pos.NPV(self._pricingDate, self._marketId),5)
 #       print price1
        marketData[0].shift(0.01)
#        print marketData[0].buildZeroCurve().nodes()
        marketDataContainer1 = MarketDataContainer()
        marketDataContainer1.add(marketData)
        self._pos.setMarketDataContainer(marketDataContainer1)
        #add dirty flag to position to run setupql again. add add marketdatacontainer method
        price2 = round(self._pos.NPV(self._pricingDate, self._marketId),5)
#        print price2
        self.failIf(price1 == price2)
 def testCalculatePerformanceTEST1Portfolio1Y(self):
     #load portfolio as of start and value
     #load portfolio as of end and value
     #sum up all ADD and REMOVE Transaction
     #% return = {end - start + SUM(ADD) - SUM(REMOVE)} / Start
     startPortfolio =Portfolio.objects.get(name='TEST1')
     start = Date(month=8,day=30,year=2011)
     startDjangoPositions = ModelPosition.objects.filter(portfolio=startPortfolio, asOf=start)
     for djangoPosition in startDjangoPositions:
         position = CreatePosition(djangoPosition)
         startPortfolio.addPosition(position)
     marketDataContainer = MarketDataContainer()
     for position in startPortfolio.positions:
         marketDataContainer.add(position.marketData(pricingDate=start, marketId=self.marketId))
     for position in startPortfolio.positions:
         position.marketDataContainer = marketDataContainer
     startValue = startPortfolio.NPV(pricingDate=start,marketId=self.marketId)
     print 'Start value = %f' % startValue
     
     endPortfolio =Portfolio.objects.get(name='TEST1')
     end = Date(month=9,day=12,year=2011)
     endDjangoPositions = ModelPosition.objects.filter(portfolio=endPortfolio, asOf=end)
     for djangoPosition in endDjangoPositions:
         position = CreatePosition(djangoPosition)
         endPortfolio.addPosition(position)
     marketDataContainer = MarketDataContainer()
     for position in endPortfolio.positions:
         marketDataContainer.add(position.marketData(pricingDate=end, marketId=self.marketId))
     for position in endPortfolio.positions:
         position.marketDataContainer = marketDataContainer
     endValue = endPortfolio.NPV(pricingDate=end,marketId=self.marketId)
     print 'End value = %f' % endValue
     
     #Should add the looping over transactions that are ADD and REDUCE
     
     print 'Annualized Performance is %f' % (((endValue - startValue) / startValue) * 365.0 / (end.ql() - start.ql()))
class HistoricalVAR(cmt.cmt):
    '''
    Analysis to calculate Historical VAR
    '''
    def __init__(self, pricingDate = None, portfolio = None, timeSteps = None,
                 confidenceInterval = None, marketId = ''):
        '''
        Input: pricingDate, portfolio, timeSteps
        timeSteps is HVARTimeStepData object and defines start, end, and all dates
        '''
        if timeSteps == None:
            raise OtherException('timeSteps cannot be none')
        self.pricingDate = pricingDate
        self.start = timeSteps.start
        self.end = timeSteps.end
        self.timeStepDataList = []
        for item in timeSteps.timeSteps:
            self.timeStepDataList.append(HVARTimeStepData(date = item))
        self.portfolio = portfolio
        self.marketId = marketId
        self.todaysMarketDataContainer = MarketDataContainer()
        self.confidenceInterval = confidenceInterval
        self.upToDate = False
        self.pnls = []
        self.returns = []
        
    @log
    def generateTodaysMarketDataContainer(self):
        ''' 
        Generate today's market data for portfolio 
        '''
        for position in self.portfolio.positions:
            self.todaysMarketDataContainer.add(position.marketData(self.pricingDate, self.marketId))

    @log
    def generateAllHistoricalMarketDataContainers(self):
        '''
        Generates all market data containers for each time step
        '''
        for timeStep in self.timeStepDataList:
            for position in self.portfolio.positions:
                timeStep.marketDataContainer.add(position.marketData(timeStep.date, self.marketId))
                #scenario market data is based on as of market data. Shift is applied later
                timeStep.scenarioMarketDataContainer.add(position.marketData(self.pricingDate, self.marketId))
#        print '****Debug output HVAR*****'
#        for timeStep in self.timeStepDataList:
#            for m, s in zip(timeStep.marketDataContainer.marketDataList,
#                            timeStep.scenarioMarketDataContainer.marketDataList):
#                print m
#                print s
#        print '****Debug output HVAR done*****'

    @log
    def generateAllMarketDataShifts(self):
        first = True
        for timeStep in self.timeStepDataList:
            if first:
                prevTimeStep = timeStep
                first = False
                continue
            else:
                for marketData, prevMarketData in zip(timeStep.marketDataContainer.marketDataList,
                                                      prevTimeStep.marketDataContainer.marketDataList):
                    timeStep.shifts.append(marketData.createShiftCurve(prevMarketData))
                prevTimeStep = timeStep
                
    @log 
    def generateAllScenarios(self):
        first = True
        for timeStep in self.timeStepDataList:
            if first:
                first = False
                continue
            else:
                for marketData, shift in zip(timeStep.scenarioMarketDataContainer.marketDataList, 
                                             timeStep.shifts):
                    marketData.adjustWithShiftCurve(shift)
    
    @log
    def generateBaseValues(self):
        for position in self.portfolio.positions:
            position.setMarketDataContainer(self.todaysMarketDataContainer)
        value = self.portfolio.NPV(self.pricingDate, self.marketId)
        for timeStep in self.timeStepDataList:
            timeStep.value = value

    @log
    def generatePnls(self):
        first = True
        for timeStep in self.timeStepDataList:
            for position in self.portfolio.positions:
                position.setMarketDataContainer(timeStep.scenarioMarketDataContainer)
            value = self.portfolio.NPV(self.pricingDate, self.marketId)
            if first:
                timeStep.pnl = None
                first = False
            else:
                timeStep.pnl = value - timeStep.value
        
    @log
    def generateReturns(self):
        first = True
        for timeStep in self.timeStepDataList:
            if first:
                timeStep.percentReturn = None
                first = False
            else:
                timeStep.percentReturn = timeStep.pnl / timeStep.value

    @log
    def generateReturnsAndPnlsForStats(self):
        first = True
        for timeStep in self.timeStepDataList:
            if first:
                first = False
            else:
                self.pnls.append(timeStep.pnl)
                self.returns.append(timeStep.percentReturn)
                
    @log    
    def doAnalysis(self):
        '''
        Run historical VaR analysis. Can be re-run any time
        '''
#the following algorithm should be implemented:
#load today's position and today's market data
#generate shifts of market data for all time periods
#generate scenarios with shifts and today's market data
#run scenario analysis with simultaneous shifts
#output of scenario analysis is pnl vector
        self.generateTodaysMarketDataContainer()
        
        self.generateAllHistoricalMarketDataContainers()
        
        self.generateBaseValues()
        
        self.generateAllMarketDataShifts()

        self.generateAllScenarios()
     
        self.generatePnls()
        
        self.generateReturns()

        self.generateReturnsAndPnlsForStats()
        
        self.upToDate = True

    @log
    def getPnLList(self):
        '''
        Returns list of pnl values. Becuase pnl on first timestep is None
        we do not return it
        '''
        if self.upToDate == False:
            self.doAnalysis()
        return self.pnls
    @log
    def getDateList(self):
        '''
        Returns list of dates from timeSteps. This list includes the 
        first date. So, thi slist is one item longer than pnls and returns
        '''
        return [timeStep.date for timeStep in self.timeStepDataList]

    @log
    def getPercentile(self):
        '''
        Returns list of pnl values. Becuase pnl on first timestep is None
        we do not return it
        '''
        if self.upToDate == False:
            self.doAnalysis()
        return scipy.stats.scoreatpercentile(self.returns,100.0*(1-self.confidenceInterval))        
    @log
    def getMean(self):
        if self.upToDate == False:
            self.doAnalysis()
        return scipy.stats.nanmean(self.returns)
    @log
    def getStdDev(self):
        if self.upToDate == False:
            self.doAnalysis()
        return scipy.stats.moment(self.returns, 2)
    @log
    def run(self):
        return self.getPercentile()
Exemple #9
0
    def run(self):
        #Log
        if os.path.isfile(self.logFile):
            os.remove(self.logFile)
        logFileHandle = open(self.logFile,'w')
        logFileHandle.write('Running batch as of %s\n' % self.batchDate)
        logFileHandle.write('Max batch is %s\n' % self.maxBatchDate)
#        if QuantLib.TARGET().isBusinessDay(self.batchDate.ql()) == False:
 #           logFileHandle.write('Not a good business date based on QuantLib TARGET calendar. Exiting ...')
  #          print('Not a good business date based on QuantLib TARGET calendar. Exiting ...')
        
        #Update locations with date
        logFileHandle.write('\nUpdating all locations except TEST1 with new date\n')
        locations = Location.objects.filter(~Q(name='TEST1'))
        for location in locations:
            logFileHandle.write('Updating location %s\n' % location.name)
            location.pricingDate = self.batchDate.toPythonDate()
            location.save()
        
        #Load Equity prices
        logFileHandle.write('\nLoading equity prices\n')
        equities = Equity.objects.all()
        equityLoader = EquityPriceLoader()
        for equity in equities:
            #skip TEST1 and TEST2 as they are only used for testing
            if equity.ticker in ['TEST1', 'TEST2']:
                continue
            if StockPrice.objects.filter(equity=equity, pricingDate=self.batchDate, marketId=self.marketId).exists() == True:
                logFileHandle.write('%s price exists\n' % equity.ticker)
                continue
            else:
                logFileHandle.write('Loading prices for equity %s\n' % equity.ticker)
                try:
                    equityLoader.loadCurrentPriceFromYahoo(secId=equity.ticker, 
                                                           today=self.batchDate,
                                                           marketId=self.marketId)
                except MarketDataMissing:
                    logFileHandle.write('No market data loaded for %s as of %s\n' % (equity.ticker, self.batchDate))
                    logFileHandle.write('As default loading price from last batch date\n')
                    lastPrice = StockPrice.objects.get(equity=equity, pricingDate=self.maxBatchDate, marketId=self.marketId)
                    lastPrice.pricingDate = self.batchDate
                    lastPrice.pk = None
                    lastPrice.save()
                   
        #Load Interest Rates        
        logFileHandle.write('\nLoading Interest Rates\n')
        if self.maxBatchDate != self.batchDate:
            logFileHandle.write('For now just copy rates from max batch date to current batch date\n')
            curve = InterestRateCurve.objects.get(ccy=Currency('USD'), index=Index('LIBOR'), 
                                                  term=TimePeriod('M'), numTerms=3, 
                                                  pricingDate=self.maxBatchDate, 
                                                  marketId='EOD')
            curve.loadRates()
            
            newCurve = InterestRateCurve(ccy=Currency('USD'), index=Index('LIBOR'), 
                                         term=TimePeriod('M'), numTerms=3, 
                                         pricingDate=self.batchDate, 
                                         marketId='EOD')
            
            for rate in curve.getRates():
                newRate = InterestRate(type=rate.type, term=rate.term, numTerms=rate.numTerms, mid=rate.mid, curve=newCurve)
                logFileHandle.write('Rate: %s/%d/%0.2f\n' % (rate.term, rate.numTerms, rate.mid*100))
                newCurve.addRate(newRate)
            newCurve.save()

        #Copy OAS forward and keep constant
        logFileHandle.write('\nCopying OAS from max batch date to batch date\n')
        if self.maxBatchDate != self.batchDate:
            bondOAS = BondOAS.objects.get(tCBond=TCBond.objects.get(name='PortAuth_4.00_JAN42'),
                                          marketId='EOD', pricingDate=self.maxBatchDate)
            bondOAS.pk = None
            bondOAS.pricingDate = self.batchDate
            bondOAS.save()
            
        #Process Positions
        logFileHandle.write('\nProcessing positions\n')
        #load all positions with the max date
        #if the batchDate greater than maxbatchdate then copy position to batchdate (roll position forward)
        if self.maxBatchDate < self.batchDate:
            positions = ModelPosition.objects.filter(asOf=self.maxBatchDate)
            for position in positions:
                logFileHandle.write('Copying position %s from max batch date to batch date\n' % position)
                position.pk = None
                position.asOf = self.batchDate
                position.save()

        #Update Positions based on Transactions
        logFileHandle.write('\nUpdating of positions based on transaction\n')
        transactions = Transaction.objects.filter(reflectedInPosition=False)
        if len(transactions) == 0:
            logFileHandle.write('No transactions to process\n')
        else:
            for transaction in transactions:
                logFileHandle.write('Processing transaction %s\n' % str(transaction))
                positions = transaction.relatedPositions()
                for position in positions:
                    logFileHandle.write('Processing position %s\n' % str(transaction))
                    transaction.updatePositionAmount(position=position)  
                    position.save() 
                transaction.reflectedInPosition = 'True'
                transaction.save()                 
            
        #Performance
        logFileHandle.write('\nRunning Performance Report\n')
        if os.path.isfile(self.perfFile):
            os.remove(self.perfFile)
        perfFileHandle = open(self.perfFile,'w')
        portfolios = Portfolio.objects.filter(user='******')
        startValue = 0
        endValue = 0
        for portfolio in portfolios:
            performanceCalculator = PerformanceCalculator(start=self.productionStartDate,
                                                          end=self.batchDate,
                                                          portfolio=portfolio,
                                                          marketId=self.marketId)
            perfFileHandle.write(performanceCalculator.report()+'\n')
            startValue += performanceCalculator.startValue
            endValue += performanceCalculator.endValue
            endValue += performanceCalculator.transactionValue
        
        if startValue == 0 or (self.batchDate.ql() - self.productionStartDate.ql()) == 0:
            overallPerformance = 0
        else:
            overallPerformance = ((endValue - startValue) / startValue) * 365.0 / (self.batchDate.ql() - self.productionStartDate.ql())
        perfFileHandle.write('Overall Period Performance = %.2f%%\n' % (overallPerformance*100.0/365.0*(self.batchDate.ql() - self.productionStartDate.ql())))
        perfFileHandle.write('Overall Annual Performance = %.2f%%' % (overallPerformance*100.0))
        perfFileHandle.close()
        
        #MTM and Positions
        logFileHandle.write('\nRunning MTM and Positions Report\n')
        totalValue = 0
        if os.path.isfile(self.mtmFile):
            os.remove(self.mtmFile)
        mtmFileHandle = open(self.mtmFile,'w')
        portfolios =Portfolio.objects.filter(user='******')
        mtmFileHandle.write('MTM Report as of %s\n' % self.batchDate)
        for portfolio in portfolios:
            mtmFileHandle.write('Portfolio=%s\n' % portfolio.name)
            modelPositions = ModelPosition.objects.filter(portfolio=portfolio, asOf=self.batchDate)
            for modelPosition in modelPositions:
                position = CreatePosition(modelPosition=modelPosition)
                portfolio.addPosition(position)
            marketDataContainer = MarketDataContainer()
            for position in portfolio.positions:
                marketDataContainer.add(position.marketData(pricingDate=self.batchDate, marketId=self.marketId))
            for position in portfolio.positions:
                position.marketDataContainer = marketDataContainer
            for position in portfolio.positions:
                positionValue = position.NPV(pricingDate=self.batchDate,marketId=self.marketId)
                mtmFileHandle.write('ModelPosition=%s with %.0f shares, asset type %s and value $%s\n' % (position.secId,
                                                                                                   position.amount,
                                                                                                   position.getAssetType(),
                                                                                                   fToDC(positionValue)))
            portfolioValue = portfolio.NPV(pricingDate=self.batchDate,marketId=self.marketId)
            mtmFileHandle.write('Portfolio value=$%s\n\n' % fToDC(portfolioValue))
            totalValue += portfolioValue
        mtmFileHandle.write('Total value=%s\n\n' % fToDC(totalValue))

        #Asset Allocation
        #allocations is associative array with value
        allocations = {}
        totalValue = 0
        for item in AssetType.choices:
            allocations[item[0]] = 0
        logFileHandle.write('\nRunning Allocation Report\n\n')
        if os.path.isfile(self.allocationFile):
            os.remove(self.allocationFile)
        allocationFileHandle = open(self.allocationFile,'w')
        portfolios =Portfolio.objects.filter(user='******')
        allocationFileHandle.write('Allocation Report as of %s\n\n' % self.batchDate)
        for portfolio in portfolios:
            if portfolio.name == 'TradeAug2013':
                continue
            modelPositions = ModelPosition.objects.filter(portfolio=portfolio, asOf=self.batchDate)
            for modelPosition in modelPositions:
                position = CreatePosition(modelPosition)
                portfolio.addPosition(position)
            marketDataContainer = MarketDataContainer()
            for position in portfolio.positions:
                marketDataContainer.add(position.marketData(pricingDate=self.batchDate, marketId=self.marketId))
            for position in portfolio.positions:
                position.marketDataContainer = marketDataContainer
            for position in portfolio.positions:
                npv = position.NPV(pricingDate=self.batchDate, marketId=self.marketId)
                allocations[str(position.getAssetType())] += npv
                totalValue += npv
        
        orderedAllocations = OrderedDict(sorted(allocations.items(),key=lambda t: t[1],reverse=True))
        for key in orderedAllocations.keys():
            try:
                allocationPercent = Allocation.objects.get(assetType=AssetType(key)).percent
            except:
                allocationPercent = 0.0
            try:
                actualAllocation = 100*orderedAllocations[key]/totalValue
            except:
                actualAllocation = 0.0
            allocationFileHandle.write('%s=%.0f%%\t\t\t\t\t\twith target %.0f%%\t and value $%s\n' % (key,
                                                                                           actualAllocation,
                                                                                           100*allocationPercent,
                                                                                           fToD(orderedAllocations[key])))
        
        logFileHandle.write('Batch completed\n')
        logFileHandle.close()
        
        #Every time I run the batch and it succeeds we need to save the batch info
        self.batch.save()