Skip to content

Odoo REST API FastAPI

  • Odoo

Table of Contents

A Comprehensive Tutorial for Odoo 18

Creating an Odoo REST API with FastAPI offers a powerful way to extend Odoo’s capabilities, enabling seamless integration with external applications and services. This tutorial provides a comprehensive, step-by-step guide to building a modern, high-performance REST API on top of your Odoo 18 backend using the FastAPI framework. We will cover everything from initial setup to advanced considerations, ensuring you can effectively leverage this potent combination for your projects. By integrating FastAPI, you gain incredible speed, developer-friendly features, and automatic API documentation, significantly enhancing your Odoo integration strategy.

Why Choose an Odoo REST API with FastAPI?

When considering how to expose Odoo functionalities externally, building an Odoo REST API with FastAPI stands out for several compelling reasons. Odoo, while powerful, sometimes requires a more flexible and modern API layer than its default XML-RPC or JSON-RPC interfaces, especially for complex integrations or public-facing services. Consequently, FastAPI emerges as an ideal partner.

The Power of FastAPI for Your Odoo API

FastAPI is a modern, high-performance web framework for building APIs with Python 3.7+ based on standard Python type hints. Furthermore, its key advantages make it exceptionally well-suited for developing an Odoo REST API:

  1. Exceptional Speed: FastAPI is built on Starlette (for web parts) and Pydantic (for data parts), delivering performance on par with NodeJS and Go. This speed is crucial when dealing with potentially large datasets or high-traffic Odoo integrations.
  2. Rapid Development: Developers can significantly increase their coding speed, often by 200% to 300%. This acceleration stems from its intuitive design and features that reduce boilerplate.
  3. Reduced Bugs: By leveraging Python type hints, FastAPI, with Pydantic, provides robust data validation, serialization, and deserialization. This, in turn, helps reduce approximately 40% of human-induced errors.
  4. Intuitive and Easy to Use: It offers excellent editor support with autocompletion everywhere, minimizing debugging time. Moreover, it’s designed to be easy to learn and use, reducing the time spent on reading documentation.
  5. Concise Code: FastAPI allows you to minimize code duplication. Many features are derived from parameter declarations, leading to less code and fewer bugs.
  6. Production-Ready and Standards-Based: You get production-ready code with automatic interactive API documentation (Swagger UI and ReDoc). Importantly, it’s fully compatible with open standards for APIs: OpenAPI (formerly Swagger) and JSON Schema.

Therefore, integrating FastAPI with Odoo allows you to create a robust, maintainable, and highly efficient Odoo REST API layer.

Understanding Odoo’s Core for API Integration

Before diving into building your Odoo REST API with FastAPI, it’s essential to grasp how Odoo’s internal mechanisms work, as your FastAPI application will interact directly with them.

Odoo Environment (env)

The Odoo Environment, commonly referred to as env, is your primary gateway to interacting with Odoo models and their data. After Odoo is correctly initialized within your FastAPI application’s context, you will obtain an env object. Subsequently, this object allows you to access any Odoo model and perform operations.

Odoo Models

Through the env object, you can access specific Odoo models using dictionary-style access, for example, env['res.partner'] for the contacts model or env['sale.order'] for sales orders. Once you have a model object, you can perform various database operations.

Common Odoo ORM Operations

Odoo’s Object-Relational Mapper (ORM) provides a rich set of methods for data manipulation. Key operations you’ll frequently use in your Odoo REST API with FastAPI include:

  • create(vals_list): This method allows you to create one or more new records in a model. vals_list is a dictionary (or a list of dictionaries) where keys are field names and values are the data to be inserted.
  • search(domain, limit=None, offset=None, order=None, count=False): This powerful method searches for records matching a given domain (a list of search criteria). You can also control pagination (limit, offset), ordering (order), and retrieve just the count of matching records (count=True).
  • browse(ids): If you have the ID or a list of IDs for records, browse fetches these records from the database. It’s generally more efficient than searching if you already know the IDs.
  • write(vals): This method updates existing records (those in the current recordset) with the new values provided in the vals dictionary.
  • unlink(): This method deletes the records in the current recordset from the database.

Transaction Management in Odoo

Odoo automatically handles database transactions. When you perform ORM operations, they are typically executed within a database transaction. For your Odoo REST API with FastAPI, it’s crucial to manage these transactions correctly. Specifically, you must commit() changes to the database after successful operations or rollback() in case of errors. Furthermore, closing the database cursor (cr.close()) after each request is vital to release database connections.

