@ab_trader true. anyway it's not what I'm looking for as commission is not included into calculation.

One of the latest additions lets you do direct time comparisons directly to lines to generate signals. Probably nobody has used it yet. An example:

class MySignal(bt.Indicator): lines = ('mysignal',) def __init__(self): self.lines.mysignal = self.data.datetime > datetime.time(10, 30)

This generates an indicator which can be used as a signal to only execute orders when the daily time goes over 10:30.

But since you are probably looking for day, you'll need to work it out in the next method comparing the self.data.datetime.date() (maybe even getting the weekday) against something of your choosing

You can use it without being merged. Again, see: Community - EoDevelopment 1.x

@Harel-Rozental said in Smart optimizations and Backtrader:

I managed to get my optimizations to run as quick as optstrategy by subclassing Cerebro and pulling out some stuff out of run() and addstrategy() into different functions (one to initialize data loading, and another which gets re-executed from outside the class for optimization).
I also manage multiprocessing from the outside.

Do you mind to share some code? Or kind of a layout of what and where was implemented in more details?

@ab_trader - I am doing my best. I have already submitted pull requests for new Fisher Transform indicator and Simulated Order. And I am sharing all my code snippets here along with explanations whenever relevant.

When I say the framework should have this or that, I dont mean that someone should implement them but that we shall implement it for everybody's benefit.

@amit Have a look here for highest and lowest.

@ab_trader DRo = Daniel Rodriguez for those that didn't immediately get, it took me a few secs :)

@ab_trader If I can use the fractal indicator to reference the true/false for any candle, like fractal[-14] to find out if 14 candles back was a high or low, then it will work, because I have to be able to get the high/low value from the fractal, not just knowing whether or not it is. I'll mess around with it, definitely looks cleaner than my method lol.

Hi,

i do like this, as suggested by @backtrader: I preprocess all my securities data including as an extra column their membership status. I do this while creating the survivorship bias free dataset.

In 'next' I look for it as it is another indicator. If True I trigger a EW target buy order otherwise a 0% target sell order.

@vladisld said in Rollover multiple contracts [help needed]:

@chewbacca said in Rollover multiple contracts [help needed]:

File "/home/user/PycharmProjects/backtrader/Strategies/VixLive.py", line 615, in notify_timer
self.initial_position = self.position.size
File "/home/user/PycharmProjects/backtrader/venv/lib/python3.8/site-packages/backtrader/lineseries.py", line 461, in _ _ getattr _ _
return getattr(self.lines, name)
AttributeError: 'Lines_LineSeries_LineIterator_DataAccessor_Strateg' object has no attribute 'position'

The error backtrace above seems strange. Accessing the position property in the strategy should call the bt.Strategy's getposition method:

class Strategy: ... def getposition(self, data=None, broker=None): data = data if data is not None else self.datas[0] broker = broker or self.broker return broker.getposition(data) position = property(getposition)

This should be reflected in the error backtrace. It looks like the self.position was called from the indicator and not from the strategy.

It could be useful to if you could share the whole VixLive.py code?

By default data0 is used as the "primary", correct?
vx2_1_min = cerebro.rolloverdata(*rollfeeds_vx2_minute, **rollkwargs_vx2_minute) -- is data0 since it's called & added first.

Correct me if I'm wrong..

@Laurent-Michelizza Thank you very much! when I log the position,I also find this question and use almost your way to solve it.
But in the future,I guess,we do a auto-close function when the future expires, it is more easy to use. After this four times reading the source code,I maybe try this function.

@run-out

Thanks again for the long reply!
I just tried cheat on open, but the result is the same.
I thought about including a buy margin and it seems this is the way to go... for that example...
Hence, i assume the orders are not done by theirs reference numbers otherwise order 75 would not be canceled?

Best

I do this as follows:
class MyStrategy(bt.Strategy):
params = (('short', 5), ('long', 10))
def init(self):
self.inds = dict()
for i, d in enumerate(self.datas):
self.inds[d] = dict()
self.inds[d]['sma_s'] = bt.indicators.MovingAverageSimple(d.close, period=self.params.short)
self.inds[d]['sma_l'] = bt.indicators.MovingAverageSimple(d.close, period=self.params.long)
self.inds[d]['start_time'] = d.datetime.date(self.params.long)
self.inds[d]['start_flag'] = 0

def prenext(self):
for i in range(3):
if self.datas[i].datetime.date() == self.inds[self.datas[i]]['start_time']:
self.inds[self.datas[i]]['start_flag'] = 1
log_str = log_str + 'i={}, date={}, sma_s={}, sma_l={}\n'.format(i, self.datas[i].datetime.date(),
self.inds[self.datas[i]]['sma_s'][0],
self.inds[self.datas[i]]['sma_l'][0])
elif self.inds[self.datas[i]]['start_flag'] == 1:
log_str = log_str + 'i={}, date={}, sma_s={}, sma_l={}\n'.format(i, self.datas[i].datetime.date(),
self.inds[self.datas[i]]['sma_s'][0],
self.inds[self.datas[i]]['sma_l'][0])

prenext() process data when time is not the same. If the time is the same, then go to next().

@Giovanni-Caridi said in No trades happened:

I didn't think bad formatting could lead to coding errors

Python is highly space/formatting dependent. Try downloading black formatter. It automatically formats your code and will try to help you if you are off.

@lifeng This is not actually the same problem, but nevertheless it was answered in your other post:
https://community.backtrader.com/topic/3411/data-feed-format/6

Note: Please refrain from asking the same question in different posts next time.

Sure, send me an email. Mine email is in my profile.

