Odooly

https://odooly.readthedocs.io/en/latest/
Admin
Odooly is a versatile Python library that communicates with Odoo/OpenERP servers using multiple...
Tokens:68,319
Snippets:511
Trust Score:8.3
Update:8 months ago
Show doc for...
Tokens:
Raw
### Env.install

Source: https://odooly.readthedocs.io/en/latest/api

Installs one or more specified modules.

```APIDOC
## Env.install

### Description
Press button `Install`. Installs one or more specified modules.

### Method
`install(_* modules_, _quiet =False_)`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **modules** (string) - One or more module names to install.
- **quiet** (boolean) - Optional - If `True`, suppresses output messages.

#### Request Body
None

### Request Example
```json
{
  "modules": ["module_x", "module_y"],
  "quiet": false
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the success of the installation.

#### Response Example
```json
{
  "status": "Installation successful"
}
```
```

--------------------------------

### Install Odoo Modules (Python)

Source: https://odooly.readthedocs.io/en/latest/api

Initiates the installation of one or more Odoo modules. Can be run quietly to suppress output. Note: Offline installations may not be signaled to other processes.

```python
Env.install(_* modules_, _quiet =False_)
```

--------------------------------

### Optional Database Configuration

Source: https://odooly.readthedocs.io/en/latest/developer

When using the Webclient, the `database =` configuration setting is now optional. This simplifies the setup process for certain OdooLy integrations.

```python
from odoorpc import Client

# Database configuration is optional when using Webclient
client = Client('localhost', port=8069, protocol='web')

```

--------------------------------

### Install Odooly using pip

Source: https://odooly.readthedocs.io/en/latest/_sources/intro.rst

This snippet shows the command to install the latest release of Odooly from PyPI. It uses pip, the standard Python package installer, and the -U flag ensures that the package is upgraded to the latest version if it's already installed.

```bash
pip install -U odooly

```

--------------------------------

### Create Odoo Database with Odooly

Source: https://odooly.readthedocs.io/en/latest/tutorial

Demonstrates how to create a new Odoo database using the Odooly client. This requires the superadmin password and the desired database name. It also shows how to verify the database creation and list installed modules.

```python
>>> client.create_database('super_password', 'demo')
Logged in as 'admin'
>>> client
<Client 'http://localhost:8069/web?db=demo'>
>>> client.database.list()
['demo']
>>> env
<Env 'admin@demo'>
>>> env.modules(installed=True)
{'installed': ['base', 'web', 'web_mobile', 'web_tests']}
>>> len(env.modules()['uninstalled'])
1398
>>> #

```

--------------------------------

### Odooly Shell Usage Examples

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

Demonstrates common commands and interactions within the Odooly interactive shell. This includes accessing models, inspecting fields, browsing and searching records, and managing modules.

```pycon
>>> client
<Client 'http://localhost:8069/web?db='>
>>> client.server_version
'18.0'
>>> #
>>> client.create_database('super_password', 'demo')
Logged in as 'admin'
>>> client
<Client 'http://localhost:8069/web?db=demo'>
>>> client.database.list()
['demo']
>>> env
<Env 'admin@demo'>
>>> env.modules(installed=True)
{'installed': ['base', 'web', 'web_mobile', 'web_tests']}
>>> len(env.modules()['uninstalled'])
1398
>>> #
>>> client.clone_database('super_password', 'demo_test')
Logged in as 'admin'
>>> client
<Client 'http://localhost:8069/web?db=demo_test'>
>>> client.database.list()
['demo', 'demo_test']
>>> env
<Env 'admin@demo_test'>
>>> client.modules(installed=True)
{'installed': ['base', 'web', 'web_mobile', 'web_tests']}
>>> len(client.modules()['uninstalled'])
1398
>>> #
>>> client
<Client 'http://localhost:8069/web?db=demo'>
>>> env.models('user')
['res.users', 'res.users.log']
```

--------------------------------

### Query Odoo Models from Command Line

Source: https://odooly.readthedocs.io/en/latest/intro

Provides examples of querying Odoo models (e.g., res.partner, res.groups) from the command line using specific arguments like database, model, fields, and search terms.

```bash
$ odooly -d demo -m res.partner -f name -f lang 1

```

```bash
$ odooly -d demo -m res.groups -f full_name 'id > 0'

```

--------------------------------

### Odoo Client Initialization and Service Setup

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Initializes the Odoo client, setting up the server connection, database, and user credentials. It handles different server connection types and configures RPC services based on the Odoo version.

```python
def __init__(self, server, db=None, user=None, password=None,
                 api_key=None, transport=None, verbose=False):
        self._http = HTTPSession()
        self._printer = Printer()
        self._session_uid = None
        self.verbose = verbose
        self._set_services(server, db, transport)
        self.env = Env(self)
        if user:  # Try to login
            self.login(user, password=password, api_key=api_key, database=db)
```

--------------------------------

### Start Odooly Shell

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

Initiates the Odooly interactive shell. It can connect to a locally running Odoo server on the default port or a specified server address and port. It also supports specifying the API endpoint like '/jsonrpc'.

```shell
~$ odooly
```

```shell
~$ odooly --server http://192.168.0.42:8069
```

```shell
~$ odooly --server http://127.0.0.1:8069/jsonrpc
```

--------------------------------

### Env Addon Management

Source: https://odooly.readthedocs.io/en/latest/_sources/api.rst

Helper methods for managing Odoo addons, including listing, installing, upgrading, and uninstalling them.

```APIDOC
## Env Addon Management

### Description
Helper methods for managing Odoo addons, including listing, installing, upgrading, and uninstalling them.

### Methods

- **modules**: Lists available addons.
- **install**: Installs one or more addons.
- **upgrade**: Upgrades one or more addons.
- **uninstall**: Uninstalls one or more addons.
- **upgrade_cancel**: Cancels an ongoing addon upgrade.

### Note
It is not recommended to install or upgrade modules in offline mode when any web server is still running, as the operation will not be signaled to other processes. This restriction does not apply when connected through Webclient API or other RPC API.
```

--------------------------------

### Env.modules

Source: https://odooly.readthedocs.io/en/latest/api

Returns a dictionary of modules. Allows filtering by name pattern and installed status.

```APIDOC
## Env.modules

### Description
Return a dictionary of modules. The optional argument `name` is a pattern to filter the modules. If the boolean argument `installed` is `True`, the modules which are “Not Installed” or “Not Installable” are omitted. If the argument is `False`, only these modules are returned. If argument `installed` is omitted, all modules are returned. The return value is a dictionary where module names are grouped in lists according to their `state`.

### Method
`modules(_name =''_, _installed =None_)`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **name** (string) - Optional - A pattern to filter module names.
- **installed** (boolean) - Optional - If `True`, only installed modules are returned. If `False`, only not installed/not installable modules are returned. If omitted, all modules are returned.

#### Request Body
None

### Request Example
```json
{
  "name": "base",
  "installed": true
}
```

### Response
#### Success Response (200)
- **modules** (object) - A dictionary where keys are module states (e.g., 'installed', 'to install') and values are lists of module names.

#### Response Example
```json
{
  "modules": {
    "installed": ["module_a", "module_b"],
    "to install": ["module_c"]
  }
}
```
```

--------------------------------

### Find Odoo Models with Odooly

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

Searches for Odoo models that match a given pattern using the Odooly shell. This example demonstrates finding models related to 'user'.

```pycon
>>> env.models('user')
['res.users', 'res.users.log']
```

--------------------------------

### Create Odoo Database with Odooly

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

Creates a new Odoo database using the Odooly shell. Requires the superadmin password and the desired database name. After creation, it confirms login and lists available databases and installed modules.

```pycon
>>> client.create_database('super_password', 'demo')
Logged in as 'admin'
>>> client
<Client 'http://localhost:8069/web?db=demo'>
>>> client.database.list()
['demo']
>>> env
<Env 'admin@demo'>
>>> env.modules(installed=True)
{'installed': ['base', 'web', 'web_mobile', 'web_tests']}
```

--------------------------------

### Manage Odoo Module Operations (Upgrade, Install, Uninstall, Cancel)

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Provides methods to interact with Odoo modules, allowing users to upgrade, install, uninstall, or cancel these operations. It handles version-specific logic and user confirmation prompts. Dependencies include the Odoo client and potentially other internal modules.

```python
def upgrade(self, *modules, quiet=False):
        """Press button ``Upgrade``."""
        return self._upgrade(modules, button='button_upgrade', quiet=quiet)

def install(self, *modules, quiet=False):
        """Press button ``Install``."""
        return self._upgrade(modules, button='button_install', quiet=quiet)

def uninstall(self, *modules, quiet=False):
        """Press button ``Uninstall``."""
        return self._upgrade(modules, button='button_uninstall', quiet=quiet)

def upgrade_cancel(self):
        """Press button ``Cancel Upgrade/Install/Uninstall``."""
        return self._upgrade((), button='cancel', quiet=True)
```

--------------------------------

### Get User Metadata

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

Retrieves metadata for a specific user, including creation and modification dates, and associated XML IDs.

```APIDOC
## Get User Metadata

### Description
Retrieves metadata for a specific user, including creation and modification dates, and associated XML IDs.

### Method
GET

### Endpoint
`/api/users/{user_id}/metadata` (Conceptual - actual interaction is via Python client)

### Parameters
#### Path Parameters
- **user_id** (integer) - Required - The ID of the user to retrieve metadata for.

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Example using the Python client to get metadata for user with ID 1
admin_user_metadata = env['res.users'].browse(1).get_metadata()
```

### Response
#### Success Response (200)
- **metadata** (list of objects) - A list containing metadata for the user.
  - **create_date** (string) - The date the user was created.
  - **create_uid** (integer or boolean) - The ID of the user who created the record.
  - **id** (integer) - The user's ID.
  - **noupdate** (boolean) - Indicates if the record should not be updated.
  - **write_date** (string) - The date the user was last modified.
  - **write_uid** (list) - The ID and name of the user who last modified the record.
  - **xmlid** (string) - The XML ID of the user.
  - **xmlids** (list of objects) - A list of XML ID objects associated with the user.

#### Response Example
```json
[
  {
    "create_date": "2024-10-01 10:08:20",
    "create_uid": false,
    "id": 1,
    "noupdate": true,
    "write_date": "2024-10-01 10:08:30",
    "write_uid": [1, "System"],
    "xmlid": "base.user_root",
    "xmlids": [{"noupdate": true, "xmlid": "base.user_root"}]
  }
]
```
```

--------------------------------

### Browse and Inspect Odoo User Record

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

This example shows how to search for a specific user by ID, access their group information, and retrieve metadata associated with the user record. It demonstrates the use of `browse` and accessing related record lists.

```pycon
>>> env['res.users'].search_count()
1
>>> admin_user = env['res.users'].browse(1)
>>> admin_user.groups_id
<RecordList 'res.groups,length=7'>
>>> admin_user.groups_id.full_name
['Administration / Access Rights',
 'Technical / Access to export feature',
 'Bypass HTML Field Sanitize',
 'Extra Rights / Contact Creation',
 'User types / Internal User',
 'Administration / Settings',
 'Extra Rights / Technical Features']
>>> admin_user.get_metadata()
[{'create_date': '2024-10-01 10:08:20',
  'create_uid': False,
  'id': 1,
  'noupdate': True,
  'write_date': '2024-10-01 10:08:30',
  'write_uid': [1, 'System'],
  'xmlid': 'base.user_root',
  'xmlids': [{'noupdate': True, 'xmlid': 'base.user_root'}]}]
```

--------------------------------

### Odooly Shell Commands Overview

Source: https://odooly.readthedocs.io/en/latest/tutorial

This snippet displays common commands available in the Odooly interactive shell. These commands allow interaction with Odoo models, fields, records, and server-side operations like module installation and upgrades.

```bash
Usage (some commands):
    env[name]                       # Return a Model instance
    env[name].keys()                # List field names of the model
    env[name].fields(names=None)    # Return details for the fields
    env[name].field(name)           # Return details for the field
    env[name].browse(ids=())
    env[name].search(domain)
    env[name].search(domain, offset=0, limit=None, order=None)
                                    # Return a RecordList

    rec = env[name].get(domain)     # Get the Record matching domain
    rec.some_field                  # Return the value of this field
    rec.read(fields=None)           # Return values for the fields

    client.login(user)              # Login with another user
    client.connect(env_name)        # Connect to another env.
    client.connect(server=None)     # Connect to another server
    env.models(name)                # List models matching pattern
    env.modules(name)               # List modules matching pattern
    env.install(module1, module2, ...)
    env.upgrade(module1, module2, ...)
                                    # Install or upgrade the modules
    env.upgrade_cancel()            # Reset failed upgrade/install

```

--------------------------------

### Instantiating Odoo Environment

Source: https://odooly.readthedocs.io/en/latest/api

Provides an example of how to instantiate an Odoo environment object using the odooly.Env class. This class wraps data for Odoo models and records, including database name, user ID, and context.

```python
from odooly import Env

# Assuming 'client' is an authenticated Client instance
# env = Env(client, "your_db_name")

# Example of accessing a model
# some_model = env["some.model"]
```

--------------------------------

### Clone Odoo Database with Odooly

Source: https://odooly.readthedocs.io/en/latest/tutorial

This snippet illustrates cloning an existing Odoo database using Odooly. It requires the superadmin password and the name for the new cloned database. The example verifies the cloning process by listing databases and checking the environment.

```python
>>> client.clone_database('super_password', 'demo_test')
Logged in as 'admin'
>>> client
<Client 'http://localhost:8069/web?db=demo_test'>
>>> client.database.list()
['demo', 'demo_test']
>>> env
<Env 'admin@demo_test'>
>>> client.modules(installed=True)
{'installed': ['base', 'web', 'web_mobile', 'web_tests']}
>>> len(client.modules()['uninstalled'])
1398
>>> #

```

--------------------------------

### Creating and Destroying Webclient Session

Source: https://odooly.readthedocs.io/en/latest/api

Provides examples of how to create a Webclient session for a user using `session_authenticate` and terminate it using `session_destroy`. These methods are used for managing user sessions.

```python
env.session_authenticate(login="user", password="password")
# env.session_destroy()
```

--------------------------------

### Create Odoo Connection from Configuration

Source: https://odooly.readthedocs.io/en/latest/api

Creates a Client connection to a defined environment by reading settings from a configuration file or memory. It simplifies connection setup by abstracting configuration details.

```python
from odooly import Client

# Create client from a named environment (e.g., 'production')
client = Client.from_config('production', user='admin')
```

--------------------------------

### Interactive Console Setup and Execution

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Configures and runs an interactive Python console for inspecting Odoo objects. It includes custom display and exception hooks, readline support for history and completion, and integrates with global variables. This function is designed to provide a rich debugging and exploration environment.

```python
def _interact(global_vars, use_pprint=True, usage=USAGE):
    import builtins
    import code
    import pprint

    if use_pprint:
        def displayhook(value, _printer=pprint.pprint, _builtins=builtins):
            # Pretty-format the output
            if value is not None:
                _printer(value)
                _builtins._ = value
        sys.displayhook = displayhook

    def excepthook(exc_type, exc, tb):
        # Print readable 'Fault' errors
        msg = ''.join(format_exception(exc_type, exc, tb, chain=False))
        print(msg.strip())
    sys.excepthook = excepthook

    builtins.usage = type('Usage', (), {'__call__': lambda s: print(usage),
                                        '__repr__': lambda s: usage})()

    try:
        import readline as rl
        import rlcompleter
        rl.parse_and_bind('tab: complete')
        # IOError if file missing, or broken Apple readline
        rl.read_history_file(HIST_FILE)
    except Exception:
        pass
    else:
        if rl.get_history_length() < 0:
            rl.set_history_length(int(os.getenv('HISTSIZE', 500)))
        # better append instead of replace?
        atexit.register(rl.write_history_file, HIST_FILE)

    # Key UP to avoid an empty line
    code.InteractiveConsole(global_vars).interact('\033[A', '')
```

--------------------------------

### Odooly Command Line Arguments Help

Source: https://odooly.readthedocs.io/en/latest/intro

Displays the help message for Odooly, outlining available options for command-line usage, including connection settings, model querying, and output formatting.

```bash
~$ odooly --help

```

--------------------------------

### List Odoo Modules in Python

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Retrieves a dictionary of Odoo modules, optionally filtering by name pattern and installation status. Modules are grouped by their state (e.g., 'installed', 'uninstalled'). Handles different filtering criteria for installed modules.

```python
def modules(self, name='', installed=None):
    """Return a dictionary of modules.

    The optional argument `name` is a pattern to filter the modules.
    If the boolean argument `installed` is :const:`True`, the modules
    which are "Not Installed" or "Not Installable" are omitted.  If
    the argument is :const:`False`, only these modules are returned.
    If argument `installed` is omitted, all modules are returned.
    The return value is a dictionary where module names are grouped in
    lists according to their ``state``.
    """
    if isinstance(name, str):
        domain = [('name', 'like', name)]
    else:
        domain = name
    if installed is not None:
        op = 'not in' if installed else 'in'
        domain.append(('state', op, ['uninstalled', 'uninstallable']))
    ir_module = self._get('ir.module.module', False)
    mods = ir_module.read(domain, 'name state')
    if mods:
        res = {}
        for mod in mods:
            if mod['state'] not in res:
                res[mod['state']] = []
            res[mod['state']].append(mod['name'])
        return res
```

--------------------------------

### Get Odoo Registry Object (Python)

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Retrieves the Odoo registry object, which provides access to the database pool and other environment-specific information. It uses the client's internal method to get the pool based on the database name.

```python
@property
def registry(self):
    """Return the environment's registry."""
    return self.client._server._get_pool(self.db_name)
```

--------------------------------

### Create User

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

This endpoint allows for the creation of new user accounts. It requires at least the 'name' and 'login' fields.

```APIDOC
## Create User

### Description
This endpoint allows for the creation of new user accounts. It requires at least the 'name' and 'login' fields.

### Method
POST

### Endpoint
`/api/users` (Conceptual - actual interaction is via Python client)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **name** (string) - Required - The full name of the user.
- **login** (string) - Required - The username for login.
- **password** (string) - Optional - The user's password.
- **groups_id** (list of integers) - Optional - List of group IDs the user belongs to.

### Request Example
```python
# Example using the Python client to create a user with name and login
new_user = env['res.users'].create({'name': 'Joe', 'login': 'joe', 'password': 'bartender'})
```

### Response
#### Success Response (200)
- **user_record** (object) - A representation of the newly created user record.

#### Response Example
```json
{
  "user_record": "<Record 'res.users,3'>"
}
```

#### Error Response (400)
- **error** (string) - Description of the validation error, e.g., missing mandatory fields.
```

--------------------------------

### lang

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Gets the current language code from the environment's context.

```APIDOC
## GET /api/lang

### Description
Returns the language code currently set in the environment's context. This is typically used to determine the user's preferred language for displaying information.

### Method
GET

### Endpoint
/api/lang

### Parameters
None

### Response
#### Success Response (200)
- **lang** (string) - The language code (e.g., 'en_US', 'fr_FR').

#### Response Example
```json
{
  "lang": "en_US"
}
```
```

--------------------------------

### Odooly Interactive Shell Session

Source: https://odooly.readthedocs.io/en/latest/intro

Demonstrates a sample session within the Odooly interactive shell, showing how to query models, search for records, read fields, and interact with modules.

```python
>>> env['res.users']
<Model 'res.users'>
>>> env['res.users'].search_count()
4
>>> crons = env['ir.cron'].with_context(active_test=False).search([])
>>> crons.read('active name')
[{'active': True, 'id': 5, 'name': 'Calendar: Event Reminder'},
 {'active': False, 'id': 4, 'name': 'Mail: Fetchmail Service'}]
>>> #
>>> env.modules('delivery')
{'uninstalled': ['delivery', 'website_sale_delivery']}
>>> env.upgrade('base')
1 module(s) selected
42 module(s) to process:
  to upgrade    account
  to upgrade    account_chart
  to upgrade    account_tax_include
  to upgrade    base
  ...
>>> #

```

--------------------------------

### Set User Password and Login in Odoo

Source: https://odooly.readthedocs.io/en/latest/tutorial

This code shows how to set a password for a newly created user and then log in as that user. It includes attempts to log in before and after setting the password, demonstrating the effect on authentication.

```python
>>> client.login('joe')
Password for 'joe':
Error: Invalid username or password
>>> env.user.login
'admin'
>>> joe_user.password = 'bartender'
>>> client.login('joe')
Logged in as 'joe'
>>> env.user.login
'joe'
>>> #

```

--------------------------------

### Get Model Keys

Source: https://odooly.readthedocs.io/en/latest/api

Retrieves all available keys (field names) for a given Odoo model.

```python
model.keys()
```

--------------------------------

### Get Single Record

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Retrieves a single record based on an ID, domain, or external ID.

```APIDOC
## GET /models/{model_name}/get

### Description
Retrieves a single record from the specified model. The `domain` argument can be a single integer ID, a search domain, or an external ID (xml_id). Returns None if no record is found, or raises ValueError if multiple records match.

### Method
GET

### Endpoint
`/models/{model_name}/get`

### Parameters
#### Path Parameters
- **model_name** (string) - Required - The name of the model.

#### Query Parameters
- **domain** (integer or string or array) - Required - The identifier for the record. Can be a single ID, an external ID (xml_id), or a search domain.
- **args** (any) - Optional - Additional positional arguments to pass through.
- **kwargs** (object) - Optional - Additional keyword arguments to pass through.
```

--------------------------------

### Connect to Odoo Server Interactively

Source: https://odooly.readthedocs.io/en/latest/intro

Launches Odooly to connect to an Odoo server, either locally or remotely, using the --server argument. It can also connect using settings from an odooly.ini file.

```bash
~$ odooly --server https://demo.odoo.com/

```

```bash
~$ odooly --server http://127.0.0.1:8069/

```

```bash
~$ odooly --list

```

```bash
~$ odooly --env demo

```

--------------------------------

### Get Specific Field Properties

Source: https://odooly.readthedocs.io/en/latest/api

Retrieves the properties of a single, specified field within an Odoo model.

```python
model.field('name')
```

--------------------------------

### Support browse() Returning Empty RecordList

Source: https://odooly.readthedocs.io/en/latest/developer

The `env['res.partner'].browse()` method now correctly returns an empty `RecordList` when no matching records are found. This provides consistent behavior for record retrieval operations.

```python
from odoorpc import Client

client = Client('localhost', port=8069)

# Browse a partner that might not exist
partner_recordlist = client.env['res.partner'].browse(99999) # Assuming ID 99999 does not exist

if not partner_recordlist:
    print("No partner found, returned an empty RecordList.")

```

--------------------------------

### registry

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Accesses the Odoo registry, which manages models and their metadata. This is used internally to get pool objects.

```APIDOC
## GET /api/registry

### Description
Returns the Odoo environment's registry. The registry is responsible for managing all Odoo models and their associated metadata.

### Method
GET

### Endpoint
/api/registry

### Parameters
None

### Response
#### Success Response (200)
- **registry** (object) - The Odoo registry object.

#### Response Example
```json
{
  "registry": { ... }
}
```
```

--------------------------------

### Client Initialization and Database Management

Source: https://odooly.readthedocs.io/en/latest/_sources/api.rst

Methods for initializing the Odooly client and managing Odoo databases.

```APIDOC
## Client and Services

### Description
The `Client` object provides wrappers for Odoo Webclient API and RPC services. It also offers helpers for exploring models and managing Odoo add-ons via the `Client.env` environment.

### Methods

- **`Client.from_config(config)`**: Initializes the client from a configuration.
- **`Client.create_database(name, lang, demo=False, mpg_id=None)`**: Creates a new Odoo database.
- **`Client.clone_database(source_db, to_db, demo=False, mpg_id=None)`**: Clones an existing Odoo database to a new one.
- **`Client.drop_database(name)`**: Drops an Odoo database.
- **`Client.login(user, password, database)`**: Logs in a user to a specific database.
- **`Client.save()`**: Saves the current client configuration.
- **`Client.get_config()`**: Retrieves the current client configuration.

### Attributes

- **`Client.env`**: The current `Env` environment of the client.

### Notes

- In interactive mode, `Client.connect(env=None, server=None, user=None)` can be used to connect to a different environment.
- To bypass invalid HTTPS server certificates, set the environment variable `ODOOLY_SSL_UNVERIFIED=1`.

### Webclient API Endpoints

- **`Client.database`**: Exposes the `/web/database` WebAPI, offering methods like `list` for database management.
- **`Client.web`**: Exposes the root `/web` WebAPI.
- **`Client.web_dataset`**: Exposes the `/web/dataset` WebAPI.
- **`Client.web_session`**: Exposes the `/web/session` WebAPI.
- **`Client.web_webclient`**: Exposes the `/web/webclient` WebAPI.

### RPC Services (Deprecated)

- **`Client.db`**: Exposes the `db` Service with methods like `list` and `server_version`. (Removed in Odoo 20)
- **`Client.common`**: Exposes the `common` Service with methods like `login_message`. (Removed in Odoo 20)
- **`Client._object`**: Exposes the `object` Service, similar to `Client.web_dataset`. (Removed in Odoo 20)
- **`Client._report`**: Exposes the `report` Service. (Removed in Odoo 11)
- **`Client._wizard`**: Exposes the `wizard` Service. (Removed in OpenERP 7)
```

--------------------------------

### Read Configuration Parameters in Odoo

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

Demonstrates how to retrieve configuration parameters from the 'ir.config_parameter' model in Odoo. It shows how to search for all parameters and then read specific fields like 'id', 'key', and 'value'.

```python
config_params = env['ir.config_parameter'].sudo().search([])
config_params.read('[{id:2}]  {key:30} {value}')
```

--------------------------------

### Read Configuration Parameters in Odoo

Source: https://odooly.readthedocs.io/en/latest/tutorial

Demonstrates how to retrieve and display configuration parameters from the 'ir.config_parameter' model in Odoo. The output shows the ID, key, and value for each configuration parameter.

```python
>>> # Show the content of a model
>>> config_params = env['ir.config_parameter'].sudo().search([])
>>> config_params.read('[{id:2}]  {key:30} {value}')
['[ 8]  base.default_max_email_size    10',
 '[ 5]  base.login_cooldown_after      10',
 '[ 6]  base.login_cooldown_duration   60',
 '[ 7]  base.template_portal_user_id   5',
 '[10]  base_setup.default_user_rights True',
 '[ 9]  base_setup.show_effect         True',
 '[ 3]  database.create_date           2024-10-01 06:10:24',
 '[ 1]  database.secret                88888888-8888-8888-8888-888888888888',
 '[ 2]  database.uuid                  77777777-7777-7777-7777-777777777777',
 '[ 4]  web.base.url                   http://localhost:8069']
```

--------------------------------

### Get Model Fields

Source: https://odooly.readthedocs.io/en/latest/api

Retrieves a dictionary of fields for an Odoo model, optionally filtering by specific field names or attributes.

```python
model.fields()
model.fields(['name', 'email'])
model.fields(attributes=['string', 'help'])
```

--------------------------------

### List Odoo Modules (Python)

Source: https://odooly.readthedocs.io/en/latest/api

Returns a dictionary of Odoo modules, optionally filtered by name pattern or installation status. Modules are grouped by their state.

```python
Env.modules(_name =''_, _installed =None_)
```

--------------------------------

### Instantiate Odoo Model

Source: https://odooly.readthedocs.io/en/latest/api

Demonstrates how to instantiate a model from the client environment. This is the entry point for interacting with specific Odoo models.

```python
client.env['res.company']
```

--------------------------------

### Create and Configure New Odoo User

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

This snippet illustrates the process of creating a new user in Odoo, including handling validation errors for missing mandatory fields like 'login'. It shows how to set user attributes and assign a password, followed by logging in as the new user.

```pycon
>>> env['res.users'].create({'name': 'Joe'})
odoo.exceptions.ValidationError: The operation cannot be completed:
    - Create/update: a mandatory field is not set.
    - Delete: another model requires the record being deleted. If possible, archive it instead.

Model: User (res.users)
Field: Login (login)
>>> #
>>> env['res.users'].create({'login': 'joe', 'name': 'Joe'})
<Record 'res.users,3'>
>>> joe_user = _
>>> joe_user.groups_id.full_name
['Technical / Access to export feature',
 'Extra Rights / Contact Creation',
 'User types / Internal User',
 'Extra Rights / Technical Features']
>>> joe_user.password = 'bartender'
>>> client.login('joe')
Logged in as 'joe'
>>> env.user.login
'joe'
>>> #
```

--------------------------------

### Cancel Odoo Module Operation (Python)

Source: https://odooly.readthedocs.io/en/latest/api

Presses the 'Cancel Upgrade/Install/Uninstall' button for ongoing module operations. This action can be used to halt a module installation, upgrade, or uninstallation process.

```python
Env.upgrade_cancel()
```

--------------------------------

### Get Current Language Code from Odoo Context

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Retrieves the language code from the current Odoo context. This is useful for internationalization and localization purposes within the Odoo application.

```python
@property
def lang(self):
    """Return the current language code."""
    return self.context.get('lang')
```

--------------------------------

### Get Single Record by ID or Domain

Source: https://odooly.readthedocs.io/en/latest/api

Retrieves a single Odoo record using its ID, external ID, or a search domain. Raises ValueError if multiple records are found.

```python
model.get(42)
model.get('my.module.record_name')
model.get([('name', '=', 'Example')])
```

--------------------------------

### Access Odoo Models and User Information

Source: https://odooly.readthedocs.io/en/latest/tutorial

Demonstrates how to access the current user's login and retrieve a list of all available models in the Odoo environment. It also shows how to handle access errors and use sudo() to bypass access restrictions.

```python
>>> env.user.login
'joe'
>>> all_models = env.models()
odoo.exceptions.AccessError: You are not allowed to access 'Models' (ir.model) records.

This operation is allowed for the following groups:
        - Administration/Access Rights

Contact your administrator to request access if necessary.
>>> all_models = env.sudo().models()
>>> len(all_models)
140
```

--------------------------------

### Prepare RecordList with Search Arguments

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

The _prepared class method initializes a RecordList instance with model, domain, and search parameters. It ensures the domain is correctly formatted using searchargs and merges provided parameters into the search dictionary.

```python
    @classmethod
    def _prepared(cls, res_model, domain, params):
        [domain] = searchargs((domain,))
        return cls(res_model, None, search={'domain': domain, **params})
```

--------------------------------

### Get Odoo Report Information (Python)

Source: https://odooly.readthedocs.io/en/latest/api

Wraps the report.report_get RPC method to retrieve information about a specific Odoo report. Requires the report ID. This method was removed in Odoo 11.

```python
Env.report_get(_report_id_)
```

--------------------------------

### Search and Browse User Records in Odoo

Source: https://odooly.readthedocs.io/en/latest/tutorial

This code demonstrates how to count the total number of users, browse a specific user by ID, and retrieve associated group information. It also shows how to fetch metadata for a user record.

```python
>>> env['res.users'].search_count()
1
>>> admin_user = env['res.users'].browse(1)
>>> admin_user.groups_id
<RecordList 'res.groups,length=7'>
>>> admin_user.groups_id.full_name
['Administration / Access Rights',
 'Technical / Access to export feature',
 'Bypass HTML Field Sanitize',
 'Extra Rights / Contact Creation',
 'User types / Internal User',
 'Administration / Settings',
 'Extra Rights / Technical Features']
>>> admin_user.get_metadata()
[{'create_date': '2024-10-01 10:08:20',
  'create_uid': False,
  'id': 1,
  'noupdate': True,
  'write_date': '2024-10-01 10:08:30',
  'write_uid': [1, 'System'],
  'xmlid': 'base.user_root',
  'xmlids': [{'noupdate': True, 'xmlid': 'base.user_root'}]}]


```

--------------------------------

### Getting Odoo Server Version

Source: https://odooly.readthedocs.io/en/latest/api

Shows how to retrieve the Odoo server version using the Client.db.server_version() RPC method. This method is part of the deprecated db service and is removed in Odoo 20.

```python
from odooly import Client

client = Client()
print(client.db.server_version())
```

--------------------------------

### Create a New User in Odoo

Source: https://odooly.readthedocs.io/en/latest/tutorial

This snippet illustrates the process of creating a new user in Odoo. It first attempts creation with minimal data, showing a validation error for missing mandatory fields, then successfully creates a user with 'login' and 'name'.

```python
>>> env['res.users'].create({'name': 'Joe'})
odoo.exceptions.ValidationError: The operation cannot be completed:
- Create/update: a mandatory field is not set.
- Delete: another model requires the record being deleted. If possible, archive it instead.

Model: User (res.users)
Field: Login (login)
>>> #

>>> env['res.users'].create({'login': 'joe', 'name': 'Joe'})
<Record 'res.users,3'>
>>> joe_user = _
>>> joe_user.groups_id.full_name
['Technical / Access to export feature',
 'Extra Rights / Contact Creation',
 'User types / Internal User',
 'Extra Rights / Technical Features']


```

--------------------------------

### Odooly Verbosity Control

Source: https://odooly.readthedocs.io/en/latest/intro

Shows how to use the --verbose switch for detailed output and how to set verbosity interactively. Higher verbosity levels provide more insight into Odooly's operations.

```bash
~$ odooly --server https://demo.odoo.com/ -vv

```

```python
>>> client.verbose = 180  # Width in columns

```

--------------------------------

### Create and Destroy Session Functions

Source: https://odooly.readthedocs.io/en/latest/developer

New functions `Env.session_authenticate()` and `Env.session_destroy()` have been added to manage user sessions explicitly. These functions provide granular control over session creation and termination.

```python
from odoorpc import Client

client = Client('localhost', port=8069)

# Authenticate a session
# client.env.session_authenticate(db='my_database', login='user', password='password')

# Destroy a session
# client.env.session_destroy()

```

--------------------------------

### Get Odoo Model Instance in Python

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Returns an instance of an Odoo model by its name. It performs validity checks unless explicitly disabled. If the model is not found, it raises an error with a list of available models if possible.

```python
def _get(self, name, check=True, transient=False):
    """Return a :class:`Model` instance.

    The argument `name` is the name of the model.  If the optional
    argument `check` is :const:`False`, no validity check is done.
    """
    check = check and not transient and self._access_models is not False
    try:
        return self._models_get(name, check, transient=transient)
    except KeyError:
        model_names = self.models(name)
    if name in self._model_names or not self._access_models:
        return self._models_get(name, self._access_models, transient=transient)
    if model_names and self._access_models:
        errmsg = 'Model not found.  These models exist:'
    else:
        errmsg = f'Model not found: {name}'
    raise Error('
 * '.join([errmsg] + model_names))
```

--------------------------------

### Accept Multiple Command Line Arguments for Local Mode

Source: https://odooly.readthedocs.io/en/latest/developer

Local mode now accepts multiple command-line arguments, allowing for more flexible configuration when running OdooLy locally. This includes specifying Odoo configuration files and data directories.

```bash
# Example: Running OdooLy in local mode with custom config and data directory
# odooly -- --config /path/to/odoo.conf --data-dir ./var

```

--------------------------------

### Clone Odoo Database with Odooly

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

Clones an existing Odoo database to a new one using Odooly. This is useful for testing, backups, or migrations. It requires the superadmin password and the name for the new database.

```pycon
>>> client.clone_database('super_password', 'demo_test')
Logged in as 'admin'
>>> client
<Client 'http://localhost:8069/web?db=demo_test'>
>>> client.database.list()
['demo', 'demo_test']
>>> env
<Env 'admin@demo_test'>
>>> client.modules(installed=True)
{'installed': ['base', 'web', 'web_mobile', 'web_tests']}
```

--------------------------------

### Get Odoo Database Cursor (Python)

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Returns a database cursor object for the Odoo environment. It handles cursor creation based on the Odoo client's version information, using a memoized cursor for efficiency.

```python
@property
def cr(self):
    """Return a cursor on the database."""
    return self.__dict__.get('cr') or _memoize(
        self, 'cr', self.registry.db.cursor()
        if self.client.version_info < 8.0 else self.registry.cursor())
```

--------------------------------

### Get Odoo Server Environment Instance (Python)

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Provides access to the Odoo server environment, specifically the API Environment object. This is supported for Odoo versions 8.0 and above. It requires the database cursor and user ID.

```python
@property
def odoo_env(self):
    """Return a server Environment.

    Supported since Odoo 8.
    """
    assert self.client.version_info >= 8.0, 'Not supported'
    return self.client._server.api.Environment(self.cr, self.uid, self.context)
```

--------------------------------

### Odoo API Initialization

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

This section details the initialization of the Odoo API client, including how to specify the server URL, database, user credentials, and other connection parameters.

```APIDOC
## Odoo API Initialization

### Description
Initializes the Odoo API client. You can specify the server URL, database name, user credentials, and API key. If no password is provided, it will be prompted during login. The `server` can be a URL string or a local Odoo instance.

### Method
`__init__`

### Parameters
- **server** (str | list) - The URL of the Odoo instance or a list of services to start locally.
- **db** (str, optional) - The name of the database to connect to.
- **user** (str, optional) - The username for authentication.
- **password** (str, optional) - The password for authentication. If not provided, it will be prompted.
- **api_key** (str, optional) - An API key for authentication.
- **transport** (any, optional) - Specifies the transport mechanism (e.g., for XML-RPC).
- **verbose** (bool, optional) - Enables verbose output for logging.

### Request Example
```python
from odoorpc import ODOO

odoo = ODOO('http://localhost:8069', db='mydatabase', user='admin', password='mypassword')
```

### Response
N/A (Initialization does not return a value, but sets up the client instance.)
```

--------------------------------

### Get Single Odoo Record

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Retrieves a single record based on an ID, search domain, or external ID (xml_id). Raises a ValueError if multiple records are found when a domain is used. Returns None if no record is found.

```python
def get(self, domain, *args, **kwargs):
    """Return a single :class:`Record`.

    The argument `domain` accepts a single integer ``id`` or a search
    domain, or an external ID ``xml_id``.  The return value is a
    :class:`Record` or None.  If multiple records are found,
    a ``ValueError`` is raised.
    """
    if args or kwargs:
        # Passthrough for env['ir.default'].get and alike
        return self._execute('get', domain, *args, **kwargs)
    if isinstance(domain, int):   # a single id
        return Record(self, domain)
    if isinstance(domain, str):  # lookup the xml_id
        rec = self.env.ref(domain)
        if not rec:
            return None
        assert rec._model is self, f'Model mismatch {rec!r} {self!r}'
        return rec
    assert issearchdomain(domain)       # a search domain
    ids = self._execute('search', domain)
    if len(ids) > 1:
        raise ValueError(f'domain matches too many records ({len(ids)})')
    return Record(self, ids[0]) if ids else None
```

--------------------------------

### sudo

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

Returns an environment instance that operates with the privileges of a specified user or the system administrator. This is useful for performing actions as another user.

```APIDOC
## GET /api/sudo

### Description
Returns an environment instance that operates with the privileges of the provided user or the system administrator ('admin' by default, or 'system' if available and appropriate). This allows operations to be performed with elevated permissions.

### Method
GET

### Endpoint
/api/sudo

### Parameters
#### Query Parameters
- **user** (string) - Optional - The username or user ID to impersonate. If not provided, defaults to the system administrator.

### Response
#### Success Response (200)
- **environment** (object) - An environment object operating with sudo privileges.

#### Response Example
```json
{
  "environment": { ... } 
}
```
```

--------------------------------

### Query and Read 'res.country' Model in Odoo

Source: https://odooly.readthedocs.io/en/latest/_sources/tutorial.rst

Illustrates how to interact with the 'res.country' model in Odoo. It covers fetching available keys, searching for countries by name, retrieving country names, and reading country codes and names with sorting.

```python
env['res.country'].keys()
env['res.country'].search(['name like public'])
env['res.country'].search(['name like public']).name
env['res.country'].search(['code > X'], order='code ASC').read('{code} {name}')
```

--------------------------------

### Attribute Assignment Restriction for RecordList

Source: https://odooly.readthedocs.io/en/latest/_modules/odooly

The __setattr__ method prevents direct modification of attributes that represent record fields or the 'id' attribute. It raises an AttributeError, guiding users to use the 'RecordList.write' method for updating record values.

```python
    def __setattr__(self, attr, value):
        if attr in self._model._keys or attr == 'id':
            msg = f"attribute {attr!r} is read-only; use 'RecordList.write' instead."
        else:
            msg = f"has no attribute {attr!r}"
        raise AttributeError("'RecordList' object " + msg)
```
Tokens:
Raw