Setting Up Your Odoo and FastAPI Environment

To begin building your Odoo REST API with FastAPI, you first need to prepare your development environment. This involves ensuring Odoo can be initialized from an external Python script (your FastAPI application) and installing the necessary libraries.

Prerequisites for Odoo FastAPI Integration

  1. Odoo 18 Installation: Ensure you have a working Odoo 18 instance. You’ll need its database name and potentially access to its configuration file.
  2. Python 3.7+: FastAPI requires Python 3.7 or newer. Your Odoo 18 environment likely already uses a compatible Python version.
  3. Odoo Libraries Accessible: The Python environment running your FastAPI application must have access to the Odoo source code or installed Odoo libraries. This is typically handled if you run FastAPI from within the same virtual environment as Odoo or if Odoo is installed system-wide.
  4. Basic Knowledge: A fundamental understanding of Odoo development, Python, and REST API concepts will be beneficial.

Step 1: Odoo Initialization for External Scripts

To use Odoo’s ORM and business logic outside of the standard Odoo server process, you must first initialize Odoo’s core components. This typically involves parsing Odoo’s configuration.

Create a Python script (which will later become your main.py for FastAPI). At the beginning, add: 

import odoo
import os

# Attempt to initialize Odoo configuration
# This allows Odoo to find its configuration, often from an 'odoo.conf' file
# or environment variables.
# You might need to adjust the path to your Odoo configuration file
# or ensure ODOO_RC environment variable is set.
try:
    # If your odoo.conf is not in a standard location, you might need to specify its path:
    # conf_path = '/path/to/your/odoo.conf'
    # if os.path.exists(conf_path):
    #     odoo.tools.config.parse_config(['-c', conf_path])
    # else:
    #     odoo.tools.config.parse_config([]) # Try default discovery
    odoo.tools.config.parse_config([])
except Exception as e:
    print(f"Error parsing Odoo configuration: {e}")
    # Handle error appropriately, perhaps by exiting or using default values

This step ensures that Odoo’s configuration settings (like database connection parameters, addons path, etc.) are loaded. If Odoo cannot find its configuration, it might fail at later stages.

Step 2: Loading the Odoo Registry for Your Database

The Odoo Registry is a crucial component that holds the in-memory representation of all models, fields, and their relationships for a specific database. Consequently, you must load the registry for the Odoo database you intend to connect your Odoo REST API with FastAPI to.

# Replace 'your_odoo_database_name' with the actual name of your Odoo 18 database
db_name = 'your_odoo_database_name'
if not db_name:
    raise Exception("Odoo database name is not configured. Please set it.")

try:
    registry = odoo.registry(db_name)
    # For Odoo 15 and newer, it's good practice to call check_signaling.
    # This helps keep the registry up-to-date if other Odoo processes
    # (like the main Odoo server) make changes to the database structure (e.g., install a new module).
    if hasattr(registry, 'check_signaling'):
        registry.check_signaling()
    print(f"Successfully loaded registry for database: {db_name}")
except Exception as e:
    print(f"Error loading Odoo registry for database '{db_name}': {e}")
    registry = None # Indicate failure
    # Depending on your application's needs, you might exit here or handle it gracefully.

It’s vital that db_name correctly identifies an existing Odoo 18 database that is properly initialized.

Step 3: Creating a Database Cursor and Odoo Environment

With the registry loaded, you can now obtain a database cursor and create an Odoo Environment object. This env object will be used to perform all ORM operations.

def get_odoo_environment_and_cursor(registry_instance, user_id=odoo.SUPERUSER_ID):
    """
    Helper function to get an Odoo environment and database cursor.
    Manages the cursor lifecycle.
    """
    if not registry_instance:
        print("Odoo registry is not available.")
        return None, None

# A database cursor is needed for all database operations.
# Using a 'with' statement ensures the cursor is automatically closed
# and transactions are committed or rolled back.
cr = registry_instance.cursor()

# The user_id determines the access rights for operations performed.
# odoo.SUPERUSER_ID bypasses access rights, which is convenient for backend scripts
# but should be used cautiously in production APIs. For a public API, you'd typically
# use a specific user ID based on authentication.
# For Odoo 18, the admin UID is often 2 (if demo data was installed). Verify this.
uid = user_id

