External blog:

https://backtest-rookies.com/2017/08/22/backtrader-multiple-data-feeds-indicators/

Internal blog:
https://www.backtrader.com/blog/posts/2017-04-09-multi-example/multi-example/

Community post(s):
https://community.backtrader.com/topic/2032/manage-multiple-assets/8

This is just one sample, but there are multiple others - try to search.

Short:

In your class methods you may use self.p and self.params interchangeably - they are actually the same object.
(see the 'Parameters' section in the docs: https://www.backtrader.com/docu/concepts/)

Longer:

One need to distinguish between the params class variable and the self.params (or self.p for that matter) instance variable.

params class variable (list of tuples or dict) defines the custom parameters and their default values that will be later used to "magically" create and populate the self.params (or self.p) instance variable

This self.params (or self.p) instance variable will have members for each tuple originally present in params class variable but their value could be different depending of which parameters where passed during class instantiation ( or have their default values if no matching parameters were passed )

TLDR:

The params class variable may be defined in classes that use MetaParams metaclass (or its derivatives) during their instantiation sequences (like Cerebro, Strategy, Analyzer, BrokerBase, Filter, Indicator, an so on and all their inherited classes ).

During the instantiation the meta-class "hijack" the instantiation sequence and creates additional instance variables (self.p and self.params in particular, but also many others like 'datas', 'data0' and other aliazes for LineSeries inherited classes for example), intializing them in various ways. You may take a look at the with_metaclass method in utils\py3.py for technical details of how this is implemented.

For example one of such meta-classes is MetaParams class which is particularly responsible for creating the self.p and self.params instance variables ( see its donew method )

During your strategy (derived from Strategy class which uses MetaParams meta-class) instantiation process a new auto-generated class (let's call it X) will be used to hold the parameter values. For each tuple in the 'params' class variable there will be a member in X class. The instance of this X class will be created, where each member will get its value either from the parameters passed during the Cerebro.addstrategy call or from the default value in the params class variable tuples.

For example let's assume your strategy params variable defined as:

class SMACrossOver(bt.Strategy):
    params = (
        ('stake', 1),
        ('period', 30),
    )

and you add this strategy to Cerebro using:

cerebro.addstrategy(SMACrossOver, period=15)

The values for 'self.p' members inside your strategy will be:

self.p.stake == 1  # from default value in `params` class variable
self.p.period == 15 # from parameters to cerebro.addstrategy

Yes sir. This is Backtrader framework support forum.

There are other general algo and non-algo trading forums out there:

https://www.reddit.com/r/algotrading/
https://www.elitetrader.com/et/

and many others - just google it.

Probably the same issue as in the following post:

https://community.backtrader.com/topic/3306/signals-stop-showing-after-a-certain-date/2

Note: Please do not post your code as image. See the top of the page for the instructions for posting code in the text form.

It seems the link in the original topic is no longer valid. Here is the updated link: https://www.backtrader.com/blog/2019-05-20-momentum-strategy/momentum-strategy/

Few things:

• Positions are maintained by the broker per data.

• position property of the Strategy class just returns the position of the data[0]. If you need to get the position for the different data, the getposition(data=...) could be used.

Now the problem in the above code seems to be related to the following logic in the next method:

        if not self.position:
            self.log('Buy Created, %.2f ' % (self.dataCloseLong[0]))
            self.order = self.buy(data = self.datas[0],size=1)
        else:
            self.log('Sell Created, %.2f' % self.dataCloseShort[0])
            self.order = self.sell(data = self.datas[1],size=1) 

If we have no position in data[0] then the 'buy' will be issued. Once this 'buy' is completed - the position will be established in data[0].

The next time the next will be called, the position in data[0] is present - so the 'sell' is issued for data[1] ( different data, right ). So the position in data[0] will never be changed from now on.

Please correct me if I'm wrong.

@André-Tavares said in How can I inherit params from a parent class and append on the child class?:

params.update({

No need to update the params dict. The parameters from the base classes are fused automagically by metaclass during the instantiation. You may take a look at the following post as well: https://community.backtrader.com/topic/2379/difference-between-params-and-p/2

Although such a strategy could be easily implemented using the Backtrader framework, the code above has no relation to the framework supported in this forum.

I suggest you start with Backtrader Quickstart Guide and Simple Sample strategy and
continue from there.

@soulmachine said in How to use two CommissionInfo inside a strategy?:

Since data has only one name, so it's not possible to apply multiple commission fees?

You're probably right. AFAIK a single commission could be specified per data name or default. As @run-out correctly mentioned - you may develop your custom commission scheme.

@the-world AFAIK position is maintained by a broker per data and there is just a single broker per Cerebro engine. So in order for multiple strategies to have an independent positions, either they need to work on different datas or they need to be run using different engine instances.

@chen-xu what is the reason not to implement this logic in a single strategy?

@run-out @run-out Just to keep this thread active in hope that Daniel will notice:

The registration seems still to be broken - just got another private email about it ( Dec`19 )

@tianjixuetu ok. One other thing that I've noticed in my experience is the default port number on linux and windows could be different.

So if your code assumes the same port on all platforms - this could be a source of the problem and it worth to check this out.

I

@tianjixuetu As the error said - you should check the "Enable ActiveX and Socket Clients" settings

@run-out Registration process seems not to be functioning once again ( returning 504 Timeout error ).

@duni4i timeframe parameter may be specified during PandasData instantiation:

data = bt.feeds.PandasData(dataname=df,timeframe=...

@adamb032 The next() method runs after a candle has been closed when all final ohlc data for that candle is available.

Does it answer your question?

@jrothschild33 said in How to process data by quarter?:

You have to make sure the data is started on January，or the result will only compression by 3 continuous months, not by quarter.

AFAIU this is the only option right now. Properly solving this should involve extending Backtrader to support yet another TimeFrame with all the ensuing consequences.

Others may correct me of cause.

I've got few emails from people wanted to register on the forum and getting errors while doing so.

Here the example:

 I contact you because I can't finish my registration.
Therefore I can't post in the forum but I would really like to join the community, maybe you can help or connect me with someone? ...

...It seems that a required javascript file for the registration process is not being loaded... 
I don't know if this is on purpose? 
The process fails when I try to consent to the data policies AFTER account creation. 
After buffering for a while I receive a 504 timeout after clicking on "Submit".

I've tried to verify it by registering some temporary account and I'm getting the same error right now (Oct'19 2021)

Hope Daniel will notice this forum post and could fix the issue.

@adarakchian so in both your way and the way I've proposed - the main issue is to replace the array.array with other container.

Using the QBuffer mode seems to be less intrusive way, while in your case the container type is changed forcefully.

In both cases the target seems to be the same: the container type should not make an assumption about the value type used for line data.

One more note: there are some assumptions about the underlying container type inside the LineBuffer - and this is reflected in the LineBuffer.mode ( QBuffer or Unbounded).

Depending on this mode, different methods are used for slicing and other operations inside the LineBuffer methods

Given that, it is important to keep the container type compatible with what LineBuffer logic is expecting IMHO