Models

Model

class trytond.model.Model([id[, \**kwargs]])

The base class that every kind of model inherits.

Class attributes are:

Model.__name__

The a unique name to reference the model throughout the platform.

Model.__access__

A set that contains the names of relation field for which the access rights are also checked for this model.

Model.__rpc__

A dictionary with method name as key and an instance of RPC as value.

Model._rec_name

The name of the field used as name of records. The default value is name.

Model.id

The definition of the field id of records.

Model.__queue__

Return a queue caller for the model. The called method will be pushed into the queue.

Model._fields

A dictionary with the field name as key and its Field instance as value.

Model._record

The record class to store internaly the values of the instances.

Model._defaults

A dictionary with the field name as key and its default method as value.

Class methods:

classmethod Model.__setup__()

Setup the class before adding into the Pool. See trytond.pool.PoolBase.__setup__().

classmethod Model.__post_setup__()

Setup the class after added into the Pool. See trytond.pool.PoolBase.__post_setup__().

classmethod Model.__register__(module_name)

Register the model in ir.model and ir.model.field. See trytond.pool.PoolBase.__register__().

classmethod Model.default_get(fields_names[, 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>().

with_rec_name allow to add rec_name value for each many2one field.

The default_rec_name key in the context can be used to define the value of the _rec_name field.

classmethod Model.fields_get([fields_names[, level]])

Return the definition of each field on the model.

level defines the number of relations to include in the relation field definition.

classmethod Model.__names__([field])

Return a dictionary with the name of the model and the field. It is a convenience-method used to format messages which should include those names.

Instance methods:

Model.on_change(fieldnames)

Return the list of changes by calling on_change method of each field.

Model.on_change_with(fieldnames)

Return the new values of all fields by calling on_change_with method of each field.

Model.on_change_notify(fieldnames)

Returns a list of type and message couple to display on the client side. Available types are info, warning and error.

Note

To be called by the client, this method must be decorated by depends() with the fields needed.

Model.pre_validate()

Validate the instance before being stored. This method is called by the client to validate the instance.

ModelView

class trytond.model.ModelView

Add the requirements to display the record in a view.

Class attributes:

ModelView._buttons

A dictionary with button name as key and the states dictionary for the button. The keys are invisible, readonly and icon which have a PYSON statement as value and depends which has a list of field names on which the states depend. This is used as default attributes of the buttons for the views that show them.

Static methods:

static ModelView.button()

Decorate button’s method to check group access and rule.

static ModelView.button_action(action)

Same as button() but return the id of the XML id action or the action value updated by the returned value of the method.

static ModelView.button_change([\*fields[, methods]])

Same as button() but for button that change values of the fields on client side (similar to on_change).

methods can be used to duplicate the field names from other decorated methods. This is useful if the decorated method calls another method.

Note

Only on instance methods.

Class methods:

classmethod ModelView.fields_view_get([view_id[, view_type[, level]]])

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

{
    'model': model name,
    'type': view type,
    'view_id': view id,
    'arch': XML description,
    'fields': {
        field name: {
            ...
        },
    },
    'field_childs': field for tree,
}
classmethod ModelView.view_toolbar_get()

Returns the model specific actions and exports in a dictionary with keys:

print

a list of available reports.

action

a list of available actions.

relate

a list of available relations.

exports

a list of available exports.

classmethod ModelView.view_attributes()

Returns a list of XPath, attribute, value and an optional depends list. Each element from the XPath will get the attribute set with the JSON encoded value. If the depends list is set its fields are added to the view if the xpath matches at least one element.

Note

The view_id is set to the context when this method is called.

classmethod ModelView.parse_view(tree, type[, view_id[, field_children[, level[, view_depends]]]])

Return the sanitized XML and the corresponding fields definition.

Note

This method is public mainly to allow modification the existing XML of the view by code.

ModelStorage

class trytond.model.ModelStorage

Add storage capability of record.

Class attributes are:

ModelStorage.create_uid

The definition of the Many2One field that points to the user who created the record.

ModelStorage.create_date

The definition of the Timestamp field that stores the creation time of the record.

ModelStorage.write_uid

The definition of the Many2One field that points to the last user who modified the record.

ModelStorage.write_date

The definition of the Timestamp field that stored the last modification time of the record.

ModelStorage.rec_name

The name of the Field used as record name.

Static methods:

static ModelStorage.default_create_uid()

Return the default value for create_uid.

static ModelStorage.default_create_date()

Return the default value for create_date.

Class methods:

classmethod ModelStorage.create(vlist)

Create records.

vlist is list of dictionaries with fields names as key and created values as value and return the list of new instances.

classmethod ModelStorage.trigger_create(records)

Trigger create actions. It calls actions defined in ir.trigger with on_create set and condition is true.

classmethod ModelStorage.read(ids, fields_names)

Return a list of dictionary for the record ids. The dictionary is composed of the fields as key and their values.

fields_names can contain dereferenced fields from related models. Their values will be returned under the referencing field suffixed by a .. The number of dots in the name is not limited.

The virtual fields _write and _delete can be used the read the writeable and deleteable state of the records. Regarding the _timestamp virtual fields it contains a timestamp that is used in the context to make a soft lock preventing update collisions.

Note

The order of the returned list is not guaranteed.

classmethod ModelStorage.index_get_field(name)

Return the index to order of the calls to field get.

classmethod ModelStorage.write(records, values[[, records, values], ...])

Write values on the list of records.

values is a dictionary with fields names as key and writen values as value.

classmethod ModelStorage.trigger_write_get_eligibles(records)

Return eligible records for write actions by triggers. This dictionary is to pass to trigger_write().

classmethod ModelStorage.trigger_write(eligibles)

Trigger write actions. It will call actions defined in ir.trigger with on_write set and condition was false before write() and true after.

classmethod ModelStorage.index_set_field(name)

Return the index to order of the calls to field set.

classmethod ModelStorage.delete(records)

Delete records.

classmethod ModelStorage.trigger_delete(records)

Trigger delete actions. It will call actions defined in ir.trigger with on_delete set and condition is true.

classmethod ModelStorage.copy(records[, default])

Duplicate the records.

default is a dictionary of default value per field name for the created records.

The values of default may be also callable that take a dictionary containing the fields and values of the record copied and return of the value.

The keys of default may use the dotted notation for the One2Many to define the default to pass to its copy operation.

New records are returned following the input order.

classmethod ModelStorage.search(domain[, offset[, limit[, order[, count]]]])

Return a list of records that match the domain.

If offset or limit are set, the result starts at the offset and has the length of the limit.

The order is a list of tuples defining the order of the result:

[ ('field name', 'ASC'), ('other field name', 'DESC'), ... ]

The first element of the tuple is a field name of the model and the second is the sort ordering as ASC for ascending, DESC for descending or empty for a default order. This second element may contain NULLS FIRST or NULLS LAST to sort null values before or after non-null values. If neither is specified the default behavior of the backend is used.

In case the field used is a Many2One, it is also possible to use the dotted notation to sort on a specific field from the target record. Or for a Dict field, the dotted notation is used to sort on the key’s value.

If count is set to True, then the result is the number of records. The count result is limited upto the value of limit if set.

classmethod ModelStorage.search_count(domain[, offset[, limit]])

Return the number of records that match the domain.

The result is limited upto the value of limit if set and reduced by offset.

classmethod ModelStorage.search_read(domain[, offset[, limit[, order[, fields_names]]]])

Call search() and read() at once.

Useful for the client to reduce the number of calls.

classmethod ModelStorage.search_rec_name(name, clause)

searcher for the Function field rec_name.

classmethod ModelStorage.search_global(cls, text)

Yield tuples (record, name, icon) for records matching text.

It is used for the global search.

classmethod ModelStorage.count()

Return an estimation of the number of records stored.

classmethod ModelStorage.browse(ids)

Return a list of record instance for the ids.

classmethod ModelStorage.export_data(records, fields_names)

Return a list of list of values for each records.

The list of values follows fields_names.

Relational fields are defined with / at any depth.

Descriptor on fields are available by appending . and the name of the method on the field that returns the descriptor.

classmethod ModelStorage.export_data_domain(domain, fields_names[, offset[, limit[, order]]])

Call search() and export_data() together.

Useful for the client to reduce the number of calls and the data transfered.

classmethod ModelStorage.import_data(fields_names, data)

Create or update records for all values in data.

The field names of values must be defined in fields_names. It returns the number of imported records.

classmethod ModelStorage.check_xml_record(records, values)

Verify if the records are originating from XML data.

It is used to prevent modification of data coming from XML files.

Note

This method must be overiden to change this behavior.

classmethod ModelStorage.validate(records)

Validate the integrity of records after creation and modification.

This method must be overridden to add validation and must raise an ValidationError if validation fails.

classmethod ModelStorage.validate_fields(records, field_names)

Validate the integrity of records after modification of the fields. This method must be overridden to add validation for the field names set and must raise an exception if validation fails.

Dual methods:

classmethod ModelStorage.save(records)

Save the modification made on the records.

Instance methods:

ModelStorage.resources()

Return a dictionary with the number of attachments (attachment_count), notes (note_count) and unread note (note_unread).

ModelStorage.get_rec_name(name)

getter for the Function field rec_name.

ModelSQL

class trytond.model.ModelSQL

Implement ModelStorage for an SQL database.

Class attributes are:

ModelSQL._table

The name of the database table which is mapped to the class.

If not set, the value of __name__ is used with dots converted to underscores.

ModelSQL._order

The default order parameter of search() method.

ModelSQL._order_name

The name of the field on which the records must be sorted when sorting on a field refering to the model.

If not set, _rec_name is used.

ModelSQL._history

If true, all changes on records are stored in an history table.

ModelSQL._sql_constraints

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

[ (<constraint name>, <constraint>, <xml id>), ... ]
constraint name

The name of the SQL constraint in the database.

constraint

An instance of Constraint

xml id

The message id for gettext()

Class methods:

classmethod ModelSQL.__table__()

Return a SQL Table instance for the Model.

classmethod ModelSQL.__table_history__()

Return a SQL Table instance for the history of Model.

classmethod ModelSQL.__table_handler__([module_name[, history]])

Return a TableHandler for the Model.

classmethod ModelSQL.table_query()

Could be defined to use a custom SQL query instead of a table of the database. It should return a SQL FromItem.

Warning

By default all CRUD operation raises an error on models implementing this method so the create(), write() and delete() methods may also been overriden if needed.

classmethod ModelSQL.history_revisions(ids)

Return a sorted list of all revisions for ids.

The list is composed of the date, id and username of the revision.

classmethod ModelSQL.restore_history(ids, datetime)

Restore the record ids from history at the specified date time.

Restoring a record still generates an entry in the history table.

Warning

No access rights are verified and the records are not validated.

classmethod ModelSQL.restore_history_before(ids, datetime)

Restore the record ids from history before the specified date time.

Restoring a record still generates an entry in the history table.

Warning

No access rights are verified and the records are not validated.

classmethod ModelSQL.search(domain[, offset[, limit[, order[, count[, query]]]]])

Same as ModelStorage.search() with the additional query argument.

If query is set to True, the the result is the SQL query.

classmethod ModelSQL.search_domain(domain[, active_test[, tables]])

Convert a domain into a SQL expression by returning the updated tables dictionary and a SQL expression.

Where tables is a nested dictionary containing the existing joins:

{
    None: (<Table invoice>, None),
    'party': {
        None: (<Table party>, <join_on sql expression>),
        'addresses': {
            None: (<Table address>, <join_on sql expression>),
            },
        },
    }

Dual methods:

classmethod ModelSQL.lock([records])

Take a lock for update on the records or take a lock on the whole table.

Constraint

class trytond.model.Constraint(table)

Represent a SQL constraint for the table.

Instance attributes:

Constraint.table

The SQL Table on which the constraint is defined.

Check

class trytond.model.Check(table, expression)

Represent a check Constraint which enforce the validity of the expression.

Instance attributes:

Check.expression

The SQL expression to check.

Unique

class trytond.model.Unique(table, \*columns)

Represent a unique Constraint which enforce the uniqueness of the group of columns.

Instance attributes:

Unique.columns

The tuple of SQL Column instances.

Unique.operators

The tuple of Equal operators.

Exclude

class trytond.model.Exclude(table[, (expression, operator), ...[, where]])

Represent an exclude Constraint which guarantees that if any two rows are compared on the specified expression using the specified operator not all of these comparisons will return TRUE.

Instance attributes:

Exclude.excludes

The tuple of expression and operator.

Exclude.columns

The tuple of expressions.

Exclude.operators

The tuple of operators.

Exclude.where

The clause for which the exclusion applies.

Workflow

class trytond.model.Workflow

A mixin to handle transition check.

Class attribute:

Workflow._transition_state

The name of the field that will be used to check state transition. The default value is ‘state’.

Workflow._transitions

A set containing tuples of from and to state.

Static methods:

static Workflow.transition(state)

Decorate method to filter records for which the transition is valid and finally to update the state of the filtered record.

ModelSingleton

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.

Class methods:

classmethod ModelSingleton.get_singleton()

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

DictSchemaMixin

class trytond.model.DictSchemaMixin

A mixin for the schema of Dict field.

Class attributes are:

DictSchemaMixin.name

A Char field for the name of the key.

DictSchemaMixin.string

A Char field for the string of the key.

DictSchemaMixin.help

The Char field used as the help text for the key.

DictSchemaMixin.type\_

The Selection field for the type of the key.

The available types are:

  • boolean

  • integer

  • char

  • float

  • numeric

  • date

  • datetime

  • selection

DictSchemaMixin.digits

The Integer field for the digits number when the type is float or numeric.

DictSchemaMixin.domain

A domain constraint on the dictionary key that will be enforced only on the client side.

The key must be referenced by its name in the left operator of the domain. The PYSON evaluation context used to compute the domain is the dictionary value. Likewise the domain is tested using the dictionary value.

DictSchemaMixin.selection

The Text field to store the couple of key and label when the type is selection.

The format is a key/label separated by “:” per line.

DictSchemaMixin.selection_sorted

If the selection must be sorted on label by the client.

DictSchemaMixin.selection_json

The Function field to return the JSON version of the selection.

Static methods:

static DictSchemaMixin.default_digits()

Return the default value for digits.

Class methods:

classmethod DictSchemaMixin.get_keys(records)

Return the definition of the keys for the records.

classmethod DictSchemaMixin.get_relation_fields()

Return a dictionary with the field definition of all the keys like the result of Model.fields_get().

It is possible to disable this method (returns an empty dictionary) by setting in the dict section of the configuration, the Model.__name__ to False.

Instance methods:

DictSchemaMixin.get_selection_json(name)

getter for the selection_json.

DictSchemaMixin.format(value[, lang])

Format the value using the key definition and the language.

MatchMixin

class trytond.model.MatchMixin

A mixin to add to a Model a match method on pattern. The pattern is a dictionary with field name as key and the value to compare. The record matches the pattern if for all dictionary entries, the value of the record is equal or not defined.

Instance methods:

MatchMixin.match(pattern[, match_none])

Return if the instance match the pattern.

If match_none is set None value of the instance will be compared.

UnionMixin

class trytond.model.UnionMixin

A mixin to create a ModelSQL which is the UNION of some ModelSQL’s. The ids of each models are sharded to be unique.

Static methods:

static UnionMixin.union_models()

Return the list of ModelSQL’s names

Class methods:

classmethod UnionMixin.union_shard(column, model)

Return a SQL expression that shards the column containing record id of model name.

classmethod UnionMixin.union_unshard(record_id)

Return the original instance of the record for the sharded id.

classmethod UnionMixin.union_column(name, field, table, Model)

Return the SQL column that corresponds to the field on the union model.

classmethod UnionMixin.union_columns(model)

Return the SQL table and columns to use for the UNION for the model name.

SymbolMixin

class trytond.model.SymbolMixin

A mixin to manage the display of symbols on the client side.

Instance methods:

SymbolMixin.get_symbol(sign[, symbol])

Return a symbol and its position.

The position indicates whether the symbol should appear before (0) or after (1) the value. If no symbol parameter is supplied then the mixin uses the value of attribute named symbol.

DigitsMixin

class trytond.model.DigitsMixin

A mixin to manage the digits of fields.Float.digits and fields.Numeric.digits from a Model.

Instance methods:

DigitsMixin.get_digits()

Return a tuple of two integers to use a digits attribute.

sequence_ordered

trytond.model.sequence_ordered([field_name[, field_label[, order]]])

Return a mixin class which defines the order of a ModelSQL with an Integer field.

field_name indicates the name of the field to be created and its default values is sequence. field_label defines the label which will be used by the field and defaults to Sequence. Order specifies the order direction and defaults to ASC NULLS FIRST.

MultiValueMixin

class trytond.model.MultiValueMixin

A mixin for Model to help having MultiValue fields with multi-values on a ValueMixin. The values are stored by creating one record per pattern. The patterns are the same as those on MatchMixin.

Class methods:

classmethod MultiValueMixin.multivalue_model(field)

Return the ValueMixin on which the values are stored for the field name.

The default is class name suffixed by the field name.

classmethod MultiValueMixin.setter_multivalue(records, name, value, \*\*pattern)

getter method for the trytond.model.fields.Function fields.

Instance methods:

MultiValueMixin.multivalue_records(field)

Return the list of all ValueMixin records linked to the instance.

By default, it returns the value of the first found One2Many linked to the multivalue model or all the records of this one.

MultiValueMixin.multivalue_record(field, \*\*pattern)

Return a new record of ValueMixin linked to the instance.

MultiValueMixin.get_multivalue(name, \*\*pattern)

Return the value of the field name for the pattern.

MultiValueMixin.set_multivalue(name, value, [save, ]\*\*pattern)

Store the value of the field name for the pattern.

If save is true, it will be stored in the database, otherwise the modified ValueMixin records are returned unsaved. save is true by default.

Warning

To customize the pattern, both methods must be override the same way.

ValueMixin

class trytond.model.ValueMixin

A mixin to store the values of MultiValueMixin.

DeactivableMixin

class trytond.model.DeactivableMixin

A mixin to add soft deletion to the model. It renders all the fields as read-only when the record is inactive.

Class attributes are:

DictSchemaMixin.active

The definition of the trytond.model.fields.Boolean field to store soft deletion state.

False values is considered as soft deletion.

tree

trytond.model.tree([parent[, name[, separator]]])

Return a mixin class TreeMixin.

parent indicates the name of the field that defines the parent of the tree and its default value is parent. name indicates the name of the field that defines the name of the record and its default value is name. If separator is set, the get_rec_name() constructs the name by concatenating each parent names using it as separator and search_rec_name() is adapted to search across the tree.

class trytond.model.TreeMixin
classmethod TreeMixin.check_recursion(records)

Helper method that checks if there is no recursion in the tree defined by tree().

avatar_mixin

trytond.model.avatar_mixin([size[, default]])

Return a mixin AvatarMixin.

size defines the size of the avatar image and its default value is 64. default indicates the name of the field to use for generating a default avatar, if it’s not set then no default avatar is generated.

class trytond.model.AvatarMixin
AvatarMixin.avatars

The One2Many field used to store the ir.avatar records.

AvatarMixin.avatar

The Binary field that contains the avatar.

AvatarMixin.avatar_url

The Char field that containts the URL for the avatar.

AvatarMixin.has_avatar

Indicate whether the record has an avatar.

classmethod AvatarMixin.generate_avatar(records, field)

Generate a default avatar for each record using the field.