Bank account model implementation in Django
In general this seems fine, easy to read, you seem to be following PEP8, that's excellent.

At first look, this repeated logic in balance and debt jumps in the eye:


@property
def balance(self):
    # ...
    while current_date &lt;= today:
        result -= sum(x.total for x in self.cashing_set.on_date(current_date))
        result -= sum(x.total for x in self.outcome_transfers.on_date(current_date))
        result += sum(x.total for x in self.deposit_set.on_date(current_date))
        result += sum(x.total for x in self.income_transfers.on_date(current_date))
        # ...

@property
def debt(self):
    # ...
    while current_date &lt;= today:
        result += sum(x.total for x in self.cashing_set.on_date(current_date))
        result += sum(x.total for x in self.outcome_transfers.on_date(current_date))
        result -= sum(x.total for x in self.deposit_set.on_date(current_date))
        result -= sum(x.total for x in self.income_transfers.on_date(current_date))
        # ...



My immediate reaction is to extract those summations to a helper method, for example:

def sum_total_transfers(self):
    result = 0
    result -= sum(x.total for x in self.cashing_set.on_date(current_date))
    result -= sum(x.total for x in self.outcome_transfers.on_date(current_date))
    result += sum(x.total for x in self.deposit_set.on_date(current_date))
    result += sum(x.total for x in self.income_transfers.on_date(current_date))
    return result


So that the above methods can reuse that with less duplication:

@property
def balance(self):
    # ...
    while current_date &lt;= today:
        result += self.sum_total_transfers()
        # ...

@property
def debt(self):
    # ...
    while current_date &lt;= today:
        result -= self.sum_total_transfers()
        # ...


On closer look, these assert lines don't look good:


@property
def balance(self):
    assert self.method == self.DEBET
    # ...

@property
def debt(self):
    assert self.method == self.CREDIT
    # ...



These assertions force the callers to check the value of self.method before using these properties,
or to organize the code in a way that ensures that .debt will only be called when self.method == self.CREDIT, otherwise the program would crash.
It would be better to avoid such unwritten rules.

For example, it might be better to have one public property that applies the correct calculation based on the method:

@property
def balance(self):
    if self.method == self.DEBET:
        return self._credit_balance
    return self._debt_balance

@property
def _credit_balance(self):
    assert self.method == self.DEBET
    # ...

@property
def _debt_balance(self):
    assert self.method == self.CREDIT
    # ...


Lastly, "debt" is misspelled in self.DEBET.