# The context can hold various session-specific data like language, timezone, etc.
# For now, an empty context is sufficient for many basic operations.
context = {}

env = odoo.api.Environment(cr, uid, context)
return env, cr

# Example usage (though this will be integrated into FastAPI endpoints later):
# if registry:
#     env, cr = get_odoo_environment_and_cursor(registry)
#     if env and cr:
#         try:
#             # Example: Count partners
#             partner_count = env['res.partner'].search_count([])
#             print(f"Found {partner_count} partners in the database.")
#             cr.commit() # Commit if any read operation implicitly started a transaction or if writes were made
#         except Exception as e:
#             print(f"Error during Odoo operation: {e}")
#             cr.rollback() # Rollback in case of error
#         finally:
#             cr.close() # Always close the cursor
# else:
#     print("Cannot proceed without a valid Odoo registry.")

In this snippet, odoo.SUPERUSER_ID is used for simplicity. For a production Odoo REST API with FastAPI, you would typically authenticate the API request and then use the Odoo user ID corresponding to the authenticated user, thereby respecting Odoo’s access rights. The get_odoo_environment_and_cursor function is a foundational piece that we will refine and use within our FastAPI endpoints.

Building Your Odoo REST API with FastAPI

Now that the Odoo initialization logic is outlined, let’s proceed to construct the FastAPI application that will serve as our Odoo REST API.

Step 4.1: Installing FastAPI and Uvicorn

First, you need to install FastAPI and Uvicorn, an ASGI server to run your application. Pydantic, used for data validation, is usually installed as a dependency of FastAPI.

Open your terminal and run:

pip install fastapi uvicorn[standard] pydantic

The [standard] part for Uvicorn installs recommended dependencies like uvloop and httptools for better performance, if available on your system.

Step 4.2: Crafting the Basic FastAPI Application Structure

Create a Python file named main.py. This file will contain your FastAPI application logic and the Odoo integration.

# main.py
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel, Field
from typing import List, Optional, Dict, Any

import odoo
import os

# --- Odoo Initialization (as discussed before) ---
ODOO_DB_NAME = os.environ.get('ODOO_DB_NAME', 'your_odoo_database_name') # Use environment variable or default
ODOO_CONFIG_FILE = os.environ.get('ODOO_CONFIG_FILE') # Optional: path to odoo.conf

try:
    if ODOO_CONFIG_FILE and os.path.exists(ODOO_CONFIG_FILE):
        odoo.tools.config.parse_config(['-c', ODOO_CONFIG_FILE])
    else:
        odoo.tools.config.parse_config([]) # Attempt default discovery

    if not ODOO_DB_NAME:
        raise ValueError("Odoo database name (ODOO_DB_NAME) is not configured.")

    registry = odoo.registry(ODOO_DB_NAME)
    if hasattr(registry, 'check_signaling'):
        registry.check_signaling()
    print(f"Successfully loaded Odoo registry for database: {ODOO_DB_NAME}")
    ODOO_INITIALIZED_SUCCESSFULLY = True
except Exception as e:
    print(f"FATAL: Error during Odoo initialization: {e}")
    print("FastAPI application might not function correctly with Odoo.")
    registry = None
    ODOO_INITIALIZED_SUCCESSFULLY = False

# --- FastAPI Application Instance ---
app = FastAPI(
    title="Odoo 18 REST API with FastAPI",
    description=f"A modern REST API to interact with Odoo 18 (Database: {ODOO_DB_NAME if ODOO_INITIALIZED_SUCCESSFULLY else 'N/A'}).",
    version="1.0.0",
    # OpenAPI tags for grouping endpoints
    openapi_tags=[
        {
            "name": "Partners",
            "description": "Operations related to Odoo partners (customers, suppliers, etc.).",
        },
        {
            "name": "Health",
            "description": "API health checks.",
        }
    ]
)

# --- Pydantic Models for Data Validation & Serialization ---
# These models define the structure of your API request and response bodies.

class PartnerBase(BaseModel):
    name: str = Field(..., example="Modern Tech Solutions Inc.")
    email: Optional[str] = Field(None, example="contact@moderntech.example.com")
    phone: Optional[str] = Field(None, example="+1-555-0102")
    is_company: bool = Field(default=False, example=True)
    # Add other relevant fields you want to expose
    # street: Optional[str] = None
    # city: Optional[str] = None
    # country_id: Optional[int] = None # For m2o, you might pass ID or handle lookup

