Yeah, his QTA book is a good book to study and it makes sense to me.

For continueITDDAnalyzer:

I have created one analyzer called ITDDAnalyzer and another called continueITDDAnalyzer. Former one is to compute ITDD at the end of ONE simulation while continueITDDAnalyzer compute succeeding simulations.

from __future__ import (absolute_import, division, print_function,
						unicode_literals)

import backtrader as bt
from backtrader.analyzers import returns as returns
import pandas as pd
from backtrader.analyzers import TimeReturn
import logging

class ITDDAnalyzer(bt.TimeFrameAnalyzerBase):
	def CalculateITDD(self):
		value = self.strategy.broker.getvalue()
		if value > self.peak:
			self.peak = value
			self.ddlen = 0  # start of streak
		self.dd=dd= 100.0 * (self.peak - value) / self.peak
		self.ddlen+=bool(dd)
		self.ITDD=max(self.ITDD, self.dd)
		self.ITDDLength=max(self.ITDDLength,self.ddlen)

	def start(self,*args,**kwargs):
		self.ITDD=0
		self.ITDDLength=0
		self.initV=self.strategy.broker.getvalue()
		self.peak=float('-inf')
		self.ddlen= -1
		self.dd = 0
		self.ITDDRecord=[]

	def __init__(self):
		self._returns = TimeReturn(timeframe=bt.TimeFrame.Months)

	def notify_trade(self,trade):
		if self.strategy.getposition(self.data).size==0:
			#Calculate the ITDD together with commission included
			self.CalculateITDD()
			self.CARreturn=(self.strategy.broker.getvalue()/self.initV - 1)*100*252/max(trade.barlen,1)
			self.ITDDRecord.append([self.ITDD, self.ITDDLength,self.CARreturn])
			#Reset Parameters for next trade
			self.ITDD=0
			self.ITDDLength=int(0)
			self.initV=self.strategy.broker.getvalue()
			self.peak=float('-inf')
			self.ddlen= -1
			self.dd = 0

	def on_dt_over(self):
		if self.strategy.getposition(self.data).size==0:
			self.CalculateITDD()


class continueITDDAnalyzer(ITDDAnalyzer):
	def __init__(self):
		self._returns = TimeReturn(timeframe=bt.TimeFrame.Months)
		self.ITDDSet=self.strategy.contITDDSet

	def start(self):
		self.ITDD=self.ITDDSet['ITDD']
		self.ITDDLength=self.ITDDSet['ITDDLength']
		self.initV=self.ITDDSet['initV']
		self.value=self.strategy.broker.getvalue()
		self.peak=float(self.ITDDSet['peak'])
		self.ddlen=self.ITDDSet['ddlen']
		self.dd =self.ITDDSet['dd']

	def get_analysis(self):
		ITDDSet = {'ITDD':self.ITDD,
					'ITDDLength':self.ITDDLength,
					'initV':self.initV,
					'value':self.strategy.broker.getvalue(),
					'peak':self.peak,
					'ddlen':self.ddlen,
					'dd':self.dd}
		return ITDDSet

