# Commissions: Credit

In some situations, the cash amount in real brokers may be decreased because the operation on assets includes an interest rate. Examples:

• Short selling of stocks

• ETFs both long and short

The charge goes directly against the cash balance in the broker account. But it can still be seen as part of a commission scheme. And as such it has been modeled in backtrader.

The `CommInfoBase` class (and with it also the `CommissionInfo` main interface object) has been extended with:

• Two (2) new parameters that allow setting the interest rate and determining if should be applied only to the short side or to both long and short

## Parameters

• `interest` (def: `0.0`)

If this is non-zero, this is the yearly interest charged for holding a short selling position. This is mostly meant for stock short-selling

The default formula applied: `days * price * size * (interest / 365)`

It must be specified in absolute terms: 0.05 -> 5%

Note

the behavior can be changed by overriding the method: `get_credit_interest`

• `interest_long` (def: `False`)

Some products like ETFs get charged on interest for short and long positions. If ths is `True` and `interest` is non-zero the interest will be charged on both directions

## The formula

The default implementation will use the following formula:

```days * abs(size) * price * (interest / 365)
```

Where:

• `days`: number of days elapsed since position was opened or the last credit interest calculation took place

## Overriding the formula

In order to change the formula subclassing of `CommissionInfo` is needed. The method to be overridden is:

```def _get_credit_interest(self, size, price, days, dt0, dt1):
'''
This method returns  the cost in terms of credit interest charged by
the broker.

In the case of ``size > 0`` this method will only be called if the
parameter to the class ``interest_long`` is ``True``

The formulat for the calculation of the credit interest rate is:

The formula: ``days * price * abs(size) * (interest / 365)``

Params:
- ``data``: data feed for which interest is charged

- ``size``: current position size. > 0 for long positions and < 0 for
short positions (this parameter will not be ``0``)

- ``price``: current position price

- ``days``: number of days elapsed since last credit calculation
(this is (dt0 - dt1).days)

- ``dt0``: (datetime.datetime) current datetime

- ``dt1``: (datetime.datetime) datetime of previous calculation

``dt0`` and ``dt1`` are not used in the default implementation and are
provided as extra input for overridden methods
'''
```

It might be that the broker doesn’t consider weekends or bank holidays when calculating the interest rate. In this case this subclass would do the trick

```import backtrader as bt

class MyCommissionInfo(bt.CommInfo):

def _get_credit_interest(self, size, price, days, dt0, dt1):
return 1.0 * abs(size) * price * (self.p.interest / 365.0)
```

In this case, in the formula:

• `days` has been replaced by `1.0`

Because if weekends/bank holidays do not count, the next calculation will always happen `1` trading da after the previous calculation