class PartnerCreate(PartnerBase):
    # Specific fields for creation, if any, otherwise inherits all from PartnerBase
    pass

class PartnerUpdate(BaseModel):
    # Allow partial updates, so all fields are optional
    name: Optional[str] = Field(None, example="Modern Tech Solutions LLC.")
    email: Optional[str] = Field(None, example="info@moderntech.example.com")
    phone: Optional[str] = Field(None, example="+1-555-0103")
    is_company: Optional[bool] = Field(None, example=True)

class Partner(PartnerBase):
    id: int = Field(..., example=123)

    class Config:
        # Pydantic V2 uses from_attributes instead of orm_mode
        # For Pydantic V1, use: orm_mode = True
        from_attributes = True

This initial structure sets up Odoo, instantiates FastAPI, and defines Pydantic models for res.partner. Using environment variables for ODOO_DB_NAME and ODOO_CONFIG_FILE is a good practice for configurability.

Step 4.3: Helper Function for Odoo Environment and Transaction Management

To manage Odoo’s environment and database transactions cleanly within FastAPI endpoints, we’ll create a dependency. This function will provide an Odoo env and handle cursor management.

# (Still in main.py)

# --- Odoo Environment Dependency ---
def get_odoo_env_cr_uid():
    """
    FastAPI dependency to get an Odoo environment, cursor, and user ID.
    Handles transaction commit/rollback and cursor closing.
    """
    if not ODOO_INITIALIZED_SUCCESSFULLY or not registry:
        raise HTTPException(status_code=503, detail="Odoo service is not available or not initialized.")

    # For Odoo 18, admin UID is typically 2. For production, use an authenticated user's UID.
    # This should be enhanced with actual authentication/authorization.
    uid = odoo.SUPERUSER_ID
    cr = None
    try:
        cr = registry.cursor()
        env = odoo.api.Environment(cr, uid, {})
        yield env # Provide the environment to the endpoint
        cr.commit()  # Commit transaction if all operations in the endpoint were successful
    except Exception as e:
        if cr:
            cr.rollback() # Rollback transaction on any error
        # Log the server-side error for debugging
        print(f"Odoo operation failed: {e}") # Replace with proper logging
        # Re-raise as HTTPException to inform the client
        if isinstance(e, HTTPException): # If it's already an HTTPException, re-raise it
            raise
        raise HTTPException(status_code=500, detail=f"An internal Odoo error occurred: {str(e)}")
    finally:
        if cr:
            cr.close() # Always close the cursor to release the database connection

# --- API Endpoints ---

# Health Check Endpoint
@app.get("/health", tags=["Health"])
async def health_check():
    """
    Performs a health check of the API and Odoo connection.
    """
    if not ODOO_INITIALIZED_SUCCESSFULLY:
        raise HTTPException(status_code=503, detail="Odoo initialization failed.")

    # Try a simple Odoo operation
    try:
        env = next(get_odoo_env_cr_uid()) # Manually invoke for check, not ideal for real use
        # A more robust check would be to use Depends in a dummy way or a separate check function
        # For simplicity here, we assume if registry is loaded, basic connection is fine.
        # A better check:
        # with registry.cursor() as cr_check:
        #    env_check = odoo.api.Environment(cr_check, odoo.SUPERUSER_ID, {})
        #    env_check['res.users'].browse(odoo.SUPERUSER_ID).check_access_rights('read', raise_exception=False)
        return {"status": "ok", "message": "API is running and Odoo registry is loaded.", "odoo_db": ODOO_DB_NAME}
    except HTTPException as http_exc: # Catch HTTPExceptions from get_odoo_env_cr_uid
        raise http_exc
    except Exception as e:
        # This path might be taken if get_odoo_env_cr_uid itself fails before yielding
        raise HTTPException(status_code=503, detail=f"Odoo connection check failed: {str(e)}")

The get_odoo_env_cr_uid function uses yield, making it a FastAPI dependency that handles setup (getting env) and teardown (commit/rollback, close cursor). This significantly cleans up endpoint logic. The health check endpoint is a good practice to verify basic connectivity.

Step 4.4: Implementing CRUD Endpoints for Odoo Partners

Now, let’s implement the Create, Read, Update, Delete (CRUD) operations for Odoo partners (res.partner) using our Odoo REST API with FastAPI.

Create Partner (POST /partners/)
# (Still in main.py)

