python - ORM: Invoices. What is the v14 equivalent of compute_taxes from v10?

Question

What is the V14 equivalent of function compute_taxes() from V10 which is is used in other module to compute the taxes on a fresh invoice created. Thanks.

 def compute_taxes(self):
        """Function used in other module to compute the taxes on a fresh invoice created (onchanges did not applied)"""
        account_invoice_tax = self.env['account.invoice.tax']
        ctx = dict(self._context)
        for invoice in self:
            # Delete non-manual tax lines
            self._cr.execute("DELETE FROM account_invoice_tax WHERE invoice_id=%s AND manual is False", (invoice.id,))
            if self._cr.rowcount:
                self.invalidate_cache()

            # Generate one tax line per tax, however many invoice lines it's applied to
            tax_grouped = invoice.get_taxes_values()

            # Create new tax lines
            for tax in tax_grouped.values():
                account_invoice_tax.create(tax)

        # dummy write on self to trigger recomputations
        return self.with_context(ctx).write({'invoice_line_ids': []})

Answer 1

Yes, I see that architecture in v14 is "a bit" changed (I've just compared codes, never used odoo though).

What you are looking for now is I believe method on line 342 in account_tax.py file:

def compute_all(self, price_unit, currency=None, quantity=1.0, product=None, partner=None, is_refund=False, handle_price_include=True):
    """ Returns all information required to apply taxes (in self + their children in case of a tax group).
        We consider the sequence of the parent for group of taxes.
            Eg. considering letters as taxes and alphabetic order as sequence :
            [G, B([A, D, F]), E, C] will be computed as [A, D, F, C, E, G]

        'handle_price_include' is used when we need to ignore all tax included in price. If False, it means the
        amount passed to this method will be considered as the base of all computations.

    RETURN: {
        'total_excluded': 0.0,    # Total without taxes
        'total_included': 0.0,    # Total with taxes
        'total_void'    : 0.0,    # Total with those taxes, that don't have an account set
        'taxes': [{               # One dict for each tax in self and their children
            'id': int,
            'name': str,
            'amount': float,
            'sequence': int,
            'account_id': int,
            'refund_account_id': int,
            'analytic': boolean,
        }],
    } ..."""

... This method returns something like:

return {
    'base_tags': taxes.mapped(is_refund and 'refund_repartition_line_ids' or 'invoice_repartition_line_ids').filtered(lambda x: x.repartition_type == 'base').mapped('tag_ids').ids,
    'taxes': taxes_vals,
    'total_excluded': sign * total_excluded,
    'total_included': sign * currency.round(total_included),
    'total_void': sign * currency.round(total_void),
}

So I guess you need to alter this method if you wish to implement something custom.