For SizingStra, it is a simple strategy to buy and sell. One point to note is that the BuyPrice and SellPrice were pre-recorded in previous WFA simulation (tf or tradeFeed in below code). It has its own buy/sell price instead of bar open/close bar price particularly when strategy has trail stop that is NOT using bar close price to close the transaction in previous trading. I did it on purpose giving I want to have monte on my trade results. I extracted the most important part for your reference as well.

	def __init__(self,targetRatio,tradeFeed):
		self.historicOrder=[] 
		self.totalCommission=0 # This is to record total commission paid in simulation
		self.o=dict()  # orders per data (main, stop, limit, manual-close)
		self.targetRatio = targetRatio #Target ratio is to calculate the fraction
		self.tf= tradeFeed

	def next(self):
		self.analyzers.contITDD.CalculateITDD()
		if (self.tf.ix[self.datas[0].datetime.datetime()]['BuyPrice'])>0:
			PValue=self.broker.getvalue()
			calSize=int(PValue*self.targetRatio/self.datas[0].open[0])
			targetSize=max(calSize,0)
			BuyPrice = self.tf.ix[self.datas[0].datetime.datetime()]['BuyPrice']
			oneSimLogger.debug('PValue:{}, TargetSize:{}, BuyPrice:{}'.format(self.broker.getvalue(),targetSize,BuyPrice))
			self.o = [self.buy(data=self.datas[0],exectype=bt.Order.Limit, size=targetSize,price=BuyPrice)]
		elif (self.tf.ix[self.datas[0].datetime.datetime()]['SellPrice'])>0:
			pos = self.getposition(self.data).size
			SellPrice = self.tf.ix[self.datas[0].datetime.datetime()]['SellPrice']
			oneSimLogger.debug('PValue:{}, TargetSize:{}, SellPrice:{}'.format(self.broker.getvalue(),pos,SellPrice))
			self.o = [self.sell(data=self.datas[0],size=pos,exectype=bt.Order.Stop,price=SellPrice)]

Credit to CAR25 by Howard Bandy. I think Howard provides a good way to measure the required fraction (sizing) for any stock simulation.
I have created the monte carlos as Howard Bandy mentioned in his book. Hope it helps BT-ers as a quick start to have the Monte Carlos simulation. :)

Figures as follow:
I have randomly distributed the trade and set the data started as 1-1-1990. It will need some entry and exit price in your previous trade record as reference point. It will adjust the monte['fraction'] according to the simulated DD90 value.

Code as follow:

def runOneMonte(_,row,consoFeeds,monte,params):
	stockName,exchange,indName=row[:3]
	cerebro = bt.Cerebro()
	cerebro.broker.setcash(100000)
	simParams={'stockName':stockName,'exchange':exchange,'indicator':indName}
	#analyzer
	cerebro.addanalyzer(continueITDDAnalyzer,_name='contITDD')
	#addCommission
	IB = params['commission'](commission=0.0)
	cerebro.broker.addcommissioninfo(IB)
	#SetBroker
	cerebro.broker.set_checksubmit(False)

	#Shuffle and reindex Data
	#random.seed(1)
	datas=list(itertools.chain.from_iterable(itertools.repeat(consoFeeds,max(int(monte['tradeTime']/len(consoFeeds)),1))))
	shuffledDatas=random.sample(datas, len(datas))
	barlen = sum(len(f)-1 for f in shuffledDatas)
	consoFeed=pd.concat(shuffledDatas)
	mcIndex=pd.date_range(start=datetime.datetime.strptime('1990-01-01','%Y-%m-%d'),periods=len(consoFeed),freq='D')
	consoFeed.set_index(mcIndex,drop=True,inplace=True)
	_feed=bt.feeds.PandasData(dataname=consoFeed[['open','high','low','close','volume']])
	cerebro.adddata(_feed,name=stockName)
	tradeFeed = consoFeed[['BuyPrice','SellPrice']]
	cerebro.addstrategy(sizingStra, monte['fraction'],tradeFeed)
	cerebro.strats[0][0][0].contITDDSet={'ITDD':0,'ITDDLength':0,'initV':100000,'peak':float('-inf'),'ddlen':-1,'dd':0}
	strategies=cerebro.run()
	contITDDSet=strategies[0].analyzers.contITDD.get_analysis()
	contITDDSet['CARReturn']=(cerebro.broker.getvalue()/contITDDSet['initV'] - 1)*100*252/barlen
	return contITDDSet