@app.post("/partners/", response_model=Partner, status_code=201, tags=["Partners"])
async def create_odoo_partner(
    partner_data: PartnerCreate,
    env: odoo.api.Environment = Depends(get_odoo_env_cr_uid) # Inject Odoo environment
):
    """
    Creates a new partner in Odoo.
    This endpoint demonstrates how to use the `env` object from the dependency
    to interact with Odoo models for creating an **Odoo REST API with FastAPI**.
    """
    try:
        # Prepare values for Odoo's create method
        vals = {
            'name': partner_data.name,
            'email': partner_data.email,
            'phone': partner_data.phone,
            'is_company': partner_data.is_company,
            # Add any other fields from PartnerCreate model
        }
        # Remove None values, as Odoo's create method might not like them for all fields
        vals_cleaned = {k: v for k, v in vals.items() if v is not None}

        new_partner_record = env['res.partner'].create(vals_cleaned)
        # The Pydantic model 'Partner' will automatically convert new_partner_record
        # due to `from_attributes = True` (or `orm_mode = True`).
        return new_partner_record
    except odoo.exceptions.AccessError as e:
        raise HTTPException(status_code=403, detail=f"Odoo access error: {str(e)}")
    except odoo.exceptions.ValidationError as e:
        raise HTTPException(status_code=400, detail=f"Odoo validation error: {str(e)}")
    except Exception as e: # Catch other potential Odoo or unexpected errors
        # The dependency get_odoo_env_cr_uid will handle rollback and cr.close
        # but we might want to log or specify error details here.
        # This generic catch is a fallback.
        print(f"Error creating partner: {e}") # Log this
        raise HTTPException(status_code=500, detail=f"Failed to create partner: {str(e)}")

Read Multiple Partners (GET /partners/)

# (Still in main.py)

@app.get("/partners/", response_model=List[Partner], tags=["Partners"])
async def read_odoo_partners(
    skip: int = 0,
    limit: int = 10,
    env: odoo.api.Environment = Depends(get_odoo_env_cr_uid)
):
    """
    Retrieves a list of partners from Odoo with pagination.
    This showcases searching records via the **Odoo REST API with FastAPI**.
    """
    try:
        # Odoo search method for res.partner
        # You can add a domain filter here, e.g., [('is_company', '=', True)]
        domain = []
        partner_records = env['res.partner'].search(domain, offset=skip, limit=limit, order='name asc')
        # The response_model=List[Partner] will handle the conversion of the Odoo recordset.
        return list(partner_records) # Convert recordset to list for Pydantic
    except Exception as e:
        print(f"Error reading partners: {e}") # Log this
        raise HTTPException(status_code=500, detail=f"Failed to retrieve partners: {str(e)}")
Read Single Partner (GET /partners/{partner_id})
pythonCopy Code# (Still in main.py)  @app.get("/partners/{partner_id}", response_model=Partner, tags=["Partners"])  asyncdefread_odoo_partner(  
    partner_id: int,  
    env: odoo.api.Environment = Depends(get_odoo_env_cr_uid)  
):  
    """  
    Retrieves a specific partner from Odoo by its ID.  
    Demonstrates fetching a single record in your **Odoo REST API with FastAPI**.  
    """try:  
        partner_record = env['res.partner'].browse(partner_id)  
        ifnot partner_record.exists():  
            raise HTTPException(status_code=404, detail=f"Partner with ID {partner_id} not found.")  
        return partner_record  
    except HTTPException: # Re-raise HTTPException (like 404) directly  raiseexcept Exception as e:  
        print(f"Error reading partner {partner_id}: {e}") # Log this  raise HTTPException(status_code=500, detail=f"Failed to retrieve partner {partner_id}: {str(e)}")
