How to Invoke Python Functions from XML Files in Odoo 19: Complete Developer Guide

Looking to automate tasks during Odoo 19 module installation? The XML <function> tag is your solution. This comprehensive guide explains how to invoke Python functions directly from XML files in Odoo 19, enabling you to execute custom logic, create records, and perform initialization tasks automatically when your module is installed or updated.

Why Invoke Python Functions from XML in Odoo 19?

Odoo's XML-based architecture provides a powerful, declarative approach to defining data models and user interfaces. However, there are scenarios where static XML definitions fall short—particularly when dealing with:

• Dynamic data initialization - Creating records based on complex business logic
• Large or changing datasets - Populating data that can't be hardcoded
• Post-installation updates - Modifying existing records when a module is installed
• Automated setup procedures - Running initialization scripts without manual intervention
• Data migration tasks - Transforming or updating data during module upgrades

The XML <function> tag bridges this gap by allowing you to invoke Python methods at install time, ensuring necessary updates or initialization steps occur automatically during module installation.

Step 1: Setting Up Your XML Data File

To trigger a Python method from an XML file in Odoo 19, you first need to create an XML data file. This file serves as the blueprint for operations that should run automatically when the module is installed.

Create a file named data/init_data.xml in your module directory:

<?xml version="1.0" encoding="UTF-8"?>
<odoo>
    <data noupdate="1">
        <!-- Your function calls and data will go here -->
    </data>
</odoo>

Understanding the noupdate Attribute

The noupdate attribute is crucial for controlling when your data and functions are executed:

Method 1: Calling a Function Without Arguments

The simplest way to invoke a Python function from XML is without passing any arguments. This is useful for initialization tasks that don't require external input.

XML Configuration

<?xml version="1.0" encoding="UTF-8"?>
<odoo>
    <data noupdate="1">
        <function model="res.partner" name="_create_default_partner"/>
    </data>
</odoo>

In this example:

• model="res.partner" - Specifies which Odoo model contains the method
• name="_create_default_partner" - The name of the Python method to invoke

Python Implementation

Create a Python file that inherits the target model and implements the method:

# -*- coding: utf-8 -*-
from odoo import api, models


class ResPartner(models.Model):
    _inherit = "res.partner"

    @api.model
    def _create_default_partner(self):
        """
        Function invoked from XML during module installation.
        Creates a default partner record for initial setup.
        """
        # Check if partner already exists to avoid duplicates
        existing = self.search([('name', '=', 'Default Partner')], limit=1)
        if not existing:
            self.create({
                'name': 'Default Partner',
                'is_company': True,
                'customer_rank': 1,
            })
            return True
        return False

Method 2: Calling a Function With Arguments

For more dynamic scenarios, you can pass arguments to your Python function using the <value> tag within the <function> element.

XML Configuration with Parameters

<?xml version="1.0" encoding="UTF-8"?>
<odoo>
    <data noupdate="1">
        <function model="res.partner" name="_create_partner_with_name">
            <value>Braincuber Technologies</value>
        </function>
    </data>
</odoo>

The <value> tag contains the argument that will be passed to the Python method. You can include multiple <value> tags for functions that accept multiple parameters.

Python Implementation with Parameters

# -*- coding: utf-8 -*-
from odoo import api, models


class ResPartner(models.Model):
    _inherit = "res.partner"

    @api.model
    def _create_partner_with_name(self, partner_name):
        """
        Function invoked from XML with a name parameter.
        Creates a partner record using the provided name.
        
        Args:
            partner_name (str): The name for the new partner record
        
        Returns:
            recordset: The created partner record
        """
        # Validate input
        if not partner_name:
            return False
            
        # Check for existing partner
        existing = self.search([('name', '=', partner_name)], limit=1)
        if existing:
            return existing
            
        # Create new partner
        return self.create({
            'name': partner_name,
            'is_company': True,
            'customer_rank': 1,
        })

Advanced Example: Multiple Parameters

You can pass multiple arguments to a function by including multiple <value> tags:

<?xml version="1.0" encoding="UTF-8"?>
<odoo>
    <data noupdate="1">
        <function model="res.partner" name="_create_company_partner">
            <value>Braincuber Technologies</value>
            <value>contact@braincuber.com</value>
            <value>+1-555-123-4567</value>
        </function>
    </data>
</odoo>

@api.model
def _create_company_partner(self, name, email, phone):
    """
    Create a company partner with full contact details.
    
    Args:
        name (str): Company name
        email (str): Contact email
        phone (str): Contact phone number
    """
    existing = self.search([('email', '=', email)], limit=1)
    if not existing:
        return self.create({
            'name': name,
            'email': email,
            'phone': phone,
            'is_company': True,
            'customer_rank': 1,
        })
    return existing

Real-World Use Cases

Here are practical scenarios where invoking functions from XML proves invaluable:

Best Practices for Production

1. Always use @api.model decorator - Functions called from XML should be model-level methods
2. Implement idempotency - Check for existing records before creating to prevent duplicates
3. Add proper error handling - Use try-except blocks to handle potential failures gracefully
4. Document your functions - Include docstrings explaining what the function does and its parameters
5. Use noupdate wisely - Set to "1" for one-time operations, "0" for data that must stay synchronized
6. Test thoroughly - Test both fresh installations and module upgrades
7. Log important operations - Use _logger to track function execution

Complete Module Example

Here's a complete example showing the module structure:

# __manifest__.py
{
    'name': 'Custom Partner Setup',
    'version': '19.0.1.0.0',
    'category': 'Tools',
    'summary': 'Automated partner setup on installation',
    'depends': ['base'],
    'data': [
        'data/init_data.xml',
    ],
    'installable': True,
    'auto_install': False,
}

Frequently Asked Questions

Conclusion

The <function> tag in Odoo 19 XML files provides a clean, declarative way to execute Python methods during module installation or updates. Whether you're initializing data, migrating records, or automating configuration, this technique ensures your operations run reliably and automatically.

By combining XML declarations with custom Python logic, you can build modules that are self-configuring and production-ready from the moment they're installed.