[18.0][MIG] fastapi: Migration to 18.0

fastapi/__init__.py

@@ -0,0 +1,3 @@
+from . import models
+from . import fastapi_dispatcher
+from . import error_handlers

fastapi/__manifest__.py

@@ -0,0 +1,34 @@
+# Copyright 2022 ACSONE SA/NV
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/LGPL).
+
+{
+    "name": "Odoo FastAPI",
+    "summary": """
+        Odoo FastAPI endpoint""",
+    "version": "18.0.1.0.0",
+    "license": "LGPL-3",
+    "author": "ACSONE SA/NV,Odoo Community Association (OCA)",
+    "maintainers": ["lmignon"],
+    "website": "https://github.com/OCA/rest-framework",
+    "depends": ["endpoint_route_handler"],
+    "data": [
+        "security/res_groups.xml",
+        "security/fastapi_endpoint.xml",
+        "security/ir_rule+acl.xml",
+        "views/fastapi_menu.xml",
+        "views/fastapi_endpoint.xml",
+        "views/fastapi_endpoint_demo.xml",
+    ],
+    "demo": ["demo/fastapi_endpoint_demo.xml"],
+    "external_dependencies": {
+        "python": [
+            "fastapi>=0.110.0",
+            "python-multipart",
+            "ujson",
+            "a2wsgi>=1.10.6",
+            "parse-accept-language",
+        ]
+    },
+    "development_status": "Beta",
+    "installable": True,
+}

fastapi/context.py

@@ -0,0 +1,10 @@
+# Copyright 2022 ACSONE SA/NV
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/LGPL).
+
+# define context vars to hold the odoo env
+
+from contextvars import ContextVar
+
+from odoo.api import Environment
+
+odoo_env_ctx: ContextVar[Environment] = ContextVar("odoo_env_ctx")

