Skip to content

Index Page

This site contains the project documentation for the odooaiorpc project.

Table Of Contents

The documentation follows the best practice for project documentation as described by Daniele Procida in the Diátaxis documentation framework and consists of four separate parts:

  1. Tutorials
  2. How-To Guides
  3. Reference
  4. Explanation

Quickly find what you're looking for depending on your use case by looking at the different pages.

Project Overview

OdooAioRPC is an aync Odoo remote procedure call

OdooAioRPC

Source code in odooaiorpc/client.py 
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
class OdooAioRPC:
    def __init__(
        self,
        url: t.Union[str, AnyUrl],
        database: str,
        user: str,
        secret: str,
        protocol: const.Protocol = const.Protocol.jsonrpc,
        auth: t.Optional[AuthTypes] = None,
        headers: t.Optional[HeaderTypes] = None,
        context: t.Optional[VerifyTypes] = None,
        timeout: TimeoutTypes = 5.0,
        transport: t.Optional[BaseProtocol] = None,
    ) -> None:
        """
        Initialize OdooAioRPC client

        Args:
            url (t.Union[str, AnyUrl]): Odoo http URL
            database (str): Odoo database
            user (str): Odoo user to connect with
            secret (str): Odoo user generated api key or password (discouraged)
            protocol (const.Protocol, optional): Communication protocol. Defaults to const.Protocol.jsonrpc.
            auth (t.Optional[AuthTypes], optional): Auth options. Defaults to None.
            headers (t.Optional[HeaderTypes], optional): Custom http headers. Defaults to None.
            context (t.Optional[VerifyTypes], optional): SSL context. Defaults to None.
            timeout (TimeoutTypes, optional): Connection timeout. Defaults to 5.0.
            transport (t.Optional[BaseProtocol], optional): _description_. Defaults to None.
        """
        self._url = url
        self._database = database
        self._user = user
        self._secret = secret
        self._uid: t.Optional[int] = None
        self._common_proxy: t.Optional[CommonDomain] = None
        self._object_proxy: t.Optional[ModelDomain] = None
        self._db_proxy: t.Optional[DBDomain] = None

        if transport:
            self._transport = transport
        else:
            self._transport = pick_preferred_protocol(protocol=protocol)(
                url=url,
                auth=auth,
                headers=headers,
                context=context,
                timeout=timeout,
            )

    @staticmethod
    def get_protocol_from_settings(settings: OdooSettings) -> BaseProtocol:
        """
        Get configured protocol class from OdooSettings

        Args:
            settings (OdooSettings): settings to get config from

        Returns:
            BaseProtocol: Protocol instance
        """
        return pick_preferred_protocol(protocol=settings.protocol).from_settings(
            settings=settings
        )

    @classmethod
    def from_settings(cls, settings: OdooSettings) -> "OdooAioRPC":
        """
        Initialize OdooAioRPC client from OdooSettings

        Args:
            settings (OdooSettings): settings

        Returns:
            OdooAioRPC: RPC client instance
        """
        return cls(
            url=settings.url,
            database=t.cast(str, settings.database),
            user=settings.user,
            secret=settings.secret,
            protocol=settings.protocol,
            auth=settings.auth,
            headers=settings.headers,
            context=settings.context,
            timeout=settings.timeout,
        )

    async def authenticate(self) -> t.Optional[int]:
        """
        Authenticate configured user with Odoo
        Return uid if auth process success

        Returns:
            t.Optional[int]: User uid
        """
        uid = await self.common.authenticate(
            self._database, self._user, self._secret, {}
        )
        if uid:
            self._uid = uid
        return uid

    async def version(self) -> dict:
        """
        Return Odoo server version informations

        Returns:
            dict: Version infos
        """
        return await self.common.version()

    @property
    def is_auth(self) -> bool:
        """
        Check if auth has been done

        Returns:
            bool: auth state
        """
        return self._uid is not None

    @property
    def common(self) -> CommonDomain:
        """
        Return common RPC domain
        Initialize if not already done

        Returns:
            CommonDomain: Common RPC domain
        """
        if self._common_proxy is None:
            self._common_proxy = CommonDomain(transport=self._transport)
        return t.cast(CommonDomain, self._common_proxy)

    @property
    def models(self) -> ModelDomain:
        """
        Return object/models RPC domain
        Initialize if not already done

        Returns:
            ModelDomain: Object RPC domain
        """
        if self._object_proxy is None:
            self._object_proxy = ModelDomain(transport=self._transport)
        return t.cast(ModelDomain, self._object_proxy)

    @property
    def db(self) -> DBDomain:
        """
        Return db RPC domain
        Initialize if not already done

        Returns:
            DBDomain: DB RPC domain
        """
        if self._db_proxy is None:
            self._db_proxy = DBDomain(transport=self._transport)
        return t.cast(DBDomain, self._db_proxy)