def calculateDD90(row,params,monte,consoFeeds,q,loopRound=6):
	stockName=row.Index
	masterLogger=logging.getLogger('Master')
	loopTime=0
	while loopTime<loopRound:
		_prevFraction=0
		_loopCount=0
		if params['numMulti'] >1:
			print('{}-{}: Start Pooling with Monte fraction:{}'.format(stockName,row.indicator, monte['fraction']))
			pool = multiprocessing.Pool(params['numMulti'], worker_init, [q])
			#Run 1000 monte carlos
			startTime=datetime.datetime.now()
			with pool as p:
				simResSet=pd.DataFrame.from_dict(pool.starmap(runOneMonte,zip(range(0,monte['NumberSim']),itertools.repeat(list(row)),itertools.repeat(consoFeeds),itertools.repeat(monte),itertools.repeat(params))))
			pool.close()
			pool.join()
			timeRequired=datetime.datetime.now()-startTime
			print('{}-{}: Loop Time required for runOneMonte:{}'.format(stockName,row.indicator,timeRequired))
		else:
			print('{}:Start Single Thread Simulation'.format(stockName))
			simResSet = pd.DataFrame([runOneMonte(i,list(row), consoFeeds,monte,params) for i in range(0,monte['NumberSim'])])
		DD90 = np.quantile(simResSet['ITDD'] , 0.9, interpolation='nearest')
		DD90 = simResSet[simResSet['ITDD']==DD90].to_dict(orient='records')[0]
		print('{}-{}:Test Result: Fraction ={}, DD90={}, CAR25={}'.format(stockName,row.indicator,monte['fraction']*100,DD90['ITDD'],DD90['CARReturn']))
		if abs(monte['drawdownLimit'] - DD90['ITDD']) < monte['accuracyTolerance'] or abs(monte['fraction'] - _prevFraction) < 0.01 or _loopCount >5:
			return DD90
		else:
			_prevFraction = monte['fraction']
			_loopCount+=1
			monte['fraction']=monte['fraction']*monte['drawdownLimit']/(DD90['ITDD'])
			if monte['fraction']>1 :
				print('Overwhelming sizing Occurred')
				return DD90
		loopTime+=1
	return DD90

def setMonte(row,params,monte):
	#Read Order time and Trade Price and prepare the feeds, dont follow below script as it is minimized
	consoFeeds=[]
	for record in records:
		consoFeeds.append(consoFeed)

	#Multi-processing
	_stockStartTime=datetime.datetime.now()
	DD90=calculateDD90(row,params,monte,consoFeeds,q)
	timeRequired=datetime.datetime.now()-_stockStartTime
	print('{}: Total Loop Time required:{}\n================================='.format(row.Index,timeRequired))
	DD90.update({'fraction':monte['fraction'],'stockName':row.Index,'exchange':row.exchange,'indicator':row.indicator})
	return DD90

One more interesting bug:
When trying to download IB historical with fromdate older than the stock start date.
I.e. RWGV first trading day start with 18 Jan 2019 and i tried to use following code:

data = ibstore.getdata(dataname='RWGV',
                        currency='USD',
                       exchange='ARCA',
                        historical=True,
                        timeframe=bt.TimeFrame.Days,
                        fromdate=datetime.datetime(2016, 5, 1),
                        todate=datetime.datetime(2019,6, 1))

This code will have no data downloaded instead download data from 18 Jan - 1 Jun 2019.

Tried to download data using IBStore, it can download historical minutes data start with 30 May 2019 but fail if start with 31 May 2019. @backtrader appreciate if you can take a look below, thanks!

#use demo account, port=7497
ibstore=bt.stores.IBStore(port=7497)
cerebro = bt.Cerebro()
stockName='SPY-STK-ISLAND-USD'
data = ibstore.getdata(dataname=stockName,
                    historical=True,
                    timeframe=bt.TimeFrame.Minutes,
                    compression=60,
                    fromdate=datetime.datetime(2019, 5, 31),
                    todate=datetime.datetime(2019,6, 25))
cerebro.adddata(data,name=stockName)
cerebro.run()

Below is the error message:

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-11-00a260357ba9> in <module>()
     15                     todate=datetime.datetime(2019,6, 25))
     16 cerebro.adddata(data,name=stockName)