Update Partner (PUT /partners/{partner_id})
pythonCopy Code# (Still in main.py)  @app.put("/partners/{partner_id}", response_model=Partner, tags=["Partners"])  asyncdefupdate_odoo_partner(  
    partner_id: int,  
    partner_data: PartnerUpdate, # Use the PartnerUpdate model for partial updates  
    env: odoo.api.Environment = Depends(get_odoo_env_cr_uid)  
):  
    """  
    Updates an existing partner in Odoo.  
    Illustrates updating records through the **Odoo REST API with FastAPI**.  
    """try:  
        partner_record = env['res.partner'].browse(partner_id)  
        ifnot partner_record.exists():  
            raise HTTPException(status_code=404, detail=f"Partner with ID {partner_id} not found for update.")  

        # Get data from Pydantic model, excluding unset fields for partial update  
        update_values = partner_data.model_dump(exclude_unset=True)  

        ifnot update_values:  
            raise HTTPException(status_code=400, detail="No update data provided.")  

        partner_record.write(update_values)  
        return partner_record  
    except odoo.exceptions.AccessError as e:  
        raise HTTPException(status_code=403, detail=f"Odoo access error: {str(e)}")  
    except odoo.exceptions.ValidationError as e:  
        raise HTTPException(status_code=400, detail=f"Odoo validation error: {str(e)}")  
    except HTTPException:  
        raiseexcept Exception as e:  
        print(f"Error updating partner {partner_id}: {e}") # Log this  raise HTTPException(status_code=500, detail=f"Failed to update partner {partner_id}: {str(e)}")
Delete Partner (DELETE /partners/{partner_id})
pythonCopy Code# (Still in main.py)  @app.delete("/partners/{partner_id}", status_code=204, tags=["Partners"]) # 204 No Content for successful deletion  asyncdefdelete_odoo_partner(  
    partner_id: int,  
    env: odoo.api.Environment = Depends(get_odoo_env_cr_uid)  
):  
    """  
    Deletes a partner from Odoo.  
    Shows how to implement deletion in your **Odoo REST API with FastAPI**.  
    """try:  
        partner_record = env['res.partner'].browse(partner_id)  
        ifnot partner_record.exists():  
            raise HTTPException(status_code=404, detail=f"Partner with ID {partner_id} not found for deletion.")  

        partner_record.unlink()  
        # No content to return, FastAPI handles the 204 status code.  returnNone# Or return Response(status_code=204)  except odoo.exceptions.AccessError as e:  
        raise HTTPException(status_code=403, detail=f"Odoo access error: {str(e)}")  
    except odoo.exceptions.UserError as e: # UserError often indicates a business logic constraint (e.g., cannot delete if linked)  raise HTTPException(status_code=409, detail=f"Odoo business rule conflict: {str(e)}") # 409 Conflict  except HTTPException:  
        raiseexcept Exception as e:  
        print(f"Error deleting partner {partner_id}: {e}") # Log this  raise HTTPException(status_code=500, detail=f"Failed to delete partner {partner_id}: {str(e)}")

Step 4.5: Running the FastAPI Application

To run your newly created Odoo REST API with FastAPI, add the following block at the end of your main.py file:

pythonCopy Code# (Still in main.py, at the very end)  if __name__ == "__main__":  
    import uvicorn  
    ifnot ODOO_INITIALIZED_SUCCESSFULLY:  
        print("WARNING: Odoo was not initialized successfully. API might not work as expected.")  
        print("Please check ODOO_DB_NAME and Odoo configuration.")  

    # It's crucial that the Odoo server itself is also running if your FastAPI app  # relies on certain real-time aspects or if Odoo modules need to be fully loaded  # by the main Odoo server process for some functionalities.  # However, for direct ORM access as shown, the main Odoo server process  # doesn't strictly need to be running, as we're initializing a connection independently.  print(f"Starting FastAPI server for Odoo DB: {ODOO_DB_NAME if ODOO_INITIALIZED_SUCCESSFULLY else 'N/A'}")  
    print("Access API docs at http://127.0.0.1:8000/docs or http://127.0.0.1:8000/redoc")  
    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)

Now, you can run your application from the terminal in the directory where main.py is located:

bashCopy Codeexport ODOO_DB_NAME="your_actual_odoo_db"# Optionally: export ODOO_CONFIG_FILE="/path/to/your/odoo.conf"  
python main.py

The reload=True flag (or --reload if running uvicorn main:app --reload directly) makes Uvicorn automatically restart the server when code changes are detected, which is very helpful during development.

Step 4.6: Accessing the Interactive API Documentation

Once your FastAPI server is running, open your web browser and navigate to http://127.0.0.1:8000/docs. You will see the interactive Swagger UI documentation. Here, you can explore all your defined endpoints for the Odoo REST API with FastAPI, see their request/response models, and even test them directly from the browser. Alternatively, navigate to http://127.0.0.1:8000/redoc for an alternative ReDoc documentation view.

Advanced Considerations for Your Odoo FastAPI API

Building a basic CRUD API is a great start. However, for production-grade Odoo REST API with FastAPI applications, several advanced topics need careful consideration.