fastapi/demo/fastapi_endpoint_demo.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- Copyright 2022 ACSONE SA/NV
+     License LGPL-3.0 or later (http://www.gnu.org/licenses/LGPL). -->
+<odoo>
+    <!-- This is the user that will be used to run the demo app -->
+    <record
+        id="my_demo_app_user"
+        model="res.users"
+        context="{'no_reset_password': True, 'no_reset_password': True}"
+    >
+        <field name="name">My Demo Endpoint User</field>
+        <field name="login">my_demo_app_user</field>
+        <field name="groups_id" eval="[(6, 0, [])]" />
+    </record>
+
+    <!-- This is the group that will be used to run the demo app
+  This group will only depend on the "group_fastapi_endpoint_runner" group
+  that provides the minimal access rights to retrieve the user running the
+  endpoint handlers and performs authentication.
+  -->
+    <record id="my_demo_app_group" model="res.groups">
+        <field name="name">My Demo Endpoint Group</field>
+        <field name="users" eval="[(4, ref('my_demo_app_user'))]" />
+        <field name="implied_ids" eval="[(4, ref('group_fastapi_endpoint_runner'))]" />
+    </record>
+
+    <!-- This is the endpoint that will be used to run the demo app
+  This endpoint will be registered on the "/fastapi_demo" path
+  -->
+
+    <record model="fastapi.endpoint" id="fastapi_endpoint_demo">
+        <field name="name">Fastapi Demo Endpoint</field>
+        <field
+            name="description"
+        ><![CDATA[
+# A Dummy FastApi Demo
+
+This demo endpoint has been created by inhering from "fastapi.endpoint", registering
+a new app into the app selection field and implementing the `_get_fastapi_routers`
+methods. See documentation to learn more about how to create a new app.
+]]></field>
+        <field name="app">demo</field>
+        <field name="root_path">/fastapi_demo</field>
+        <field name="demo_auth_method">http_basic</field>
+        <field name="user_id" ref="my_demo_app_user" />
+    </record>
+</odoo>

fastapi/dependencies.py

@@ -0,0 +1,177 @@
+# Copyright 2022 ACSONE SA/NV
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/LGPL).
+
+from typing import TYPE_CHECKING, Annotated
+
+from odoo.api import Environment
+from odoo.exceptions import AccessDenied
+
+from odoo.addons.base.models.res_partner import Partner
+from odoo.addons.base.models.res_users import Users
+
+from fastapi import Depends, Header, HTTPException, Query, status
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+
+from .context import odoo_env_ctx
+from .schemas import Paging
+
+if TYPE_CHECKING:
+    from .models.fastapi_endpoint import FastapiEndpoint
+
+
+def company_id() -> int | None:
+    """This method may be overriden by the FastAPI app to set the allowed company
+    in the Odoo env of the endpoint. By default, the company defined on the
+    endpoint record is used.
+    """
+    return None
+
+
+def odoo_env(company_id: Annotated[int | None, Depends(company_id)]) -> Environment:
+    env = odoo_env_ctx.get()
+    if company_id is not None:
+        env = env(context=dict(env.context, allowed_company_ids=[company_id]))
+
+    yield env
+
+
+def authenticated_partner_impl() -> Partner:
+    """This method has to be overriden when you create your fastapi app
+    to declare the way your partner will be provided. In some case, this
+    partner will come from the authentication mechanism (ex jwt token) in other cases
+    it could comme from a lookup on an email received into an HTTP header ...
+    See the fastapi_endpoint_demo for an example"""
+
+
+def optionally_authenticated_partner_impl() -> Partner | None:
+    """This method has to be overriden when you create your fastapi app
+    and you need to get an optional authenticated partner into your endpoint.
+    """
+
+
+def authenticated_partner_env(
+    partner: Annotated[Partner, Depends(authenticated_partner_impl)],
+) -> Environment:
+    """Return an environment with the authenticated partner id in the context"""
+    return partner.with_context(authenticated_partner_id=partner.id).env
+
+
+def optionally_authenticated_partner_env(
+    partner: Annotated[Partner | None, Depends(optionally_authenticated_partner_impl)],
+    env: Annotated[Environment, Depends(odoo_env)],
+) -> Environment:
+    """Return an environment with the authenticated partner id in the context if
+    the partner is not None
+    """
+    if partner:
+        return partner.with_context(authenticated_partner_id=partner.id).env
+    return env
+
+
+def authenticated_partner(
+    partner: Annotated[Partner, Depends(authenticated_partner_impl)],
+    partner_env: Annotated[Environment, Depends(authenticated_partner_env)],
+) -> Partner:
+    """If you need to get access to the authenticated partner into your
+    endpoint, you can add a dependency into the endpoint definition on this
+    method.
+    This method is a safe way to declare a dependency without requiring a
+    specific implementation. It depends on `authenticated_partner_impl`. The
+    concrete implementation of authenticated_partner_impl has to be provided
+    when the FastAPI app is created.
+    This method return a partner into the authenticated_partner_env
+    """
+    return partner_env["res.partner"].browse(partner.id)
+
+
+def optionally_authenticated_partner(
+    partner: Annotated[Partner | None, Depends(optionally_authenticated_partner_impl)],
+    partner_env: Annotated[Environment, Depends(optionally_authenticated_partner_env)],
+) -> Partner | None:
+    """If you need to get access to the authenticated partner if the call is
+    authenticated, you can add a dependency into the endpoint definition on this
+    method.
+
+    This method defer from authenticated_partner by the fact that it returns
+    None if the partner is not authenticated .
+    """
+    if partner:
+        return partner_env["res.partner"].browse(partner.id)
+    return None
+
+
+def paging(
+    page: Annotated[int, Query(ge=1)] = 1, page_size: Annotated[int, Query(ge=1)] = 80
+) -> Paging:
+    """Return a Paging object from the page and page_size parameters"""
+    return Paging(limit=page_size, offset=(page - 1) * page_size)
+
+
+def basic_auth_user(
+    credential: Annotated[HTTPBasicCredentials, Depends(HTTPBasic())],
+    env: Annotated[Environment, Depends(odoo_env)],
+) -> Users:
+    username = credential.username
+    password = credential.password
+    try:
+        response = (
+            env["res.users"]
+            .sudo()
+            .authenticate(
+                db=env.cr.dbname,
+                credential={
+                    "type": "password",
+                    "login": username,
+                    "password": password,
+                },
+                user_agent_env=None,
+            )
+        )
+        return env["res.users"].browse(response.get("uid"))
+    except AccessDenied as ad:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Basic"},
+        ) from ad
+
+
+def authenticated_partner_from_basic_auth_user(
+    user: Annotated[Users, Depends(basic_auth_user)],
+    env: Annotated[Environment, Depends(odoo_env)],
+) -> Partner:
+    return env["res.partner"].browse(user.sudo().partner_id.id)
+
+
+def fastapi_endpoint_id() -> int:
+    """This method is overriden by the FastAPI app to make the fastapi.endpoint record
+    available for your endpoint method. To get the fastapi.endpoint record
+    in your method, you just need to add a dependency on the fastapi_endpoint method
+    defined below
+    """
+
+
+def fastapi_endpoint(
+    _id: Annotated[int, Depends(fastapi_endpoint_id)],
+    env: Annotated[Environment, Depends(odoo_env)],
+) -> "FastapiEndpoint":
+    """Return the fastapi.endpoint record"""
+    return env["fastapi.endpoint"].browse(_id)
+
+
+def accept_language(
+    accept_language: Annotated[
+        str | None,
+        Header(
+            alias="Accept-Language",
+            description="The Accept-Language header is used to specify the language "
+            "of the content to be returned. If a language is not available, the "
+            "server will return the content in the default language.",
+        ),
+    ] = None,
+) -> str:
+    """This dependency is used at application level to document the way the language
+    to use for the response is specified. The header is processed outside of the
+    fastapi app to initialize the odoo environment with the right language.
+    """
+    return accept_language