common: CommonDomain property

Return common RPC domain Initialize if not already done

Returns:

Name Type Description
CommonDomain CommonDomain

Common RPC domain

db: DBDomain property

Return db RPC domain Initialize if not already done

Returns:

Name Type Description
DBDomain DBDomain

DB RPC domain

is_auth: bool property

Check if auth has been done

Returns:

Name Type Description
bool bool

auth state

models: ModelDomain property

Return object/models RPC domain Initialize if not already done

Returns:

Name Type Description
ModelDomain ModelDomain

Object RPC domain

__init__(url, database, user, secret, protocol=const.Protocol.jsonrpc, auth=None, headers=None, context=None, timeout=5.0, transport=None)

Initialize OdooAioRPC client

Parameters:

Name Type Description Default
url t.Union[str, AnyUrl]

Odoo http URL

 required
database str

Odoo database

 required
user str

Odoo user to connect with

 required
secret str

Odoo user generated api key or password (discouraged)

 required
protocol const.Protocol

Communication protocol. Defaults to const.Protocol.jsonrpc.

 const.Protocol.jsonrpc
auth t.Optional[AuthTypes]

Auth options. Defaults to None.

 None
headers t.Optional[HeaderTypes]

Custom http headers. Defaults to None.

 None
context t.Optional[VerifyTypes]

SSL context. Defaults to None.

 None
timeout TimeoutTypes

Connection timeout. Defaults to 5.0.

 5.0
transport t.Optional[BaseProtocol]

description. Defaults to None.

 None
Source code in odooaiorpc/client.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
def __init__(
    self,
    url: t.Union[str, AnyUrl],
    database: str,
    user: str,
    secret: str,
    protocol: const.Protocol = const.Protocol.jsonrpc,
    auth: t.Optional[AuthTypes] = None,
    headers: t.Optional[HeaderTypes] = None,
    context: t.Optional[VerifyTypes] = None,
    timeout: TimeoutTypes = 5.0,
    transport: t.Optional[BaseProtocol] = None,
) -> None:
    """
    Initialize OdooAioRPC client

    Args:
        url (t.Union[str, AnyUrl]): Odoo http URL
        database (str): Odoo database
        user (str): Odoo user to connect with
        secret (str): Odoo user generated api key or password (discouraged)
        protocol (const.Protocol, optional): Communication protocol. Defaults to const.Protocol.jsonrpc.
        auth (t.Optional[AuthTypes], optional): Auth options. Defaults to None.
        headers (t.Optional[HeaderTypes], optional): Custom http headers. Defaults to None.
        context (t.Optional[VerifyTypes], optional): SSL context. Defaults to None.
        timeout (TimeoutTypes, optional): Connection timeout. Defaults to 5.0.
        transport (t.Optional[BaseProtocol], optional): _description_. Defaults to None.
    """
    self._url = url
    self._database = database
    self._user = user
    self._secret = secret
    self._uid: t.Optional[int] = None
    self._common_proxy: t.Optional[CommonDomain] = None
    self._object_proxy: t.Optional[ModelDomain] = None
    self._db_proxy: t.Optional[DBDomain] = None

    if transport:
        self._transport = transport
    else:
        self._transport = pick_preferred_protocol(protocol=protocol)(
            url=url,
            auth=auth,
            headers=headers,
            context=context,
            timeout=timeout,
        )

authenticate() async

Authenticate configured user with Odoo Return uid if auth process success

Returns:

Type Description
t.Optional[int]