---> 17 cerebro.run()
     18 '''
     19     if len(data)>0:

/usr/local/lib/python3.7/site-packages/backtrader/cerebro.py in run(self, **kwargs)
   1125             # let's skip process "spawning"
   1126             for iterstrat in iterstrats:
-> 1127                 runstrat = self.runstrategies(iterstrat)
   1128                 self.runstrats.append(runstrat)
   1129                 if self._dooptimize:

/usr/local/lib/python3.7/site-packages/backtrader/cerebro.py in runstrategies(self, iterstrat, predata)
   1208                 if self._exactbars < 1:  # datas can be full length
   1209                     data.extend(size=self.params.lookahead)
-> 1210                 data._start()
   1211                 if self._dopreload:
   1212                     data.preload()

/usr/local/lib/python3.7/site-packages/backtrader/feed.py in _start(self)
    201 
    202     def _start(self):
--> 203         self.start()
    204 
    205         if not self._started:

/usr/local/lib/python3.7/site-packages/backtrader/feeds/ibdata.py in start(self)
    400         if self._state == self._ST_START:
    401             self._start_finish()  # to finish initialization
--> 402             self._st_start()
    403 
    404     def stop(self):

/usr/local/lib/python3.7/site-packages/backtrader/feeds/ibdata.py in _st_start(self)
    627                 timeframe=self._timeframe, compression=self._compression,
    628                 what=self.p.what, useRTH=self.p.useRTH, tz=self._tz,
--> 629                 sessionend=self.p.sessionend)
    630 
    631             self._state = self._ST_HISTORBACK

/usr/local/lib/python3.7/site-packages/backtrader/stores/ibstore.py in reqHistoricalDataEx(self, contract, enddate, begindate, timeframe, compression, what, useRTH, tz, sessionend, tickerId)
    707         duration = None
    708         for dur in durations:
--> 709             intdate = self.dt_plus_duration(begindate, dur)
    710             if intdate >= enddate:
    711                 intdate = enddate

/usr/local/lib/python3.7/site-packages/backtrader/stores/ibstore.py in dt_plus_duration(self, dt, duration)
   1174             month = dt.month - 1 + size  # -1 to make it 0 based, readd below
   1175             years, month = divmod(month, 12)
-> 1176             return dt.replace(year=dt.year + years, month=month + 1)
   1177 
   1178         if dim == 'Y':

ValueError: day is out of range for month

@Mar-Co This is what I have done for the WFA. Its hard but fun. :)

def createWFAReport(simParams,simulations):
	#Create simulation report format
	reportColumns=['grossProfit','grossAverageProfit','maxProfit',
				   'grossLoss','grossAverageLoss','maxLoss',
				   'netProfit','averageNetProfit','NAR',
				   'recoveryFactor','MDDLength','MDD',
				   'wonTrade','lossTrade','tradingTime',
				   'averageTradeTime','TradeNumber','maxValue',
				   'minValue','totalCommission']
	simulationReport=pd.DataFrame(columns=reportColumns)

	#Loop Simulations to create summary
	for simulation in simulations:
		'''some Calculation is done here'''
	return simReport

def WFASplit(self,trainBy='12m',testBy='3m', loopBy='m',overlap=True):
	startDate=self.index[0]
	endDate=self.index[-1]
	if trainBy[-1] is 'm':
		trainTime=relativedelta(months=int(trainBy[:-1]))
	else:
		raise ValueError
	if testBy[-1] is 'm':
		testTime=relativedelta(months=int(testBy[:-1]))
	else:
		raise ValueError
	assert ((relativedelta(endDate,startDate)-trainTime).days) > 0

	if loopBy is 'm':
		test_starts = zip(rrule(MONTHLY, dtstart=startDate, until=endDate-trainTime,interval=int(testBy[:-1])))
	else:
		raise ValueError

	for i in test_starts:
		startD=i[0]
		endD=i[0]+trainTime
		yield (self[(self.index>=startD)&(self.index<endD)],
			  self[(self.index>=endD)&(self.index<endD+testTime)])
	return None

def runTrain(trainTestGenerator,_ind,stockName):
	WFATrainResult=[]
	for train,test in trainTestGenerator:
		logger.debug('{} Training Data:{} to {}'.format(stockName,pd.DatetimeIndex.strftime(train.head(1).index,'%Y-%m-%d'),pd.DatetimeIndex.strftime(train.tail(1).index,'%Y-%m-%d')))
		#Generate Indicator ResultSet
		trainer = bt.Cerebro(cheat_on_open=True, stdstats=False, optreturn=False)
		trainer.broker.set_cash(10000)
		#Add Commission
		IB = params['commission'](commission=0.0)
		trainer.broker.addcommissioninfo(IB)
		#Below Analyzer are used to calculate the Recovery Ratio
		trainer.addanalyzer(btanalyzers.TradeAnalyzer, _name='TradeAn')
		trainer.addanalyzer(recoveryAnalyzer,timeframe=params['analysisTimeframe'], _name='recoveryFac')
		trainer.addanalyzer(WFAAn,_name='WFAAna')
		trainer.addanalyzer(btanalyzers.TimeReturn,timeframe=bt.TimeFrame.Months,_name='TR')
		#SetBroker
		trainer.broker.set_checksubmit(False)
		#Copy for tester
		tester = deepcopy(trainer)
		#Optimize Strategy
		trainingFile='{}/WFA'
		trainer.optstrategy(trainingIdea,
							inOrOut=(params['inOrOut'],),
							selfLog=(params['selfLog'],),
							indName=(row.indicator,),
							indFormula=(_ind['formula'],),
							entryExitPara=(_ind['entryExitParameters'],),
							indOutName=(_ind['indValue'],),
							nonOptParams=(None,),
							resultLocation=(params['resultLocation'],),
							timeString=(params['timeString'],),
							market=(row.market,),
							**optt)
		trainData = bt.feeds.PandasData(dataname=train)
		# Add a subset of data.
		trainer.adddata(trainData)
		optTable = trainer.run()
		final_results_list = []
		for run in optTable:
			for x in run:
				x.params['res']=x.analyzers.WFAAna.get_analysis()
				final_results_list.append(x.params)

		_bestWFA=pd.DataFrame.from_dict(final_results_list,orient='columns').sort_values('res',ascending=False).iloc[0].to_dict()
		bestTrainParams = {key: _bestWFA[key] for key in _bestWFA if key not in ['market','inOrOut','resultLocation','selfLog','timeString','res']}
		bestTrainParams=pd.DataFrame(bestTrainParams,index=[0])
		bestTrainParams['trainStart']=train.iloc[0].name
		bestTrainParams['trainEnd']=train.iloc[-1].name
		bestTrainParams['testStart']=test.iloc[0].name
		bestTrainParams['testEnd']=test.iloc[-1].name
		WFATrainResult.append(bestTrainParams)
	WFATrainResult=pd.concat(WFATrainResult)
	return WFATrainResult

def runTest(params, WFATrainResult,_ind,datafeed,stockName):
	#Generate Indicator ResultSet
	tester = bt.Cerebro(cheat_on_open=True)
	tester.broker.set_cash(10000)
	#Add Commission
	IB = params['commission'](commission=0.0)
	tester.broker.addcommissioninfo(IB)
	#SetBroker
	tester.broker.set_checksubmit(False)
	logger.debug('{} Start Testing'.format(stockName))
	OneSimHandler=logging.FileHandler(filename='{}/simulation/{}_{}_test.log'.format(params['resultLocation'], str(stockName),str(row.indicator)))
	OneSimHandler.setLevel(logging.DEBUG)
	OneSimHandler.setFormatter(logging.Formatter("%(asctime)s:%(relativeCreated)d - %(message)s"))
	oneLogger.addHandler(OneSimHandler)
	tester.addstrategy(trainingIdea,
			inOrOut=params['inOrOut'],
			selfLog=params['selfLog'],
			indName=row.indicator,
			indFormula=_ind['formula'],
			entryExitPara=_ind['entryExitParameters'],
			indOutName=_ind['indValue'],
			nonOptParams=None,
			resultLocation=params['resultLocation'],
			timeString=params['timeString'],
			market=market,
			WFATestParams=WFATrainResult)
	data=bt.feeds.PandasData(dataname=datafeed)
	tester.adddata(data,name=stockName)
	#Add analyzers for Tester
	tester.addanalyzer(btanalyzers.DrawDown, _name='MDD')
	tester.addanalyzer(btanalyzers.TradeAnalyzer, _name='TradeAn')
	tester.addanalyzer(btanalyzers.SQN, _name='SQN')
	tester.addanalyzer(recoveryAnalyzer,timeframe=params['analysisTimeframe'], _name='recoveryFac')
	tester.addanalyzer(ITDDAnalyzer,_name='ITDD')
	tester.addanalyzer(simpleAn,_name='simpleAna')
	tester.addanalyzer(btanalyzers.TimeReturn,timeframe=bt.TimeFrame.Months,_name='TR')
	# Run and Return Cerebro
	cere=tester.run()[0]

	_report=cere.analyzers.simpleAna.writeAnalysis(bnhReturn)
	oneLogger.removeHandler(OneSimHandler)
	if params['plotGraph']:
		plotSimGraph(tester,params,stockName,row.indicator)
	return _report

if __name__ == "__main__":
	session='WinsWFAProd'
	stockList, indicatorDict, params = jsonConfigMap(session)
	params['timeString']='0621_113833'
	params['topResult']=pd.read_csv('{}{}/consoReport.csv'.format(params['resultLocation'],params['timeString']),index_col=0)
	params['resultLocation']+=params['timeString']+'/WFA'
	simulations=[]

	try:
	#Create Folder
		shutil.rmtree(params['resultLocation'])
	except FileNotFoundError :
		pass
	except PermissionError:
		pass
	os.makedirs(params['resultLocation'],exist_ok=True)
	for element in ['order','trade','mr','ohlc','simulation','bestTrain','graph']:
		os.makedirs(params['resultLocation']+'/'+element,exist_ok=True)
	#Create master Log
	handler = logging.FileHandler(filename='{}/Master.log'.format(params['resultLocation']))
	handler.setFormatter(logging.Formatter('%(asctime)s:%(name)s - %(levelname)s {}- %(message)s'))
	logger = logging.getLogger()
	logger.setLevel(logging.DEBUG)
	logger.addHandler(handler)
	#Create OptReport Log
	reportHandler = logging.FileHandler(filename='{}/optReport.csv'.format(params['resultLocation']))
	reportHandler.setFormatter(logging.Formatter('%(message)s'))
	reportHandler.setLevel(logging.INFO)
	reportLogger=logging.getLogger('report')
	reportLogger.addHandler(reportHandler)
	simResultColumns=['stockName','market','indicator',
					'grossProfit','grossAverageProfit','maxProfit',
					'grossLoss','grossAverageLoss','maxLoss',
					'netProfit','averageNetProfit','NAR','profitFactor',
					'recoveryFactor','MDDLength','MDD',
					'selfMDD','winRate','tradingTimeRatio',
					'averageTradingBar','tradeNumber','maxValue',
					'minValue','initialv','totalCommission',
					'barNumber','expectancy100','bnhReturn','bnhRatio']
	reportLogger.info(str(simResultColumns).strip("[]").replace("'","").replace(" ",""))

	#Create Simulation Log
	oneLogger=logging.getLogger('oneLogger')
	oneLogger.propagate=False
	postHandler=logging.StreamHandler()
	postHandler.setLevel(logging.INFO)
	if params['selfLog']:
		oneLogger.setLevel(logging.DEBUG)
	else:
		oneLogger.setLevel(logging.INFO)
	oneLogger.addHandler(postHandler)
	#Record Start Time
	startTime=time.time()
	for row in params['topResult'].itertuples():
		simParams=pd.DataFrame(columns=['startTime','endTime','Parameter'])
		indicator=indicatorDict[row.indicator]
		stockName=row.stockName
		market=row.market
		try:
			optt = eval(indicator['optParam'])
		except:
			logger.info('{}: Indicator does not have WFA parameters and skipped'.format(row.indicator))
			continue
		datafeed=feeder(stockName, market,params)
		bnhReturn=round(datafeed.iloc[-1]['close'] - datafeed.iloc[0]['open'],2)
		#Extract Feeder from Data to save time for multi-simulation
		print('Start WFA for {}-{} from {} to {}'.format(stockName,row.indicator,datafeed.iloc[0].name,datafeed.iloc[-1].name))
		trainTestGenerator=WFASplit(datafeed,trainBy='8m',testBy='8m',loopBy='m')
		_ind=indicatorDict[row.indicator]
		#Training
		WFATrainResult=runTrain(trainTestGenerator,_ind,stockName)
		WFATrainResult=pd.DataFrame.from_records(WFATrainResult)
		WFATrainResult.to_csv('{}/bestTrain/{}_{}_train.csv'.format(params['resultLocation'],stockName,row.indicator),index=False)
		#TESTING
		_report=runTest(params, WFATrainResult,_ind, datafeed,stockName)
		#Consolidate T
		if _report[0] is not None:
			reportLogger.info(str(_report).strip("[]").strip(" ").replace(" ","").replace("'",""))
			simulations.append(_report)

#After simulations
	simulations=pd.DataFrame(simulations)
	reportColumns=['stockName','market','indicator',
					'grossProfit','grossAverageProfit','maxProfit',
					'grossLoss','grossAverageLoss','maxLoss',
					'netProfit','averageNetProfit','NAR',
					'profitFactor','recoveryFactor','MDDLength',
					'selfMDD','winRate','tradingTimeRatio',
					'averageTradingBar','tradeNumber','maxValue',
					'minValue','initialv','totalCommission',
					'barNumber','expectancy100','bnhReturn',
					'bnhRatio']
	simulations.columns=reportColumns
	consoResult=cr.scoring(simulations)
	consoResult=consoResult.sort_values(['res'],ascending=False)
	consoResult.sort_values('res').to_csv('{}/optReport.csv'.format(params['resultLocation']),index=False)

	timeRequired=time.time()-startTime
	print('timeRequired={:.2f}s'.format(timeRequired))

Re: JSON data sources

Hi @backtrader ,

Just a follow up on this wonderful idea mixing backtrader+ influxDB +Grafana using Analyzer, here's what I did:

Pre-req:

1.You setup the grafana/influxdb connection, basic stuff like installed Json/influxdb-python blah blah blah.
2. You created a influxdb client and passed to strategy using params
(i.e. self.strategy.params['client'] <==this is the influxdb client object
3. You already created a database called "simulation" to store the simulation result.
4. For the Grafana OHLC bar please take reference here

Feel free to discuss and let me know if you have any great idea on it.
(Btw InfluxDB will have a high cardinality issue if talking about recording a lot of ohlc simulations, talking about 10k~ up with 16gb ram will be overflow, im thinking should i remove the candlestick instead...)

from __future__ import (absolute_import, division, print_function,
					unicode_literals)

import backtrader as bt
import pandas as pd
from influxdb import DataFrameClient

class GrafanaAn(bt.Analyzer):

def create_analysis(self):
	self.tradeBegV=0
	self.tradeEndV=0

def notify_trade(self, trade):
	t=self.datas[0].datetime.date(0).strftime('%Y-%m-%dT%H:%M:%SZ')
	if trade.justopened:
		self.tradeBegV=self.strategy.broker.getvalue()
		self.tradeBegTime=t
		self.tradeBegP=float(trade.price)
		self.tradeSize=float(trade.size)
		#Send a buy indicator to Grafana
		jsonBody=[{"measurement":"portfolio",
					"tags":{
					"stock":self.data._name,
					"market":self.strategy.params['market'],
					"ind":self.strategy.indName
					},
					"time":t,
					"fields":{
						"BuyPrice":float(trade.price),
						"Size":float(trade.size),
				}
				  }]
		ar=self.strategy.params['client'].write_points(jsonBody,database='simulation')
		assert ar
	elif trade.status == trade.Closed:
		self.tradeEndV = self.strategy.broker.getvalue()
		ret=(self.tradeEndV/self.tradeBegV-1)*100
		t=self.datas[0].datetime.date(0).strftime('%Y-%m-%dT%H:%M:%SZ')
		jsonBody=[{"measurement":"trade",
					"tags":{
					"stock":self.data._name,
					"market":self.strategy.params['market'],
					"ind":self.strategy.indName
					},
					"time":t,
					"fields":{
						"commission":float(trade.commission),
						"return":float(ret),
						"pnl":float(trade.pnl),
						"pnlcomm":float(trade.pnlcomm),
						"tradingTime":int(trade.barlen),
						"beginTime":self.tradeBegTime,
						"endTime":t
					}
				  }]
		ar=self.strategy.params['client'].write_points(jsonBody,database='simulation')
		assert ar
		jsonBody=[{"measurement":"portfolio",
					"tags":{
					"stock":self.data._name,
					"market":self.strategy.params['market'],
					"ind":self.strategy.indName
					},
					"time":t,
					"fields":{
						"SellPrice":float(trade.pnl/self.tradeSize+self.tradeBegP),
						"Size":float(trade.size),
				}
				  }]
		ar=self.strategy.params['client'].write_points(jsonBody,database='simulation')
		assert ar
		
def start(self):
	self._i=0
	self._dict={}

def next(self):
	_value=self.strategy.broker.getvalue()
	_pos=self.strategy.getposition().size
	self._dict[self._i]={'portv':_value,'pos':_pos}
	self._i+=1
	#for k,ind in self.strategy.ind.items():

def stop(self):
	portVFrame=pd.DataFrame.from_dict(self._dict,"index")
	portVFrame.columns=['portv','pos']
	priceFrame=self.data._dataname
	portVFrame.set_index(priceFrame.index,inplace=True)
	priceFrame['portv']=portVFrame['portv']
	priceFrame['pos']=portVFrame['pos']
	priceFrame=priceFrame.astype(float)
	client=DataFrameClient(database='simulation')
	ar=client.write_points(priceFrame,"portfolio",{"ind":self.strategy.indName,"market":self.strategy.params['market'],"stock":self.data._name},database='simulation')
	assert ar
	#Print Monthly return
	_mr=self.strategy.analyzers.TR.get_analysis()
	MonthlyReport=pd.DataFrame.from_dict(_mr,"index")
	ar=client.write_points(MonthlyReport,"monthlyReturn",{"ind":self.strategy.indName,"market":self.strategy.params['market'],"stock":self.data._name},database='simulation')
	assert ar

def get_analysis(self):
	return None

'''

Great design! Friendly reminders:

1. Change commission to abs(commission) avoid sell/short results a negative commission...(and you know the consequence)

2. This commission does not include the cost of exchange (I.e nasdaq/amex). Additional mapping or charges are needed

Ref: https://www.interactivebrokers.com.hk/en/index.php?f=commission&p=stocks2#02

@robin-dhillon said in About Commission:

order.executed.comm

Thanks Robin, I did some further studies on how to store the commission info. Turns out the easiest way is to use notify_trade nicely.

https://community.backtrader.com/topic/950/print-trade-simple-question/11

I guess you are having a similar margin problem as my previous post. Hope it helps.

https://community.backtrader.com/topic/1611/having-margin-problem-when-reversing-the-position-using-order_target_percent

Hi Admin,

I would like to get an analyzer to get overall commission in the strategy.
Tried to look into internet and manual but no luck, nearest one i find is the get_analysis but seems it does not provide such info. Not sure anyway i can do it?