fastapi/depends.py

@@ -0,0 +1,12 @@
+# Copyright 2023 ACSONE SA/NV
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/LGPL).
+
+import warnings
+
+warnings.warn(
+    "The 'depends' package is deprecated. Please use 'dependencies' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from .dependencies import *  # noqa: F403, F401, E402

fastapi/error_handlers.py

@@ -0,0 +1,77 @@
+# Copyright 2022 ACSONE SA/NV
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/LGPL).
+
+from starlette import status
+from starlette.exceptions import HTTPException, WebSocketException
+from starlette.middleware.errors import ServerErrorMiddleware
+from starlette.middleware.exceptions import ExceptionMiddleware
+from starlette.responses import JSONResponse
+from starlette.websockets import WebSocket
+from werkzeug.exceptions import HTTPException as WerkzeugHTTPException
+
+from odoo.exceptions import AccessDenied, AccessError, MissingError, UserError
+
+from fastapi import Request
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError
+from fastapi.utils import is_body_allowed_for_status_code
+
+
+def convert_exception_to_status_body(exc: Exception) -> tuple[int, dict]:
+    body = {}
+    status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+    details = "Internal Server Error"
+
+    if isinstance(exc, WerkzeugHTTPException):
+        status_code = exc.code
+        details = exc.description
+    elif isinstance(exc, HTTPException):
+        status_code = exc.status_code
+        details = exc.detail
+    elif isinstance(exc, RequestValidationError):
+        status_code = status.HTTP_422_UNPROCESSABLE_ENTITY
+        details = jsonable_encoder(exc.errors())
+    elif isinstance(exc, WebSocketRequestValidationError):
+        status_code = status.WS_1008_POLICY_VIOLATION
+        details = jsonable_encoder(exc.errors())
+    elif isinstance(exc, AccessDenied | AccessError):
+        status_code = status.HTTP_403_FORBIDDEN
+        details = "AccessError"
+    elif isinstance(exc, MissingError):
+        status_code = status.HTTP_404_NOT_FOUND
+        details = "MissingError"
+    elif isinstance(exc, UserError):
+        status_code = status.HTTP_400_BAD_REQUEST
+        details = exc.args[0]
+
+    if is_body_allowed_for_status_code(status_code):
+        # use the same format as in
+        # fastapi.exception_handlers.http_exception_handler
+        body = {"detail": details}
+    return status_code, body
+
+
+# we need to monkey patch the ServerErrorMiddleware and ExceptionMiddleware classes
+# to ensure that all the exceptions that are handled by these specific
+# middlewares are let to bubble up to the retrying mechanism and the
+# dispatcher error handler to ensure that appropriate action are taken
+# regarding the transaction, environment, and registry. These middlewares
+# are added by default by FastAPI when creating an application and it's not
+# possible to remove them. So we need to monkey patch them.
+
+
+def pass_through_exception_handler(
+    self, request: Request, exc: Exception
+) -> JSONResponse:
+    raise exc
+
+
+def pass_through_websocket_exception_handler(
+    self, websocket: WebSocket, exc: WebSocketException
+) -> None:
+    raise exc
+
+
+ServerErrorMiddleware.error_response = pass_through_exception_handler
+ExceptionMiddleware.http_exception = pass_through_exception_handler
+ExceptionMiddleware.websocket_exception = pass_through_websocket_exception_handler