t.Optional[int]: User uid
Source code in odooaiorpc/client.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
async def authenticate(self) -> t.Optional[int]:
    """
    Authenticate configured user with Odoo
    Return uid if auth process success

    Returns:
        t.Optional[int]: User uid
    """
    uid = await self.common.authenticate(
        self._database, self._user, self._secret, {}
    )
    if uid:
        self._uid = uid
    return uid

from_settings(settings) classmethod

Initialize OdooAioRPC client from OdooSettings

Parameters:

Name Type Description Default
settings OdooSettings

settings

 required

Returns:

Name Type Description
OdooAioRPC OdooAioRPC

RPC client instance
Source code in odooaiorpc/client.py 
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
@classmethod
def from_settings(cls, settings: OdooSettings) -> "OdooAioRPC":
    """
    Initialize OdooAioRPC client from OdooSettings

    Args:
        settings (OdooSettings): settings

    Returns:
        OdooAioRPC: RPC client instance
    """
    return cls(
        url=settings.url,
        database=t.cast(str, settings.database),
        user=settings.user,
        secret=settings.secret,
        protocol=settings.protocol,
        auth=settings.auth,
        headers=settings.headers,
        context=settings.context,
        timeout=settings.timeout,
    )

get_protocol_from_settings(settings) staticmethod

Get configured protocol class from OdooSettings

Parameters:

Name Type Description Default
settings OdooSettings

settings to get config from

 required

Returns:

Name Type Description
BaseProtocol BaseProtocol

Protocol instance
Source code in odooaiorpc/client.py 
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@staticmethod
def get_protocol_from_settings(settings: OdooSettings) -> BaseProtocol:
    """
    Get configured protocol class from OdooSettings

    Args:
        settings (OdooSettings): settings to get config from

    Returns:
        BaseProtocol: Protocol instance
    """
    return pick_preferred_protocol(protocol=settings.protocol).from_settings(
        settings=settings
    )

version() async

Return Odoo server version informations

Returns:

Name Type Description
dict dict

Version infos
Source code in odooaiorpc/client.py 
114
115
116
117
118
119
120
121
async def version(self) -> dict:
    """
    Return Odoo server version informations

    Returns:
        dict: Version infos
    """
    return await self.common.version()

OdooSettings

Bases: BaseSettings

Odoo client configuration settings

Source code in odooaiorpc/config.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class OdooSettings(BaseSettings):
    """
    Odoo client configuration settings
    """

    class Config:
        env_prefix = "ODOO_AIO_"
        env_file = ".env"
        env_file_encoding = "utf-8"

    url: AnyUrl
    """
    Odoo url
    """
    database: t.Optional[str] = None
    """
    Odoo database
    """
    user: str
    """
    Odoo user
    """
    secret: str
    """
    Odoo user API key
    """
    protocol: const.Protocol = const.Protocol.jsonrpc
    """
    RPC protocol used to communicate. Default to jsonrpc
    """
    auth: t.Optional[AuthTypes] = None
    headers: t.Optional[HeaderTypes] = None
    context: t.Optional[VerifyTypes] = None
    timeout: TimeoutTypes = 5.0

    @validator("database", pre=True, always=True)
    def extract_db_name(cls, v, values, **kwargs):
        """
        Extract database name from url if not specified
        """
        if v is None and "url" in values:
            parsed_url = urlparse(values["url"])
            return parsed_url.hostname.split(".")[0]
        return v

database: t.Optional[str] = None class-attribute instance-attribute

Odoo database

protocol: const.Protocol = const.Protocol.jsonrpc class-attribute instance-attribute

RPC protocol used to communicate. Default to jsonrpc

secret: str instance-attribute

Odoo user API key

url: AnyUrl instance-attribute

Odoo url

user: str instance-attribute

Odoo user

extract_db_name(v, values, **kwargs)

Extract database name from url if not specified

Source code in odooaiorpc/config.py 
45
46
47
48
49
50
51
52
53
@validator("database", pre=True, always=True)
def extract_db_name(cls, v, values, **kwargs):
    """
    Extract database name from url if not specified
    """
    if v is None and "url" in values:
        parsed_url = urlparse(values["url"])
        return parsed_url.hostname.split(".")[0]
    return v