Robust Error Handling in Your Odoo API

While HTTPException is useful for standard errors, you might need more sophisticated error handling.

  • Custom Exception Handlers: FastAPI allows you to define custom exception handlers. For instance, you can catch specific Odoo exceptions (e.g., odoo.exceptions.UserError, odoo.exceptions.AccessDenied) and transform them into standardized HTTP responses.
  • Logging: Implement comprehensive logging. Log incoming requests, outgoing responses (selectively), errors, and important Odoo operations. Libraries like loguru or Python’s built-in logging module can be configured for this.

Transaction Management Best Practices for Odoo Integration

The Depends(get_odoo_env_cr_uid) pattern handles basic transaction management. However, ensure:

  • Atomicity: If an API endpoint involves multiple Odoo operations that must succeed or fail together, the current dependency structure handles this by committing only at the end or rolling back on any exception.
  • Read-Only Operations: For purely read-only endpoints, while cr.commit() doesn’t harm, it’s technically unnecessary. Odoo’s cursor might start a transaction even for reads. The current setup is safe.

Authentication and Authorization for Your Odoo REST API

The current example uses odoo.SUPERUSER_ID, which bypasses all Odoo access rights. This is not secure for most production APIs.

  • FastAPI Security Utilities: FastAPI provides tools for implementing various authentication schemes like OAuth2 Password Bearer, API Keys, etc. (see FastAPI Security Documentation).
  • Mapping API Users to Odoo Users:
    1. Authenticate the API request (e.g., validate a token).
    2. Determine the corresponding Odoo user ID based on the authenticated identity.
    3. Pass this uid to odoo.api.Environment(cr, uid, context) instead of odoo.SUPERUSER_ID. This ensures that all operations performed through your Odoo REST API with FastAPI adhere to Odoo’s configured access rights for that user.

Asynchronous Operations with Odoo

FastAPI excels at asynchronous programming (async/await). However, Odoo’s ORM is predominantly synchronous.

  • Challenge: Directly calling synchronous Odoo ORM methods within an async def FastAPI endpoint can block the event loop, negating FastAPI’s concurrency benefits.
  • Solution: Use asyncio.to_thread (Python 3.9+) or run_in_executor with loop.run_in_executor for older versions to run synchronous Odoo calls in a separate thread pool. import asyncio
import asyncio
# Inside an async endpoint:
# partner_record = await asyncio.to_thread(env['res.partner'].browse, partner_id)

This requires careful management, as the Odoo environment (env) and cursor (cr) are thread-local or need to be passed correctly. The current dependency get_odoo_env_cr_uid is synchronous; adapting it for true async Odoo calls would require significant changes to how env and cr are managed across threads.

Data Validation and Serialization Deep Dive with Pydantic

Pydantic is extremely powerful for your Odoo REST API with FastAPI.

  • Complex Models: Define nested Pydantic models to represent Odoo’s relational data (e.g., a SaleOrder model with a list of SaleOrderLine models).
  • Custom Validators: Use Pydantic’s @validator (Pydantic V1) or @field_validator (Pydantic V2) decorators for complex validation logic beyond basic type checking.
  • Response Models: Utilize response_model extensively to control exactly what data is returned, preventing accidental exposure of sensitive fields. You can have different Pydantic models for input (creation/update) and output.

Optimizing Performance for your Odoo API

  • Efficient Odoo Searches:
    • Use precise domains in env[model].search(domain) to filter data at the database level.
    • When fetching multiple records, only request the fields you absolutely need using the fields parameter in Odoo’s read() method if you are not relying on Pydantic’s automatic field selection from ORM objects. However, Pydantic’s from_attributes usually handles this well by only accessing defined fields.
    • Be mindful of Odoo’s default _rec_name computations or related fields that might trigger extra queries.
  • Caching: For frequently accessed, rarely changing data, consider implementing a caching layer (e.g., using Redis with FastAPI).
  • Pagination: Always use pagination (limit, offset) for endpoints that can return many records.

Testing Your Odoo REST API

Thorough testing is crucial for any API, especially one interacting with a complex backend like Odoo.

Interactive Testing with Swagger UI/ReDoc

As mentioned, http://127.0.0.1:8000/docs and http://127.0.0.1:8000/redoc are invaluable for quick, interactive testing during development of your Odoo REST API with FastAPI.

Automated Testing with Pytest

