[RFC] Ignore missing-return in compute methods

[chienandalu]

Would it be possible to ignore compute methods for the missing-return directive? They aren't meant to return anything and would avoid little absurds like this where the return is just superflous:

    discount = fields.Float(compute="_compute_discount", store=True)

    @api.depends("order_id", "order_id.general_discount")
    def _compute_discount(self):
        if hasattr(super(), "_compute_discount"):
            super()._compute_discount()
        for line in self:
            line.discount = line.order_id.general_discount
        return

[moylop260]

It is not possible for a static checker

I mean, if you are inheriting a compute field method the field could not be defined in the class

I mean, the definition of the field could be

#repositoy1
class MetaClass...
    discount = fields...(compute="_compute_discount")

    def _compute_discount(self):
        ...

#repositoy2
class InhClass...
     _inherit = ...

    def _compute_discount(self):
        ...

The second class there are not a static way to know it is a method declared from fields compute attribute

Even the convention name could not be used since it not even is a fields compute method

See the following examples:

• https://github.com/odoo/odoo/blob/4ff2d0adad267ed8bd2b0f606e1ce324b43194cc/addons/sale_management/models/digest.py#L29
• https://github.com/odoo/odoo/blob/f7127d39637a47c1ecff6206eb9797d116684b64/addons/account_tax_python/models/account_tax.py#L40
• https://github.com/odoo/odoo/blob/5bb6dc115cb3a2d559ff0030be867d1283d2c0d1/addons/sale/models/payment_transaction.py#L182
• https://github.com/odoo/odoo/blob/82a8cdd6f2f04e61bdf188c6a4f93aea5b5d8458/addons/website/models/ir_rule.py#L22
• https://github.com/odoo/odoo/blob/a9708d6c8ab01df901ef7943d7cb4c34f9859826/addons/mrp_account/models/product.py#L52

Notice the name starts with _compute and it has a return

What about returning the original value even if it is returning None?

Check the following cases returning the same original value:

• https://github.com/odoo/odoo/blob/b45d21c550d21b40a9e9947d0374a67265c7a702/addons/purchase_stock/models/stock.py#L232
• https://github.com/odoo/odoo/blob/b45d21c550d21b40a9e9947d0374a67265c7a702/addons/purchase_stock/models/stock.py#L236
• https://github.com/odoo/odoo/blob/34a2948d3d6e0f597c1b5d65f9f118e891c07cc4/addons/product/models/product.py#L482
• https://github.com/odoo/odoo/blob/4bd6f422453ff54b3043217b7a5c85946e48fca5/addons/mrp/models/stock_move.py#L24
• https://github.com/odoo/odoo/blob/335b99d7de36a3fd6dbcaed3f05af646a36a9dcd/addons/sale_stock_margin/models/sale_order_line.py#L29

I mean, in your example

    @api.depends("order_id", "order_id.general_discount")
    def _compute_discount(self):
        res = None
        if hasattr(super(), "_compute_discount"):
            res = super()._compute_discount()
        for line in self:
            line.discount = line.order_id.general_discount
        return res

Also, I think your code is a corner case since it inherits the original method but validating if it exists
And it is overwriting the original value pre-computed in the original method

For these corner cases you can use a disable comment:

• # pylint:disable=...

[pedrobaeza]

This follows the attempt of standardizing the inheritance converting fields to computed writable:

OCA/odoo-community.org#50

[moylop260]

if the field is re-defined in the same class, so it is possible to detect it for the static checker

(Note: The example code in the description of this issue doesn't have the field definition as part of the class in this case it is not possible to detect it)

[pedrobaeza]

Yes, the field should be redefined in the same class for converting it into compute.

[chienandalu]

Thanks for the explanations @moylop260 🙂 👍 We'll adapt to this then

[pedrobaeza]

Well, Moi is saying that it can be put the exception if the field is redefined in the same class, which is the case, so this may worth. Anyway, the debate about using this technique is still around.

[moylop260]

I just updated the main description with the final and real case of use

Using this way it is possible to discard the lint

[chienandalu]

Well, Moi is saying that it can be put the exception if the field is redefined in the same class, which is the case, so this may worth. Anyway, the debate about using this technique is still around.

Oh, sure! I missed that part 🙂 Thanks for reopening Moi.

[luisg123v]

I don't find necessary to consider this case. Even though compute methods are generally not meant to return anything, I don't see why we should restrict that, and returning the super's result is always a good practice.

Regarding the getattr approach, since that technique is kind of a hack, the way to return would also be:

result = None
if hasattr(super(), "_compute_discount"):
    result = super()._compute_discount()
for line in self:
    line.discount = line.order_id.general_discount
return result

Or even:

result = getattr(super(), "_compute_discount", lambda self: None)()
for line in self:
    line.discount = line.order_id.general_discount
return result

Second alternative would even be better than original proposal, as it's better for coverage.

CC @antonag32

[github-actions]

There hasn't been any activity on this issue in the past 6 months, so it has been marked as stale and it will be closed automatically if no further activity occurs in the next 30 days.
If you want this issue to never become stale, please ask a PSC member to apply the "no stale" label.