@run-out alright... I think I got it!

class Win_Buy(bt.Strategy): params = (("period", 5),) def log(self, txt, dt=None): ''' Logging function fot this strategy''' dt = dt or self.datas[0].datetime.date(0) print('%s, %s' % (dt.isoformat(), txt)) def __init__(self): self.risk = 0.01 self.diff = self.data - self.data(-1) self.win_record = self.data(0) > self.data(-1) self.prob_win = bt.ind.SumN(self.win_record, period=self.p.period) self.prob_loss = self.p.period - self.prob_win self.wins = bt.ind.SumN( bt.If(self.diff >= 0, self.diff, 0), period=self.p.period) self.losses = bt.ind.SumN( bt.If(self.diff <0, -self.diff,0), period=self.p.period) self.avg_win = bt.DivByZero(self.wins, self.prob_win, 0) self.avg_loss = bt.DivByZero(self.losses, self.prob_loss, 0) self.avg_risk = bt.ind.Average(self.data.close*self.risk, period=self.p.period) def next(self): self.dsharpe = self.avg_win[0] / (self.avg_risk[0]) if self.dsharpe > 1: # previous close less than the previous close # BUY, BUY, BUY!!! (with all possible default parameters) self.log('BUY CREATE, %.2f' % self.data[0]) self.buy() else: pass

With Prints...

2018-01-09, c 24.37 diff 0.02, winr 1.00, pwin 3.00, ploss 2.00, wins 0.25, plosses 0.14, avg_win 0.08, avg_loss 0.07, avg_risk 0.24, DSHAREP 0.34 2018-01-10, c 24.25 diff -0.12, winr 0.00, pwin 2.00, ploss 3.00, wins 0.12, plosses 0.26, avg_win 0.06, avg_loss 0.09, avg_risk 0.24, DSHAREP 0.25 2018-01-11, c 24.32 diff 0.07, winr 1.00, pwin 2.00, ploss 3.00, wins 0.09, plosses 0.26, avg_win 0.05, avg_loss 0.09, avg_risk 0.24, DSHAREP 0.18 2018-01-12, c 24.34 diff 0.02, winr 1.00, pwin 3.00, ploss 2.00, wins 0.11, plosses 0.18, avg_win 0.04, avg_loss 0.09, avg_risk 0.24, DSHAREP 0.15 2018-01-15, c 24.40 diff 0.06, winr 1.00, pwin 4.00, ploss 1.00, wins 0.17, plosses 0.12, avg_win 0.04, avg_loss 0.12, avg_risk 0.24, DSHAREP 0.17 2018-01-16, c 24.31 diff -0.09, winr 0.00, pwin 3.00, ploss 2.00, wins 0.15, plosses 0.21, avg_win 0.05, avg_loss 0.11, avg_risk 0.24, DSHAREP 0.21 2018-01-17, c 24.35 diff 0.04, winr 1.00, pwin 4.00, ploss 1.00, wins 0.19, plosses 0.09, avg_win 0.05, avg_loss 0.09, avg_risk 0.24, DSHAREP 0.20

Does this seem right?
Also if I just wanted to use DSharpe as a bt.Indicator would i just change the class from Strategy to Indicator? and the purchase metrics?

@backtrader Yes,you are right!

@vladisld said in How to make Market order valid.:

So if some old bar is stored in the order, and somehow referenced in the future - will it still be in memory at the time of reference? IMHO worth to take a look.

I created a script to check this. I ran a simple moving average from the beginning of the year with period=22 so that the min period would start at the beginning of February. I then made an order with no exit.

Next I added the bar length to the order using self.o.obar = len(self)

Next I ran the script to the end of the year and printed out the self.o.obar and the actual length using len(self).

Then I ran the script using all of the possible variables for exactbars:

With the default False value each and every value stored in a line is kept in memory Possible values: True or 1: all “lines” objects reduce memory usage to the automatically calculated minimum period. If a Simple Moving Average has a period of 30, the underlying data will have always a running buffer of 30 bars to allow the calculation of the Simple Moving Average This setting will deactivate preload and runonce Using this setting also deactivates plotting -1: datas and indicators/operations at strategy level will keep all data in memory. For example: a RSI internally uses the indicator UpDay to make calculations. This subindicator will not keep all data in memory This allows to keep plotting and preloading active. runonce will be deactivated -2: datas and indicators kept as attributes of the strategy will keep all data in memory.

For all input parameters for exactbars the results were the same. The bar length references held steady for the order and the length of the bars run. This would seem to indicate you could use the self.o.obar method to keep track of the starting bar of the order and make use later on in the order's life.

As a side note, I have made extensive use of adding information to orders as attributres when I will need to evaluate that information bar by bar over the order's life. This has been very convenient.

Still digging... looks like this deal is actually the one which may be causing the issue...

It's somehow placing the sell before the first buy:

*** NEW DEAL *** BUYING: size 0.007998528270798173 price 1250.23 DEBUGGING: Size 0 Take Profit Price 0.0 2021-01-07T13:26:00, SELL EXECUTED, Size: -0.04059 Price: 1261.41, Cost: -51.20, Comm 0.00 2021-01-07T13:26:00, BUY EXECUTED, Size: 0.00800 Price: 1250.61, Cost: -10.09, Comm 0.00 DEBUGGING: Size 0.007998528270798173 Take Profit Price 1266.2426249999999 2021-01-07T16:39:00, SELL EXECUTED, Size: -0.00800 Price: 1265.86, Cost: -10.12, Comm 0.00

Given how I have my def next() setup, I am unsure how this is possible...