For robust testing, use a framework like Pytest.

  • FastAPI’s TestClient: FastAPI provides a TestClient that allows you to make requests to your application in your tests without needing a running server. tests/test_partners.py
# tests/test_partners.py
from fastapi.testclient import TestClient
from main import app # Your FastAPI app instance

client = TestClient(app)

def test_create_partner():
    response = client.post(
        "/partners/",
        json={"name": "Test Partner API", "email": "test@api.example.com", "is_company": False},
    )
    assert response.status_code == 201
    data = response.json()
    assert data["email"] == "test@api.example.com"
    assert "id" in data

def test_read_partners():
    response = client.get("/partners/")
    assert response.status_code == 200
    assert isinstance(response.json(), list)
  • Mocking Odoo: For unit tests, you might want to mock the Odoo env object or specific ORM calls to isolate your API logic from the actual Odoo database. Python’s unittest.mock library is excellent for this.
  • Integration Tests: For integration tests, you would run tests against a real (test) Odoo database to ensure the entire flow of your Odoo REST API with FastAPI works correctly.
  • Refer to the Pytest Documentation for more on writing tests.

### Deployment Strategies for Odoo and FastAPI

When moving your Odoo REST API with FastAPI to production, consider these deployment aspects:

Running Uvicorn in Production with Gunicorn

While Uvicorn can run standalone, for production, it’s common to use Gunicorn as a process manager for Uvicorn workers. Gunicorn provides robustness, multiple worker processes, and easier management.

pip install gunicorn
gunicorn -k uvicorn.workers.UvicornWorker main:app -w 4 -b 0.0.0.0:8000

Here, -w 4 starts 4 worker processes. The number of workers typically depends on your server’s CPU cores.

Reverse Proxy (Nginx/Traefik)

Place your Gunicorn/Uvicorn setup behind a reverse proxy like Nginx or Traefik.

  • Benefits:
    • SSL/TLS Termination: Handle HTTPS securely.
    • Load Balancing: If you scale to multiple API server instances.
    • Serving Static Files: Though less relevant for a pure API.
    • Caching: Some reverse proxies offer caching capabilities.
    • Security: Can provide an additional layer of security (e.g., rate limiting).
  • Consult the Nginx Documentation or Traefik’s documentation for configuration details.

Containerization with Docker

Containerizing your Odoo REST API with FastAPI application using Docker simplifies deployment, scaling, and ensures consistency across environments.

  • Dockerfile: Create a Dockerfile for your FastAPI application.
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# Expose the port Uvicorn will run on
EXPOSE 8000

# Set ODOO_DB_NAME and other Odoo connection params via environment variables
# ENV ODOO_DB_NAME="your_production_db"
# ENV ODOO_CONFIG_FILE="/path/to/odoo.conf/in/container/or/mounted/volume" 
# (if needed and not handled by Odoo's auto-discovery within the container's context)

# Command to run the application using Gunicorn with Uvicorn workers
CMD ["gunicorn", "-k", "uvicorn.workers.UvicornWorker", "main:app", "-w", "4", "-b", "0.0.0.0:8000"]
  • You’d build this image and run it as a container.
  • Docker Compose: For managing multi-container applications (e.g., your FastAPI app, Odoo itself if containerized, a database, Redis), Docker Compose is very useful.
  • Explore the Docker Documentation for more information.

Conclusion: Powering Up Odoo with FastAPI

You have now journeyed through the process of building a robust Odoo REST API with FastAPI for your Odoo 18 system. By combining Odoo’s comprehensive business functionalities with FastAPI’s modern, high-performance API development capabilities, you unlock significant potential for integrations, custom frontends, and extending Odoo’s reach.

This tutorial covered the essential steps: understanding Odoo’s internals, setting up the environment, initializing Odoo within a FastAPI context, defining Pydantic models, creating CRUD endpoints, and managing transactions. Furthermore, we delved into advanced topics like security, error handling, asynchronous operations, testing, and deployment strategies, all crucial for a production-ready Odoo REST API with FastAPI.

The path to mastering this integration involves continuous learning and adaptation to your specific project needs. Remember to prioritize security, write thorough tests, and optimize for performance as your API grows. The combination of Odoo and FastAPI provides a flexible and powerful platform for your development endeavors.

Discover more from teguhteja.id

Subscribe to get the latest posts sent to your email.

Tags:

Leave a Reply

WP Twitter Auto Publish Powered By : XYZScripts.com