@borutf
Would agree, looks like a bug:
if self.p.todate is not None:
period2 = (self.p.todate.date() - posix).total_seconds()
urlargs.append('period2={}'.format(int(period2)))
if self.p.todate is not None:
period1 = (self.p.fromdate.date() - posix).total_seconds()
urlargs.append('period1={}'.format(int(period1)))
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.
@kjiessar
Aaaaand 5 minutes later. Trying to fix it, it seems that the issue is something else. Will come back as soon as I found out
Hi,
I know it seems stupid but can happen, that more tan one transaction is triggering at a time.
The bt.analyzers.Transactions will use a map and use the date as key putting in only 1 of the transactions, overriding the beforehand added.
Code Link
def next(self):
[...]
if entries:
self.rets[self.strategy.datetime.datetime()] = entries
This can compromise your analysis, just be aware of it.
Documentation issue:
Custom Schemes
class CommInfo_Fut_Perc_Mult(bt.CommInfoBase):
params = (
('stocklike', False), # Futures
('commtype', bt.CommInfoBase.COMM_PERC), # Apply % Commission
('percabs', True), # pass perc as 0.xx
)
comminfo = CommInfo_Fut_Perc_Mult(
commission=0.001, # 0.1%
mult=10,
margin=2000 # Margin is needed for futures-like instruments
)
cerebro.addcommissioninfo(comminfo)
last line should be:
cerebro.broker.addcommissioninfo(comminfo)
Hi there,
at the end of a run I'm usually take cerebro.broker.get_value() to sort my strategy paramters.
Now I'm givin OptStrategy a try and can't find the value for each strategy.
If not any preferred way to implement it? E.g. an Analyzer seems a bit overkill.
@kjiessar
Ok tested a bit around.
New assumption: Stupid me forgot to include the commision fees.
That meens i got enoug money for the share to buy but as the fees will be added to the price, I will not get as much as I ordered, because it is downsized as much as needed, to pay the fee.
Correct?
Hi there,
I'm struggling a bit withthe Order.Margin. So here are is my base assumption:
Order.Margin is the status, when:
remaining_cash - all( open_orders size * prize) < 0
Some of my cash is "blocked" because i have open orders and the "free" cash is not enough to "block" enough cash for the new order.
If thats correct, is there an api call that gives me the remaining "free" cash aka margin(?)?
Done:
https://github.com/backtrader2/backtrader/issues/65
Not that good at filling those, so hope it is enough like that.
@borutf
Would agree, looks like a bug:
if self.p.todate is not None:
period2 = (self.p.todate.date() - posix).total_seconds()
urlargs.append('period2={}'.format(int(period2)))
if self.p.todate is not None:
period1 = (self.p.fromdate.date() - posix).total_seconds()
urlargs.append('period1={}'.format(int(period1)))
Hi everybody,
sorry if this is noob question but I'm struggeling with getting the value (is that called portfolio value?) after a run.
I'm currently using cerebro.broker.get_value() as I can also see it my plots
The small values are because cryptotrading data is used.
So my issue here is:
I'm starting with 0.0019 BTC here and buy some other crypto.
Even if this other crypto drops to nearly 0, lets just say the remaing complete value of my portfolio is 0.000000001BTC.
If I sell it (so adding the remaining value), it should still have remaining cash +0.000000001BTC
It seems that I'm still missinterpreting something here.
Another topic: why is my plot so damn ugly compared to the on in the docs? (can create another thread if it isn't a short answer)
are you sure on that?
exectype=bt.Order.Market
could you try to omit the exectype and try again?