Smarter Odoo Fields with Compute and Inverse Methods

Build Dynamic and Editable Odoo Fields

One of Odoo’s most powerful features is its ability to define computed fields. Computed fields allow you to display data dynamically without storing it directly in the database. But sometimes, we need more than just computed values—we need fields that can both calculate and accept manual input. That’s where compute and inverse methods come in.

In this article, we’ll break down how to use these methods effectively, highlight common pitfalls, and walk through real examples to help you build smarter, more responsive fields in Odoo.

What Are Computed Fields?

A computed field is one whose value is automatically calculated based on other fields or business logic. Instead of being entered manually by users, it’s derived.

For example, if you have a sale.order.line model with price_unit and product_uom_qty, you might want a computed field subtotal:


subtotal = fields(Float)(
    string="Subtotal",
    compute="_compute_subtotal",
    store=True
)

Here, the field subtotal is never entered directly; it’s calculated by the system.

The Compute Method

The compute method defines how Odoo calculates a field.

Example

from odoo import models, fields, api
class SaleOrderLine(models.Model):
    _inherit = 'sale.order.line'
    subtotal = fields.Float(
        string="Subtotal",
        compute="_compute_subtotal",
        store=True
    )
    @api.depends('price_unit', 'product_uom_qty')
    def _compute_subtotal(self):
        for line in self:
            line.subtotal = line.price_unit * line.product_uom_qty
Key points
  • The method is decorated with @api.depends, so Odoo knows when to re-calculate.
  • If either price_unit or product_uom_qty changes, Odoo recomputes subtotal.
  • With store=True, the value is stored in the database for reporting and searching.

The Inverse Method

By default, computed fields are read-only. But what if you want users to edit them directly

This is where the inverse method comes in. It tells Odoo how to handle manual updates on a computed field.

Example

discounted_price = fields.Float(
    string="Discounted Price",
    compute="_compute_discounted_price",
    inverse="_inverse_discounted_price",
    store=True
)
discount_percent = fields.Float(
    string="Discount (%)"
)
@api.depends('price_unit', 'discount_percent')
def _compute_discounted_price(self):
    for line in self:
        line.discounted_price = line.price_unit * (1 - (line.discount_percent / 100))
def _inverse_discounted_price(self):
    for line in self:
        if line.price_unit:
            line.discount_percent = 100 - ((line.discounted_price / line.price_unit) * 100)

Now:

  • If you change discount_percent, Odoo computes discounted_price.
  • If you change discounted_price, the inverse method updates discount_percent accordingly.

This creates a two-way synchronisation between fields.

The Search Method

Sometimes, you might also want users to search based on computed fields. Since Odoo does not always store these fields in the database, you can define a custom search method to make them searchable.

Example

total_amount = fields.Float(
    string="Total Amount",
    compute="_compute_total_amount",
    search="_search_total_amount"
)
def _compute_total_amount(self):
    for order in self:
        order.total_amount = sum(order.order_line.mapped('subtotal'))
def _search_total_amount(self, operator, value):
    return [('order_line.subtotal', operator, value)]

With this setup, users can filter or search for records — for instance, orders with total_amount > 1000 — even though total_amount is a computed value.

Best Practices for Compute and Inverse

Always use @api.depends

Without it, Odoo won’t know when to recompute.

Be careful with recursion

If your compute and inverse methods call each other indirectly, you’ll create infinite loops.

Use store=True wisely

Stored computed fields speed up reporting but add extra database writes.

Add readonly=False

If you want users to edit computed fields, make sure they aren’t read-only in the view.

Inverse is optional

Only define it if users need to edit the computed value.

Key Takeaways

The combination of compute, inverse, and search methods makes Odoo fields incredibly flexible. With these tools, you can:

  • Automate calculations across models.
  • Allow two-way editing for smarter user experiences.
  • Enable search ability even on computed values.

Whether you’re building a payroll system, an approval workflow, or a custom pricing engine, mastering these methods will help you design clean, efficient, and user-friendly modules.

Found this article useful?

Explore more development guides and solutions from our team.

Check out more posts

Share

Sign in to leave a comment
How to Print Barcodes in Odoo QWeb Reports
All Supported Formats Explained