Is there any way to contribute to the (already good) documentation?
I think some images and examples at some point could help to get rid of some of the.... low quality questions (not excluding mine).

If you want to go with writer and don't fear to post-process with pandas you can use this:

from backtrader import WriterBase
import collections
import io
import itertools
import sys
from backtrader.utils.py3 import (map, with_metaclass, string_types,
                                  integer_types)
import backtrader as bt
class WriterPlain(WriterBase):
    '''The system wide writer class.
    It can be parametrized with:
      - ``out`` (default: ``sys.stdout``): output stream to write to
        If a string is passed a filename with the content of the parameter will
        be used.
        If you wish to run with ``sys.stdout`` while doing multiprocess optimization, leave it as ``None``, which will
        automatically initiate ``sys.stdout`` on the child processes.
      - ``close_out``  (default: ``False``)
        If ``out`` is a stream whether it has to be explicitly closed by the
        writer
      - ``csv`` (default: ``False``)
        If a csv stream of the data feeds, strategies, observers and indicators
        has to be written to the stream during execution
        Which objects actually go into the csv stream can be controlled with
        the ``csv`` attribute of each object (defaults to ``True`` for ``data
        feeds`` and ``observers`` / False for ``indicators``)
      - ``csv_filternan`` (default: ``True``) whether ``nan`` values have to be
        purged out of the csv stream (replaced by an empty field)
      - ``csv_counter`` (default: ``True``) if the writer shall keep and print
        out a counter of the lines actually output
      - ``indent`` (default: ``2``) indentation spaces for each level
      - ``separators`` (default: ``['=', '-', '+', '*', '.', '~', '"', '^',
        '#']``)
        Characters used for line separators across section/sub(sub)sections
      - ``seplen`` (default: ``79``)
        total length of a line separator including indentation
      - ``rounding`` (default: ``None``)
        Number of decimal places to round floats down to. With ``None`` no
        rounding is performed
    '''
    params = (
        ('out', None),
        ('close_out', False),

        ('csv', False),
        ('csvsep', ','),
        ('csv_filternan', True),
        ('csv_counter', True),

        ('indent', 2),
        ('separators', ['=', '-', '+', '*', '.', '~', '"', '^', '#']),
        ('seplen', 79),
        ('rounding', None),
    )

    def __init__(self):
        self._len = itertools.count(1)
        self.headers = list()
        self.values = list()

    def _start_output(self):
        # open file if needed
        if not hasattr(self, 'out') or not self.out:
            if self.p.out is None:
                self.out = sys.stdout
                self.close_out = False
            elif isinstance(self.p.out, string_types):
                self.out = open(self.p.out, 'w')
                self.close_out = True
            else:
                self.out = self.p.out
                self.close_out = self.p.close_out

    def start(self):
        self._start_output()

        if self.p.csv:
            # self.writelineseparator()
            self.writeiterable(self.headers, counter='Id')

    def stop(self):
        if self.close_out:
            self.out.close()

    def next(self):
        if self.p.csv:
            self.writeiterable(self.values, func=str, counter=next(self._len))
            self.values = list()

    def addheaders(self, headers):
        if self.p.csv:
            self.headers.extend(headers)
        pass

    def addvalues(self, values):
        print(values)
        if self.p.csv:
            if self.p.csv_filternan:
                values = map(lambda x: x if x == x else '', values)
            self.values.extend(values)

    def writeiterable(self, iterable, func=None, counter=''):
        if self.p.csv_counter:
            iterable = itertools.chain([counter], iterable)

        if func is not None:
            iterable = map(lambda x: func(x), iterable)

        line = self.p.csvsep.join(iterable)
        self.writeline(line)

    def writeline(self, line):
        self.out.write(line + '\n')

    def writelines(self, lines):
        for l in lines:
            self.out.write(l + '\n')

    def writelineseparator(self, level=0):
        sepnum = level % len(self.p.separators)
        separator = self.p.separators[sepnum]

        line = ' ' * (level * self.p.indent)
        line += separator * (self.p.seplen - (level * self.p.indent))
        self.writeline(line)

    def writedict(self, dct, level=0, recurse=False):
        pass

It is the WriterFile, without seperator and with empty writedict.

To answer my own question:

def __init__(self):
    self.PATTERN_CDLHARAMICROSS = bt.talib.CDLHARAMICROSS(self.datas[0].open, self.datas[0].high, self.datas[0].low, self.datas[0].close)
def next(self):
        self.log(self.PATTERN_CDLHARAMICROSS[0])

gives exactly what i wanted. No doubled arrays and limiting the time line makes no sense here if it is applied to the whole line.
Sorry for the stupid question.

@run-out thank you for the insight. What about the website with it's documentation and tutorials?

To answer my own question:

def __init__(self):
    self.PATTERN_CDLHARAMICROSS = bt.talib.CDLHARAMICROSS(self.datas[0].open, self.datas[0].high, self.datas[0].low, self.datas[0].close)
def next(self):
        self.log(self.PATTERN_CDLHARAMICROSS[0])

gives exactly what i wanted. No doubled arrays and limiting the time line makes no sense here if it is applied to the whole line.
Sorry for the stupid question.

If you want to go with writer and don't fear to post-process with pandas you can use this:

from backtrader import WriterBase
import collections
import io
import itertools
import sys
from backtrader.utils.py3 import (map, with_metaclass, string_types,
                                  integer_types)
