Odoo Documentation : Fields

Fields

Basic fields

`class openerp.fields.Field(string=None, **kwargs)`

The field descriptor contains the field definition, and manages accesses and assignments of the corresponding field on records. The following attributes may be provided when instanciating a field:

Parameters

string -- the label of the field seen by users (string); if not set, the ORM takes the field name in the class (capitalized).
help -- the tooltip of the field seen by users (string)
readonly -- whether the field is readonly (boolean, by default False)
required -- whether the value of the field is required (boolean, by default False)
index -- whether the field is indexed in database (boolean, by default False)
default -- the default value for the field; this is either a static value, or a function taking a recordset and returning a value
states -- a dictionary mapping state values to lists of UI attribute-value pairs; possible attributes are: 'readonly', 'required', 'invisible'. Note: Any state-based condition requires the state field value to be available on the client-side UI. This is typically done by including it in the relevant views, possibly made invisible if not relevant for the end-user.
groups -- comma-separated list of group xml ids (string); this restricts the field access to the users of the given groups only
copy (bool) -- whether the field value should be copied when the record is duplicated (default: True for normal fields, False for one2many and computed fields, including property fields and related fields)
oldname (string) -- the previous name of this field, so that ORM can rename it automatically at migration

Computed fields

One can define a field whose value is computed instead of simply being read from the database. The attributes that are specific to computed fields are given below. To define such a field, simply provide a value for the attribute compute.

Parameters

compute -- name of a method that computes the field
inverse -- name of a method that inverses the field (optional)
search -- name of a method that implement search on the field (optional)
store -- whether the field is stored in database (boolean, by default False on computed fields)
compute_sudo -- whether the field should be recomputed as superuser to bypass access rights (boolean, by default False)

The methods given for compute, inverse and search are model methods. Their signature is shown in the following example:

upper = fields.Char(compute='_compute_upper',

                    inverse='_inverse_upper',

                    search='_search_upper')

@api.depends('name')

def _compute_upper(self):

    for rec in self:

        rec.upper = rec.name.upper() if rec.name else False

def _inverse_upper(self):

    for rec in self:

        rec.name = rec.upper.lower() if rec.upper else False

def _search_upper(self, operator, value):

    if operator == 'like':

        operator = 'ilike'

    return [('name', operator, value)]

The compute method has to assign the field on all records of the invoked recordset. The decorator openerp.api.depends()must be applied on the compute method to specify the field dependencies; those dependencies are used to determine when to recompute the field; recomputation is automatic and guarantees cache/database consistency. Note that the same method can be used for several fields, you simply have to assign all the given fields in the method; the method will be invoked once for all those fields.

By default, a computed field is not stored to the database, and is computed on-the-fly. Adding the attribute store=True will store the field's values in the database. The advantage of a stored field is that searching on that field is done by the database itself. The disadvantage is that it requires database updates when the field must be recomputed.

The inverse method, as its name says, does the inverse of the compute method: the invoked records have a value for the field, and you must apply the necessary changes on the field dependencies such that the computation gives the expected value. Note that a computed field without an inverse method is readonly by default.

The search method is invoked when processing domains before doing an actual search on the model. It must return a domain equivalent to the condition: field operator value.

Related fields

The value of a related field is given by following a sequence of relational fields and reading a field on the reached model. The complete sequence of fields to traverse is specified by the attribute

Parameters

related -- sequence of field names

Some field attributes are automatically copied from the source field if they are not redefined: string, help, readonly, required (only if all fields in the sequence are required), groups, digits, size, translate, sanitize, selection, comodel_name, domain, context. All semantic-free attributes are copied from the source field.

By default, the values of related fields are not stored to the database. Add the attribute store=True to make it stored, just like computed fields. Related fields are automatically recomputed when their dependencies are modified.

Company-dependent fields

Formerly known as 'property' fields, the value of those fields depends on the company. In other words, users that belong to different companies may see different values for the field on a given record.

Parameters

company_dependent -- whether the field is company-dependent (boolean)

Incremental definition

A field is defined as class attribute on a model class. If the model is extended (see Model), one can also extend the field definition by redefining a field with the same name and same type on the subclass. In that case, the attributes of the field are taken from the parent class and overridden by the ones given in subclasses.

For instance, the second class below only adds a tooltip on the field state:

class First(models.Model):

    _name = 'foo'

    state = fields.Selection([...], required=True)

class Second(models.Model):

    _inherit = 'foo'

    state = fields.Selection(help="Blah blah blah")

`class openerp.fields.Char(string=None, **kwargs)`

Bases: openerp.fields._String

Basic string field, can be length-limited, usually displayed as a single-line string in clients

Parameters

size (int) -- the maximum size of values stored for that field
translate (bool) -- whether the values of this field can be translated

