class trytond.model.Model

This is the base class that every kind of model inherits. It defines common attributes of all models.

Class attributes are:


It contains the a unique name to reference the model throughout the platform.


It contains a dictionary with one or more Model._name as keys. For each key a Many2One field is defined as value. The trytond.model.fields.Many2One fields must be defined in the the current model fields. A referenced model with _inherits is a generalization of the current model which is specialized. In the specialized model it is possible to interact with all attributes and methods of the general model.


It contains a description of the model.


It contains a dictionary with method name as key and a boolean as value. If a method name is in the dictionary then it is allowed to call it remotely. If the value is True then the transaction will be committed.


It contains a dictionary mapping keywords to an error message. By way of example:

_error_messages = {
    'recursive_categories': 'You can not create recursive categories!',
    'wrong_name': 'You can not use " / " in name field!'

It contains the name of the field used as name of records. The default value is ‘name’.

The definition of the field id of records.

Instance methods:

Model.init(cursor, module_name)

Registers the model in ir.model and ir.model.field.

Model.raise_user_error(cursor, error[, error_args[, error_description[, error_description_args[, raise_exception[, context]]]]])

Raises an exception that will be displayed as an error message in the client. error is the key of the error message in _error_messages and error_args is the arguments for the “%”-based substitution of the error message. There is the same parameter for an additional description. The boolean raise_exception can be set to False to retrieve the error message strings.

Model.raise_user_warning(cursor, user, warning_name, warning[, warning_args[, warning_description[, warning_description_args[, context]]]])

Raises an exception that will be displayed as a warning message on the client, if the user has not yet bypassed it. warning_name is used to uniquely identify the warning. Others parameters are like in Model.raise_user_error().


It requires that the cursor will be commited as it stores state of the warning states by users.

Model.default_get(cursor, user, fields_names[, context[, with_rec_name]])

Return a dictionary with the default values for each field in fields_names. Default values are defined by the returned value of each instance method with the pattern default_`field_name`(cursor, user, [context]). with_rec_name allow to add rec_name value for each many2one field.

Model.fields_get(cursor, user[, fields_names[, context]])

Return the definition of each field on the model.


class trytond.model.ModelView

It adds requirements to display a view of the model in the client.

Instance methods:

ModelView.fields_view_get(cursor, user[, view_id[, view_type[, context[, toolbar[, hexmd5]]]]])

Return a view definition used by the client. The definition is:

    'model': model name,
    'arch': XML description,
    'fields': {
        field name: {
    'toolbar': {
        'print': [
        'action': [
        'relate': [
    ''md5': {
ModelView.view_header_get(cursor, user, value[, view_type[, context]])

Return the window title used by the client for the specific view type.


class trytond.model.ModelStorage

It adds storage capability.

Class attributes are:


The definition of the trytond.model.fields.Many2One field create_uid of records. It contains the id of the user who creates the record.


The definition of the trytond.model.fields.DateTime field create_date of records. It contains the datetime of the creation of the record.


The definition of the trytond.model.fields.Many2One field write_uid of the records. It contains the id of the last user who writes on the record.


The definition of the trytond.model.fields.DateTime field write_date of the records. It contains the datetime of the last write on the record.


The definition of the trytond.model.fields.Function field rec_name. It is used in the client to display the records with a single string.


The list of constraints that each record must respect. The definition is:

[ (‘function name’, ‘error keyword’), … ]

where function name is the name of an instance method of the class which must return a boolean (False when the constraint is violated) and error keyword is a key of Model._error_messages.

Instance methods:

ModelStorage.default_create_uid(cursor, user[, context])

Return the default value for create_uid.

ModelStorage.default_create_date(cursor, user[, context])

Return the default value for create_date.

ModelStorage.create(cursor, user, values[, context])

Create a record. values is a dictionary with fields names as key and created values as value., user, ids[, fields_names[, context]])

Return values for the ids. If fields_names is set, there will be only values for these fields otherwise it will be for all fields. If ids is a list of ids, the returned value will be a list of dictionaries. If ids is an integer, the returned value will be a dictionary.

ModelStorage.write(cursor, user, ids, values[, context])

Write values on records. ids can be a list of ids or an id. values is a dictionary with fields names as key and writen values as value.

ModelStorage.delete(cursor, user, ids[, context])

Delete records. ids can be a list of ids or an id.

ModelStorage.copy(cursor, user, ids[, default[, context]])

Duplicate the records. ids can be a list of ids or an id. default is a dictionary of default value for the created records., user, domain[, offset[, limit[, order[, context[, count]]]]])

Return a list of ids that match the domain.

ModelStorage.search_count(cursor, user, domain[, context])

Return the number of records that match the domain.

ModelStorage.search_read(cursor, user, domain[, offset[, limit[, order[, context[, fields_names]]]]])

Call search() and read() at once. Useful for the client to reduce the number of calls.

ModelStorage.get_rec_name(cursor, user, ids, name[, context])

Getter for the trytond.model.fields.Function field rec_name.

ModelStorage.search_rec_name(cursor, user, name, clause[, context])

Searcher for the trytond.model.fields.Function field rec_name.

ModelStorage.browse(cursor, user, ids[, context])

Return a BrowseRecordList or a BrowseRecord for the ids.

ModelStorage.export_data(cursor, user, ids, fields_names[, context])

Return a list of list of values for each ids. The list of values follows fields_names. Relational fields are defined with / at any depth.

ModelStorage.import_data(cursor, user, fields_names, datas[, context])

Create records for all values in datas. The field names of values must be defined in fields_names. It returns a tuple containing: the number of records imported, the last values if failed, the exception if failed and the warning if failed.

ModelStorage.check_xml_record(cursor, user, ids, values[, context])

Verify if the ids are originating from XML data. It is used to prevent modification of data coming from XML files. This method must be overiden to change this behavior.

ModelStorage.check_recursion(cursor, user, ids[, parent])

Helper method that checks if there is no recursion in the tree composed with parent as parent field name.

ModelStorage.workflow_trigger_trigger(cursor, user, ids[, context])

Trigger a trigger event on the workflow of records.


class trytond.model.ModelSQL

It implements ModelStorage for an SQL database.

Class attributes are:


The name of the database table which is mapped to the class. If not set, the value of Model._name is used with dots converted to underscores.


A list of tuples defining the default order of the records:

[ (‘field name’, ‘ASC’), (‘other field name’, ‘DESC’), … ]

where the first element of the tuple is a field name of the model and the second is the sort ordering as ASC for ascending or DESC for descending.


The name of the field (or an SQL statement) on which the records must be sorted when sorting on this model from an other model. If not set, ModelStorage._rec_name will be used.


If true, all changes on records will be stored in a history table.


A list of SQL constraints that are added on the table:

[ (‘constraint name’, ‘SQL constraint’, ‘error message key’), … ]
  • constraint name is the name of the SQL constraint in the database
  • SQL constraint is the actual SQL constraint
  • error message key is the key of _sql_error_messages

Like Model._error_messages but for _sql_constraints

Instance methods:

ModelSQL.default_sequence(cursor, user[, context])

Return default value for sequence field if the model has one.


Could be overrided to use a custom SQL query instead of a table of the database. It should return a tuple containing SQL query and arguments.

ModelSQL.search_domain(cursor, user, domain[, active_test[, context]])

Convert a domain into a tuple containing:

  • a SQL clause string
  • a list of arguments for the SQL clause
  • a list of tables used in the SQL clause
  • a list of arguments for the tables


class trytond.model.ModelWorkflow

It adds workflow capability to ModelStorage.

Instance methods:

ModelWorkflow.workflow_trigger_create(cursor, user, ids[, context])

Trigger create event on the workflow of records.

ModelWorkflow.workflow_trigger_write(cursor, user, ids[, context])

Trigger write event on the workflow of records.

ModelWorkflow.workflow_trigger_validate(cursor, user, ids[, context])

Trigger validate event on the workflow of records.

ModelWorkflow.workflow_trigger_delete(cursor, user, ids[, context])

Trigger delete event on the workflow of records.


class trytond.model.ModelSingleton

Modify ModelStorage into a singleton. This means that there will be only one record of this model. It is commonly used to store configuration value.

Instance methods:

ModelSingleton.get_singleton_id(cursor, user[, context])

Return the id of the unique record if there is one.