import backtrader as bt
class WriterPlain(WriterBase):
    '''The system wide writer class.
    It can be parametrized with:
      - ``out`` (default: ``sys.stdout``): output stream to write to
        If a string is passed a filename with the content of the parameter will
        be used.
        If you wish to run with ``sys.stdout`` while doing multiprocess optimization, leave it as ``None``, which will
        automatically initiate ``sys.stdout`` on the child processes.
      - ``close_out``  (default: ``False``)
        If ``out`` is a stream whether it has to be explicitly closed by the
        writer
      - ``csv`` (default: ``False``)
        If a csv stream of the data feeds, strategies, observers and indicators
        has to be written to the stream during execution
        Which objects actually go into the csv stream can be controlled with
        the ``csv`` attribute of each object (defaults to ``True`` for ``data
        feeds`` and ``observers`` / False for ``indicators``)
      - ``csv_filternan`` (default: ``True``) whether ``nan`` values have to be
        purged out of the csv stream (replaced by an empty field)
      - ``csv_counter`` (default: ``True``) if the writer shall keep and print
        out a counter of the lines actually output
      - ``indent`` (default: ``2``) indentation spaces for each level
      - ``separators`` (default: ``['=', '-', '+', '*', '.', '~', '"', '^',
        '#']``)
        Characters used for line separators across section/sub(sub)sections
      - ``seplen`` (default: ``79``)
        total length of a line separator including indentation
      - ``rounding`` (default: ``None``)
        Number of decimal places to round floats down to. With ``None`` no
        rounding is performed
    '''
    params = (
        ('out', None),
        ('close_out', False),

        ('csv', False),
        ('csvsep', ','),
        ('csv_filternan', True),
        ('csv_counter', True),

        ('indent', 2),
        ('separators', ['=', '-', '+', '*', '.', '~', '"', '^', '#']),
        ('seplen', 79),
        ('rounding', None),
    )

    def __init__(self):
        self._len = itertools.count(1)
        self.headers = list()
        self.values = list()

    def _start_output(self):
        # open file if needed
        if not hasattr(self, 'out') or not self.out:
            if self.p.out is None:
                self.out = sys.stdout
                self.close_out = False
            elif isinstance(self.p.out, string_types):
                self.out = open(self.p.out, 'w')
                self.close_out = True
            else:
                self.out = self.p.out
                self.close_out = self.p.close_out

    def start(self):
        self._start_output()

        if self.p.csv:
            # self.writelineseparator()
            self.writeiterable(self.headers, counter='Id')

    def stop(self):
        if self.close_out:
            self.out.close()

    def next(self):
        if self.p.csv:
            self.writeiterable(self.values, func=str, counter=next(self._len))
            self.values = list()

    def addheaders(self, headers):
        if self.p.csv:
            self.headers.extend(headers)
        pass

    def addvalues(self, values):
        print(values)
        if self.p.csv:
            if self.p.csv_filternan:
                values = map(lambda x: x if x == x else '', values)
            self.values.extend(values)

    def writeiterable(self, iterable, func=None, counter=''):
        if self.p.csv_counter:
            iterable = itertools.chain([counter], iterable)

        if func is not None:
            iterable = map(lambda x: func(x), iterable)

        line = self.p.csvsep.join(iterable)
        self.writeline(line)

    def writeline(self, line):
        self.out.write(line + '\n')

    def writelines(self, lines):
        for l in lines:
            self.out.write(l + '\n')

    def writelineseparator(self, level=0):
        sepnum = level % len(self.p.separators)
        separator = self.p.separators[sepnum]

        line = ' ' * (level * self.p.indent)
        line += separator * (self.p.seplen - (level * self.p.indent))
        self.writeline(line)

    def writedict(self, dct, level=0, recurse=False):
        pass

It is the WriterFile, without seperator and with empty writedict.

Is there any way to contribute to the (already good) documentation?
I think some images and examples at some point could help to get rid of some of the.... low quality questions (not excluding mine).

Hi everyone,

what I'm trying to do is getting the last value of pattern recognition as a line. The data that is used in the pattern should be limitted.
My current approach ending in an index error

self.pattern_len =min(len(self.datas[0].open)-1, 10)
self.PATTERN_CDLHARAMICROSS = bt.talib.CDLHARAMICROSS(self.datas[0].open.get(size= self.pattern_len), self.datas[0].high.get(size= self.pattern_len), self.datas[0].low.get(size= self.pattern_len), self.datas[0].close.get(size= self.pattern_len))[-1]

IndexError: array index out of range

I know it could probably be easier by just using the whole length for the pattern and just read the last value from the line.
(Would that mean in every bar/step there would be an complete array of the pattern recognition?)

Is the error, that it tries to establish the value before it has enough values? Why does my approach with min does not work?

Thank you for your explanation
I was reading and found a reference to this post about BarReplayer_Open

https://community.backtrader.com/topic/217/order_target_percent-calculation-problems

Corresponding Blogpost
https://www.backtrader.com/docu/filters-reference/

So is it possible with the BarReplayer_Open to create orders in between open and close?

Thank you that helped a lot.
So in general it looks like this:

There is no way to get in between an open and a close slice. If you want to do that you would need to use a finer granularity, like minutes instead of days. But then there woul again a be open and close.

Hi I'm new and this is my first post.

When next is executed I'm not sure where I'm in the current time.
So the question:

Is next() dataclose[0] in the future?

What I already tried:

def next(self):
        self.log(self.datetime.datetime(ago=0))
        ...

2021-01-30, 2021-01-30 00:00:00
2021-01-30, Close, 34269.52

Dataframe Entry:

Date
2021-01-30    34269.523438
Name: Close, dtype: float64

So it looks lik I'm in 2021-01-30 00:00:00 (morning) and can already access open and close. Close will only be calculatet when market has closed. Does that mean my strategies should not access dataclose[0] because it would be cheating and unrealistic?