The precision digits are given by the attribute

Parameters

digits -- a pair (total, decimal), or a function taking a database cursor and returning a pair (total, decimal)

`class openerp.fields.Text(string=None, **kwargs)`

Bases: openerp.fields._String

Very similar to Char but used for longer contents, does not have a size and usually displayed as a multiline text box.

Parameters

translate -- whether the value of this field can be translated

`class openerp.fields.Selection(selection=None, string=None, **kwargs)`

Bases: openerp.fields.Field

Parameters

selection -- specifies the possible values for this field. It is given as either a list of pairs (value, string), or a model method, or a method name.
selection_add -- provides an extension of the selection in the case of an overridden field. It is a list of pairs (value, string).

The attribute selection is mandatory except in the case of related fields or field extensions.

`class openerp.fields.Html(string=None, **kwargs)`

Bases: openerp.fields._String

`class openerp.fields.Date(string=None, **kwargs)`

Bases: openerp.fields.Field

`static context_today(record, timestamp=None)`

Return the current date as seen in the client's timezone in a format fit for date fields. This method may be used to compute default values.

Parameters

timestamp (datetime) -- optional datetime value to use instead of the current date and time (must be a datetime, regular dates can't be converted between timezones.)

Return type

str

`static from_string(value)`

Convert an ORM value into a date value.

`static to_string(value)`

Convert a date value into the format expected by the ORM.

`static today(*args)`

Return the current day in the format expected by the ORM. This function may be used to compute default values.

`class openerp.fields.Datetime(string=None, **kwargs)`

Bases: openerp.fields.Field

`static context_timestamp(record, timestamp)`

Returns the given timestamp converted to the client's timezone. This method is not meant for use as a _defaults initializer, because datetime fields are automatically converted upon display on client side. For _defaults you fields.datetime.now()should be used instead.

Parameters

timestamp (datetime) -- naive datetime value (expressed in UTC) to be converted to the client timezone

Return type

datetime

Returns

timestamp converted to timezone-aware datetime in context timezone

`static from_string(value)`

Convert an ORM value into a datetime value.

`static now(*args)`

Return the current day and time in the format expected by the ORM. This function may be used to compute default values.

`static to_string(value)`

Convert a datetime value into the format expected by the ORM.

Relational fields

`class openerp.fields.Many2one(comodel_name=None, string=None, **kwargs)`

Bases: openerp.fields._Relational

The value of such a field is a recordset of size 0 (no record) or 1 (a single record).

Parameters

comodel_name -- name of the target model (string)
domain -- an optional domain to set on candidate values on the client side (domain or string)
context -- an optional context to use on the client side when handling that field (dictionary)
ondelete -- what to do when the referred record is deleted; possible values are: 'set null', 'restrict', 'cascade'
auto_join -- whether JOINs are generated upon search through that field (boolean, by default False)
delegate -- set it to True to make fields of the target model accessible from the current model (corresponds to _inherits)

The attribute comodel_name is mandatory except in the case of related fields or field extensions.

`class openerp.fields.One2many(comodel_name=None, inverse_name=None, string=None, **kwargs)`

Bases: openerp.fields._RelationalMulti

One2many field; the value of such a field is the recordset of all the records in comodel_name such that the field inverse_nameis equal to the current record.

Parameters

comodel_name -- name of the target model (string)
inverse_name -- name of the inverse Many2one field in comodel_name (string)
domain -- an optional domain to set on candidate values on the client side (domain or string)
context -- an optional context to use on the client side when handling that field (dictionary)
auto_join -- whether JOINs are generated upon search through that field (boolean, by default False)
limit -- optional limit to use upon read (integer)

The attributes comodel_name and inverse_name are mandatory except in the case of related fields or field extensions.

`class openerp.fields.Many2many(comodel_name=None, relation=None, column1=None, column2=None, string=None, **kwargs)`

Bases: openerp.fields._RelationalMulti

Many2many field; the value of such a field is the recordset.

Parameters

comodel_name -- name of the target model (string)

The attribute comodel_name is mandatory except in the case of related fields or field extensions.

Parameters

relation -- optional name of the table that stores the relation in the database (string)
column1 -- optional name of the column referring to "these" records in the table relation (string)
column2 -- optional name of the column referring to "those" records in the table relation (string)

The attributes relation, column1 and column2 are optional. If not given, names are automatically generated from model names, provided model_name and comodel_name are different!

Parameters

domain -- an optional domain to set on candidate values on the client side (domain or string)
context -- an optional context to use on the client side when handling that field (dictionary)
limit -- optional limit to use upon read (integer)

`class openerp.fields.Reference(selection=None, string=None, **kwargs)`

Bases: openerp.fields.Selection