SYMBOL INDEX (4290 symbols across 224 files)

FILE: doc/conf.py
  function get_info (line 8) | def get_info():

FILE: setup.py
  function read (line 14) | def read(fname):
  function get_version (line 20) | def get_version():
  class rnc2rng (line 25) | class rnc2rng(Command):
    method initialize_options (line 29) | def initialize_options(self):
    method finalize_options (line 32) | def finalize_options(self):
    method run (line 35) | def run(self):

FILE: trytond/admin.py
  function run (line 21) | def run(options):
  function validate (line 130) | def validate(models, percentage=100):

FILE: trytond/backend/database.py
  class DatabaseInterface (line 13) | class DatabaseInterface(object):
    method __new__ (line 20) | def __new__(cls, name=''):
    method __init__ (line 23) | def __init__(self, name=''):
    method connect (line 26) | def connect(self):
    method get_connection (line 29) | def get_connection(self, autocommit=False, readonly=False):
    method put_connection (line 32) | def put_connection(self, connection, close=False):
    method close (line 35) | def close(self):
    method create (line 39) | def create(cls, connection, database_name):
    method drop (line 43) | def drop(cls, connection, database_name):
    method list (line 46) | def list(self, hostname=None):
    method init (line 49) | def init(self):
    method test (line 52) | def test(self, hostname=None):
    method nextid (line 58) | def nextid(self, connection, table):
    method setnextid (line 61) | def setnextid(self, connection, table, value):
    method currid (line 64) | def currid(self, connection, table):
    method lock (line 68) | def lock(cls, connection, table):
    method lock_id (line 71) | def lock_id(self, id, timeout=None):
    method has_constraint (line 74) | def has_constraint(self, constraint):
    method has_returning (line 77) | def has_returning(self):
    method has_multirow_insert (line 80) | def has_multirow_insert(self):
    method has_select_for (line 83) | def has_select_for(self):
    method get_select_for_skip_locked (line 86) | def get_select_for_skip_locked(self):
    method has_window_functions (line 89) | def has_window_functions(self):
    method has_unaccent (line 92) | def has_unaccent(self):
    method has_unaccent_indexable (line 95) | def has_unaccent_indexable(self):
    method unaccent (line 98) | def unaccent(self, value):
    method has_similarity (line 101) | def has_similarity(self):
    method similarity (line 104) | def similarity(self, column, value):
    method has_search_full_text (line 107) | def has_search_full_text(self):
    method format_full_text (line 110) | def format_full_text(self, *documents, language=None):
    method format_full_text_query (line 113) | def format_full_text_query(self, query, language=None):
    method search_full_text (line 116) | def search_full_text(self, document, query):
    method rank_full_text (line 119) | def rank_full_text(self, document, query, normalize=None):
    method has_sequence (line 124) | def has_sequence(cls):
    method sequence_exist (line 127) | def sequence_exist(self, connection, name):
    method sequence_create (line 132) | def sequence_create(
    method sequence_update (line 138) | def sequence_update(
    method sequence_rename (line 144) | def sequence_rename(self, connection, old_name, new_name):
    method sequence_delete (line 149) | def sequence_delete(self, connection, name):
    method sequence_next_number (line 154) | def sequence_next_number(self, connection, name):
    method has_channel (line 159) | def has_channel(self):
    method sql_type (line 162) | def sql_type(self, type_):
    method sql_format (line 165) | def sql_format(self, type_, value):
    method json_get (line 168) | def json_get(self, column, key=None):
    method json_key_exists (line 171) | def json_key_exists(self, column, key):
    method json_any_keys_exist (line 174) | def json_any_keys_exist(self, column, keys):
    method json_all_keys_exist (line 177) | def json_all_keys_exist(self, column, keys):
    method json_contains (line 180) | def json_contains(self, column, json):

FILE: trytond/backend/postgresql/database.py
  function unescape_quote (line 52) | def unescape_quote(s):
  function replace_special_values (line 58) | def replace_special_values(s, **mapping):
  class LoggingCursor (line 64) | class LoggingCursor(cursor):
    method execute (line 65) | def execute(self, sql, args=None):
  class ForSkipLocked (line 71) | class ForSkipLocked(For):
    method __str__ (line 72) | def __str__(self):
  class Unaccent (line 77) | class Unaccent(Function):
  class Similarity (line 82) | class Similarity(Function):
  class Match (line 88) | class Match(BinaryOperator):
  class ToTsvector (line 93) | class ToTsvector(Function):
  class Setweight (line 98) | class Setweight(Function):
  class TsQuery (line 103) | class TsQuery(Function):
  class ToTsQuery (line 107) | class ToTsQuery(TsQuery):
  class PlainToTsQuery (line 112) | class PlainToTsQuery(TsQuery):
  class PhraseToTsQuery (line 117) | class PhraseToTsQuery(TsQuery):
  class WebsearchToTsQuery (line 122) | class WebsearchToTsQuery(TsQuery):
  class TsRank (line 127) | class TsRank(Function):
  class AdvisoryLock (line 132) | class AdvisoryLock(Function):
  class TryAdvisoryLock (line 136) | class TryAdvisoryLock(Function):
  class JSONBExtractPath (line 140) | class JSONBExtractPath(Function):
  class JSONKeyExists (line 145) | class JSONKeyExists(BinaryOperator):
  class _BinaryOperatorArray (line 150) | class _BinaryOperatorArray(BinaryOperator):
    method _operands (line 154) | def _operands(self):
    method params (line 160) | def params(self):
  class JSONAnyKeyExist (line 167) | class JSONAnyKeyExist(_BinaryOperatorArray):
  class JSONAllKeyExist (line 172) | class JSONAllKeyExist(_BinaryOperatorArray):
  class JSONContains (line 177) | class JSONContains(BinaryOperator):
  class Database (line 182) | class Database(DatabaseInterface):
    method __new__ (line 210) | def __new__(cls, name=_default_name):
    method __init__ (line 241) | def __init__(self, name=_default_name):
    method _connection_params (line 245) | def _connection_params(cls, name):
    method connect (line 254) | def connect(self):
    method get_connection (line 257) | def get_connection(self, autocommit=False, readonly=False):
    method put_connection (line 278) | def put_connection(self, connection, close=False):
    method close (line 281) | def close(self):
    method create (line 288) | def create(cls, connection, database_name, template='template0'):
    method drop (line 300) | def drop(cls, connection, database_name):
    method get_version (line 308) | def get_version(self, connection):
    method list (line 314) | def list(self, hostname=None):
    method init (line 348) | def init(self):
    method test (line 381) | def test(self, hostname=None):
    method _test (line 393) | def _test(cls, connection, hostname=None):
    method nextid (line 413) | def nextid(self, connection, table):
    method setnextid (line 418) | def setnextid(self, connection, table, value):
    method currid (line 422) | def currid(self, connection, table):
    method lock (line 428) | def lock(self, connection, table):
    method lock_id (line 433) | def lock_id(self, id, timeout=None):
    method has_constraint (line 439) | def has_constraint(self, constraint):
    method has_multirow_insert (line 442) | def has_multirow_insert(self):
    method get_table_schema (line 445) | def get_table_schema(self, connection, table_name):
    method current_user (line 456) | def current_user(self):
    method search_path (line 468) | def search_path(self):
    method has_returning (line 486) | def has_returning(self):
    method has_select_for (line 496) | def has_select_for(self):
    method get_select_for_skip_locked (line 499) | def get_select_for_skip_locked(self):
    method has_window_functions (line 513) | def has_window_functions(self):
    method has_sequence (line 517) | def has_sequence(cls):
    method has_proc (line 520) | def has_proc(self, name, property='oid'):
    method has_unaccent (line 539) | def has_unaccent(self):
    method has_unaccent_indexable (line 542) | def has_unaccent_indexable(self):
    method has_similarity (line 545) | def has_similarity(self):
    method similarity (line 548) | def similarity(self, column, value):
    method has_search_full_text (line 551) | def has_search_full_text(self):
    method _search_full_text_language (line 554) | def _search_full_text_language(self, language):
    method format_full_text (line 573) | def format_full_text(self, *documents, language=None):
    method format_full_text_query (line 600) | def format_full_text_query(self, query, language=None):
    method search_full_text (line 618) | def search_full_text(self, document, query):
    method rank_full_text (line 621) | def rank_full_text(self, document, query, normalize=None):
    method sql_type (line 637) | def sql_type(self, type_):
    method sql_format (line 644) | def sql_format(self, type_, value):
    method unaccent (line 650) | def unaccent(self, value):
    method sequence_exist (line 655) | def sequence_exist(self, connection, name):
    method sequence_create (line 666) | def sequence_create(
    method sequence_update (line 675) | def sequence_update(
    method sequence_rename (line 683) | def sequence_rename(self, connection, old_name, new_name):
    method sequence_delete (line 692) | def sequence_delete(self, connection, name):
    method sequence_next_number (line 697) | def sequence_next_number(self, connection, name):
    method has_channel (line 723) | def has_channel(self):
    method has_extension (line 726) | def has_extension(self, extension_name):
    method json_get (line 743) | def json_get(self, column, key=None):
    method json_key_exists (line 749) | def json_key_exists(self, column, key):
    method json_any_keys_exist (line 752) | def json_any_keys_exist(self, column, keys):
    method json_all_keys_exist (line 755) | def json_all_keys_exist(self, column, keys):
    method json_contains (line 758) | def json_contains(self, column, json):
  function convert_json (line 775) | def convert_json(value):

FILE: trytond/backend/postgresql/init.sql
  type ir_configuration (line 3) | CREATE TABLE ir_configuration (
  type ir_model (line 12) | CREATE TABLE ir_model (
  type ir_model_field (line 23) | CREATE TABLE ir_model_field (
  type ir_ui_view (line 39) | CREATE TABLE ir_ui_view (
  type ir_ui_menu (line 51) | CREATE TABLE ir_ui_menu (
  type ir_translation (line 62) | CREATE TABLE ir_translation (
  type ir_lang (line 77) | CREATE TABLE ir_lang (
  type res_user (line 90) | CREATE TABLE res_user (
  type res_group (line 105) | CREATE TABLE res_group (
  type "res_user-res_group" (line 113) | CREATE TABLE "res_user-res_group" (
  type ir_module (line 124) | CREATE TABLE ir_module (
  type ir_module_dependency (line 141) | CREATE TABLE ir_module_dependency (
  type ir_cache (line 157) | CREATE TABLE ir_cache (

FILE: trytond/backend/postgresql/table.py
  class TableHandler (line 18) | class TableHandler(TableHandlerInterface):
    method _init (line 22) | def _init(self, model, history=False):
    method table_exist (line 100) | def table_exist(cls, table_name):
    method table_rename (line 106) | def table_rename(cls, old_name, new_name):
    method column_exist (line 127) | def column_exist(self, column_name):
    method column_rename (line 130) | def column_rename(self, old_name, new_name):
    method _columns (line 146) | def _columns(self):
    method _constraints (line 168) | def _constraints(self):
    method _fk_deltypes (line 194) | def _fk_deltypes(self):
    method _indexes (line 208) | def _indexes(self):
    method _update_definitions (line 223) | def _update_definitions(self, columns=True, constraints=True):
    method alter_size (line 230) | def alter_size(self, column_name, column_type):
    method alter_type (line 239) | def alter_type(self, column_name, column_type):
    method column_is_type (line 247) | def column_is_type(self, column_name, type_, *, size=-1):
    method db_default (line 259) | def db_default(self, column_name, value):
    method add_column (line 273) | def add_column(self, column_name, sql_type, default=None, comment=''):
    method add_fk (line 362) | def add_fk(self, column_name, reference, on_delete=None):
    method drop_fk (line 394) | def drop_fk(self, column_name, table=None):
    method not_null_action (line 397) | def not_null_action(self, column_name, action='add'):
    method add_constraint (line 436) | def add_constraint(self, ident, constraint):
    method drop_constraint (line 450) | def drop_constraint(self, ident, table=None):
    method set_indexes (line 460) | def set_indexes(self, indexes):
    method drop_column (line 481) | def drop_column(self, column_name):
    method drop_table (line 491) | def drop_table(cls, model, table, cascade=False):
  class IndexMixin (line 501) | class IndexMixin:
    method __init_subclass__ (line 505) | def __init_subclass__(cls):
    method definition (line 509) | def definition(cls, index):
    method _get_indexed_expressions (line 541) | def _get_indexed_expressions(cls, index):
    method _get_expression_variables (line 545) | def _get_expression_variables(cls, expression, usage):
  class HashTranslator (line 561) | class HashTranslator(IndexMixin, IndexTranslatorInterface):
    method score (line 565) | def score(cls, index):
    method _get_indexed_expressions (line 572) | def _get_indexed_expressions(cls, index):
  class BTreeTranslator (line 578) | class BTreeTranslator(IndexMixin, IndexTranslatorInterface):
    method score (line 582) | def score(cls, index):
    method _get_expressions (line 596) | def _get_expressions(cls, index):
    method _get_expression_variables (line 602) | def _get_expression_variables(cls, expression, usage):
  class TrigramTranslator (line 611) | class TrigramTranslator(IndexMixin, IndexTranslatorInterface):
    method score (line 615) | def score(cls, index):
    method _get_expressions (line 629) | def _get_expressions(cls, index):
    method _get_expression_variables (line 635) | def _get_expression_variables(cls, expression, usage):

FILE: trytond/backend/sqlite/database.py
  class DatabaseDataError (line 38) | class DatabaseDataError(DatabaseError):
  class SQLiteExtract (line 42) | class SQLiteExtract(Function):
    method extract (line 47) | def extract(lookup_type, date):
  function date_trunc (line 87) | def date_trunc(_type, date):
  function split_part (line 117) | def split_part(text, delimiter, count):
  class SQLitePosition (line 123) | class SQLitePosition(Function):
    method position (line 128) | def position(substring, string):
  function replace (line 137) | def replace(text, pattern, replacement):
  function now (line 141) | def now():
  function to_char (line 150) | def to_char(value, format):
  class SQLiteSubstring (line 194) | class SQLiteSubstring(Function):
  class SQLiteOverlay (line 199) | class SQLiteOverlay(Function):
    method overlay (line 204) | def overlay(string, placing_string, from_, for_=None):
  class SQLiteCharLength (line 210) | class SQLiteCharLength(Function):
  class SQLiteCurrentTimestamp (line 215) | class SQLiteCurrentTimestamp(Function):
  class SQLiteTrim (line 220) | class SQLiteTrim(Trim):
    method __str__ (line 222) | def __str__(self):
    method params (line 241) | def params(self):
  function sign (line 250) | def sign(value):
  function greatest (line 259) | def greatest(*args):
  function least (line 267) | def least(*args):
  function bool_and (line 275) | def bool_and(*args):
  function bool_or (line 279) | def bool_or(*args):
  function cbrt (line 283) | def cbrt(value):
  function div (line 287) | def div(a, b):
  function trunc (line 291) | def trunc(value, digits):
  class JSONExtract (line 306) | class JSONExtract(Function):
  class JSONQuote (line 311) | class JSONQuote(Function):
  class SQLiteCursor (line 316) | class SQLiteCursor(sqlite.Cursor):
    method __enter__ (line 318) | def __enter__(self):
    method __exit__ (line 321) | def __exit__(self, type, value, traceback):
  class SQLiteConnection (line 325) | class SQLiteConnection(sqlite.Connection):
    method cursor (line 327) | def cursor(self):
  class Database (line 331) | class Database(DatabaseInterface):
    method __new__ (line 348) | def __new__(cls, name=_default_name):
    method __init__ (line 354) | def __init__(self, name=_default_name):
    method connect (line 359) | def connect(self):
    method _make_uri (line 422) | def _make_uri(self):
    method get_connection (line 446) | def get_connection(self, autocommit=False, readonly=False):
    method put_connection (line 455) | def put_connection(self, connection=None, close=False):
    method close (line 458) | def close(self):
    method create (line 466) | def create(cls, connection, database_name):
    method drop (line 479) | def drop(cls, connection, database_name):
    method list (line 488) | def list(self, hostname=None):
    method init (line 512) | def init(self):
    method test (line 548) | def test(self, hostname=None):
    method lastid (line 577) | def lastid(self, cursor):
    method lock (line 581) | def lock(self, connection, table):
    method lock_id (line 584) | def lock_id(self, id, timeout=None):
    method has_constraint (line 587) | def has_constraint(self, constraint):
    method has_multirow_insert (line 590) | def has_multirow_insert(self):
    method has_window_functions (line 593) | def has_window_functions(self):
    method sql_type (line 596) | def sql_type(self, type_):
    method sql_format (line 603) | def sql_format(self, type_, value):
    method json_get (line 610) | def json_get(self, column, key=None):
  function adapt_datetime (line 620) | def adapt_datetime(val):
  function convert_interval (line 631) | def convert_interval(value):

FILE: trytond/backend/sqlite/init.sql
  type ir_configuration (line 1) | CREATE TABLE ir_configuration (
  type ir_model (line 7) | CREATE TABLE ir_model (
  type ir_model_field (line 15) | CREATE TABLE ir_model_field (
  type ir_ui_view (line 28) | CREATE TABLE ir_ui_view (
  type ir_ui_menu (line 37) | CREATE TABLE ir_ui_menu (
  type ir_translation (line 44) | CREATE TABLE ir_translation (
  type ir_lang (line 56) | CREATE TABLE ir_lang (
  type res_user (line 66) | CREATE TABLE res_user (
  type res_group (line 76) | CREATE TABLE res_group (
  type "res_user-res_group" (line 81) | CREATE TABLE "res_user-res_group" (
  type ir_module (line 87) | CREATE TABLE ir_module (
  type ir_module_dependency (line 97) | CREATE TABLE ir_module_dependency (
  type ir_cache (line 107) | CREATE TABLE ir_cache (

FILE: trytond/backend/sqlite/table.py
  function _escape_identifier (line 21) | def _escape_identifier(name):
  class TableHandler (line 25) | class TableHandler(TableHandlerInterface):
    method _init (line 29) | def _init(self, model, history=False):
    method table_exist (line 50) | def table_exist(cls, table_name):
    method table_rename (line 86) | def table_rename(cls, old_name, new_name):
    method column_exist (line 101) | def column_exist(self, column_name):
    method _recreate_table (line 104) | def _recreate_table(self, update_columns=None, drop_columns=None):
    method column_rename (line 138) | def column_rename(self, old_name, new_name):
    method _columns (line 156) | def _columns(self):
    method _indexes (line 179) | def _indexes(self):
    method _update_definitions (line 189) | def _update_definitions(self, columns=True):
    method alter_size (line 193) | def alter_size(self, column_name, column_type):
    method alter_type (line 196) | def alter_type(self, column_name, column_type):
    method column_is_type (line 199) | def column_is_type(self, column_name, type_, *, size=-1):
    method db_default (line 211) | def db_default(self, column_name, value):
    method add_column (line 214) | def add_column(self, column_name, sql_type, default=None, comment=''):
    method _add_raw_column (line 223) | def _add_raw_column(self, column_name, column_type, default=None,
    method add_fk (line 283) | def add_fk(self, column_name, reference, on_delete=None):
    method drop_fk (line 286) | def drop_fk(self, column_name, table=None):
    method not_null_action (line 289) | def not_null_action(self, column_name, action='add'):
    method add_constraint (line 300) | def add_constraint(self, ident, constraint):
    method drop_constraint (line 303) | def drop_constraint(self, ident, table=None):
    method set_indexes (line 306) | def set_indexes(self, indexes):
    method drop_column (line 331) | def drop_column(self, column_name):
    method drop_table (line 345) | def drop_table(cls, model, table, cascade=False):
  class IndexMixin (line 356) | class IndexMixin:
    method __init_subclass__ (line 358) | def __init_subclass__(cls):
    method definition (line 362) | def definition(cls, index):
    method _get_expression_variables (line 384) | def _get_expression_variables(cls, expression, usage):
  class IndexTranslator (line 401) | class IndexTranslator(IndexMixin, IndexTranslatorInterface):
    method score (line 404) | def score(cls, index):

FILE: trytond/backend/table.py
  class TableHandlerInterface (line 9) | class TableHandlerInterface(object):
    method __new__ (line 17) | def __new__(cls, model, history=False):
    method _init (line 26) | def _init(self, model, history=False):
    method table_exist (line 45) | def table_exist(cls, table_name):
    method table_rename (line 49) | def table_rename(cls, old_name, new_name):
    method column_exist (line 52) | def column_exist(self, column_name):
    method column_rename (line 55) | def column_rename(self, old_name, new_name):
    method alter_size (line 58) | def alter_size(self, column_name, column_type):
    method alter_type (line 61) | def alter_type(self, column_name, column_type):
    method column_is_type (line 64) | def column_is_type(self, column_name, type_, *, size=-1):
    method db_default (line 67) | def db_default(self, column_name, value):
    method add_column (line 70) | def add_column(self, column_name, abstract_type, default=None, comment...
    method add_fk (line 73) | def add_fk(self, column_name, reference, on_delete=None):
    method drop_fk (line 76) | def drop_fk(self, column_name, table=None):
    method not_null_action (line 79) | def not_null_action(self, column_name, action='add'):
    method add_constraint (line 82) | def add_constraint(self, ident, constraint):
    method drop_constraint (line 85) | def drop_constraint(self, ident, table=None):
    method create_index (line 88) | def create_index(self, index):
    method drop_column (line 91) | def drop_column(self, column_name):
    method drop_table (line 95) | def drop_table(cls, model, table, cascade=False):
    method convert_name (line 99) | def convert_name(cls, name, reserved=0):
    method index_translator_for (line 110) | def index_translator_for(self, index):
  class IndexTranslatorInterface (line 120) | class IndexTranslatorInterface:
    method _get_name (line 123) | def _get_name(cls, query, params):
    method definition (line 132) | def definition(cls, index):
    method score (line 136) | def score(cls, index):

FILE: trytond/bus.py
  class _MessageQueue (line 43) | class _MessageQueue:
    method __init__ (line 47) | def __init__(self, timeout):
    method append (line 53) | def append(self, channel, element):
    method get_next (line 57) | def get_next(self, channels, from_id=None):
  class LongPollingBus (line 85) | class LongPollingBus:
    method subscribe (line 94) | def subscribe(cls, database, channels, last_message=None):
    method create_response (line 138) | def create_response(cls, channel, message):
    method _listen (line 147) | def _listen(cls, database):
    method publish (line 205) | def publish(cls, channel, message):
  function subscribe (line 228) | def subscribe(request, database_name):
  function notify (line 258) | def notify(title, body=None, priority=1, user=None, client=None):

FILE: trytond/cache.py
  function _cast (line 28) | def _cast(column):
  function freeze (line 38) | def freeze(o):
  function unfreeze (line 47) | def unfreeze(o):
  function _get_modules (line 56) | def _get_modules(cursor):
  class BaseCache (line 65) | class BaseCache(object):
    method __init__ (line 68) | def __init__(self, name, size_limit=1024, duration=None, context=True):
    method stats (line 85) | def stats(cls):
    method _key (line 93) | def _key(self, key):
    method get (line 103) | def get(self, key, default=None):
    method set (line 106) | def set(self, key, value):
    method clear (line 109) | def clear(self):
    method clear_all (line 113) | def clear_all(cls):
    method sync (line 118) | def sync(cls, transaction):
    method sync_since (line 121) | def sync_since(self, value):
    method commit (line 125) | def commit(cls, transaction):
    method rollback (line 129) | def rollback(cls, transaction):
    method drop (line 133) | def drop(cls, dbname):
  class MemoryCache (line 137) | class MemoryCache(BaseCache):
    method __init__ (line 149) | def __init__(self, *args, **kwargs):
    method _get_cache (line 156) | def _get_cache(self):
    method get (line 171) | def get(self, key, default=None):
    method set (line 186) | def set(self, key, value):
    method clear (line 199) | def clear(self):
    method _clear (line 204) | def _clear(self, dbname, timestamp=None):
    method _clear_all (line 213) | def _clear_all(cls, dbname):
    method sync (line 218) | def sync(cls, transaction):
    method sync_since (line 258) | def sync_since(self, value):
    method commit (line 262) | def commit(cls, transaction):
    method rollback (line 316) | def rollback(cls, transaction):
    method drop (line 320) | def drop(cls, dbname):
    method refresh_pool (line 340) | def refresh_pool(cls, transaction):
    method _listen (line 355) | def _listen(cls, dbname):
  class LRUDict (line 412) | class LRUDict(OrderedDict):
    method __init__ (line 423) | def __init__(self, size_limit,
    method __setitem__ (line 433) | def __setitem__(self, key, value):
    method __missing__ (line 437) | def __missing__(self, key):
    method update (line 447) | def update(self, *args, **kwargs):
    method setdefault (line 451) | def setdefault(self, key, default=None):
    method _check_size_limit (line 456) | def _check_size_limit(self):
  class LRUDictTransaction (line 461) | class LRUDictTransaction(LRUDict):
    method __init__ (line 468) | def __init__(self, *args, **kwargs):
    method clear (line 473) | def clear(self):
    method refresh (line 477) | def refresh(self):

FILE: trytond/commandline.py
  function database_completer (line 18) | def database_completer(parsed_args, **kwargs):
  function module_completer (line 27) | def module_completer(**kwargs):
  function language_completer (line 32) | def language_completer(**kwargs):
  function get_base_parser (line 37) | def get_base_parser():
  function get_parser (line 47) | def get_parser():
  function get_parser_daemon (line 70) | def get_parser_daemon():
  function get_parser_worker (line 79) | def get_parser_worker():
  function get_parser_cron (line 92) | def get_parser_cron():
  function get_parser_admin (line 99) | def get_parser_admin():
  function get_parser_console (line 143) | def get_parser_console():
  function get_parser_stat (line 155) | def get_parser_stat():
  function config_log (line 161) | def config_log(options):
  function pidfile (line 176) | def pidfile(options):

FILE: trytond/config.py
  function get_hostname (line 22) | def get_hostname(netloc):
  function get_port (line 31) | def get_port(netloc):
  function split_netloc (line 36) | def split_netloc(netloc):
  function parse_listen (line 40) | def parse_listen(value):
  function parse_uri (line 45) | def parse_uri(uri):
  class TrytonConfigParser (line 49) | class TrytonConfigParser(configparser.ConfigParser):
    method __init__ (line 51) | def __init__(self):
    method update_environ (line 101) | def update_environ(self):
    method update_etc (line 115) | def update_etc(self, configfile=os.environ.get('TRYTOND_CONFIG')):
    method get (line 128) | def get(self, section, option, *args, **kwargs):
    method getint (line 136) | def getint(self, section, option, *args, **kwargs):
    method getfloat (line 145) | def getfloat(self, section, option, *args, **kwargs):
    method getboolean (line 154) | def getboolean(self, section, option, *args, **kwargs):

FILE: trytond/console.py
  class Console (line 16) | class Console(InteractiveConsole):
    method __init__ (line 17) | def __init__(self, locals=None, filename="<console>", histsize=-1,
    method init_completer (line 23) | def init_completer(selfi, locals):
    method init_history (line 28) | def init_history(self, histfile, histsize):
    method save_history (line 37) | def save_history(self, histfile, histsize):
  function run (line 42) | def run(options):

FILE: trytond/convert.py
  class ParsingError (line 22) | class ParsingError(Exception):
  class DummyTagHandler (line 26) | class DummyTagHandler:
    method __init__ (line 30) | def __init__(self):
    method startElement (line 33) | def startElement(self, name, attributes):
    method characters (line 36) | def characters(self, data):
    method endElement (line 39) | def endElement(self, name):
  class MenuitemTagHandler (line 43) | class MenuitemTagHandler:
    method __init__ (line 45) | def __init__(self, master_handler):
    method startElement (line 49) | def startElement(self, name, attributes):
    method characters (line 162) | def characters(self, data):
    method endElement (line 165) | def endElement(self, name):
    method current_state (line 173) | def current_state(self):
  class RecordTagHandler (line 177) | class RecordTagHandler:
    method __init__ (line 181) | def __init__(self, master_handler):
    method startElement (line 194) | def startElement(self, name, attributes):
    method characters (line 280) | def characters(self, data):
    method endElement (line 293) | def endElement(self, name):
    method current_state (line 321) | def current_state(self):
  class Fs2bdAccessor (line 325) | class Fs2bdAccessor:
    method __init__ (line 331) | def __init__(self, ModelData, pool):
    method get (line 338) | def get(self, module, fs_id):
    method exists (line 343) | def exists(self, module, fs_id):
    method get_browserecord (line 348) | def get_browserecord(self, module, model_name, db_id):
    method set (line 356) | def set(self, module, fs_id, values):
    method reset_browsercord (line 369) | def reset_browsercord(self, module, model_name, ids=None):
    method fetch_new_module (line 384) | def fetch_new_module(self, module):
  class TrytondXmlHandler (line 418) | class TrytondXmlHandler(sax.handler.ContentHandler):
    method __init__ (line 420) | def __init__(self, pool, module, module_state, modules, languages):
    method parse_xmlstream (line 455) | def parse_xmlstream(self, stream):
    method startElement (line 469) | def startElement(self, name, attributes):
    method characters (line 498) | def characters(self, data):
    method endElement (line 502) | def endElement(self, name):
    method current_state (line 523) | def current_state(self):
    method get_id (line 529) | def get_id(self, xml_id):
    method _clean_value (line 542) | def _clean_value(key, record):
    method populate_to_delete (line 565) | def populate_to_delete(self):
    method import_record (line 577) | def import_record(self, model, values, fs_id):
    method create_records (line 697) | def create_records(self, model, vlist, fs_ids):
    method write_records (line 731) | def write_records(self, module, model,
  function post_import (line 786) | def post_import(pool, module, to_delete):

FILE: trytond/cron.py
  function run (line 14) | def run(options):

FILE: trytond/exceptions.py
  class TrytonException (line 5) | class TrytonException(Exception):
  class UserError (line 9) | class UserError(TrytonException):
    method __init__ (line 11) | def __init__(self, message, description='', domain=None):
    method __str__ (line 18) | def __str__(self):
  class UserWarning (line 22) | class UserWarning(TrytonException):
    method __init__ (line 25) | def __init__(self, name, message, description=''):
    method __str__ (line 33) | def __str__(self):
  class LoginException (line 37) | class LoginException(TrytonException):
    method __init__ (line 42) | def __init__(self, name, message, type='password'):
  class ConcurrencyException (line 51) | class ConcurrencyException(TrytonException):
    method __init__ (line 53) | def __init__(self, message):
    method __str__ (line 59) | def __str__(self):
  class RateLimitException (line 63) | class RateLimitException(TrytonException):
  class MissingDependenciesException (line 67) | class MissingDependenciesException(TrytonException):
    method __init__ (line 69) | def __init__(self, missings):
    method __str__ (line 72) | def __str__(self):

FILE: trytond/filestore.py
  class FileStore (line 12) | class FileStore(object):
    method get (line 14) | def get(self, id, prefix=''):
    method getmany (line 19) | def getmany(self, ids, prefix=''):
    method size (line 22) | def size(self, id, prefix=''):
    method sizemany (line 27) | def sizemany(self, ids, prefix=''):
    method set (line 30) | def set(self, data, prefix=''):
    method setmany (line 51) | def setmany(self, data, prefix=''):
    method _filename (line 54) | def _filename(self, id, prefix):
    method _id (line 62) | def _id(self, data):

FILE: trytond/i18n.py
  function gettext (line 8) | def gettext(message_id, *args, **variables):
  function lazy_gettext (line 31) | def lazy_gettext(message_id, *args, **variables):

FILE: trytond/ir/__init__.py
  function register (line 13) | def register():

FILE: trytond/ir/action.py
  class WizardModelError (line 29) | class WizardModelError(ValidationError):
  class EmailError (line 33) | class EmailError(ValidationError):
  class ViewError (line 37) | class ViewError(ValidationError):
  class DomainError (line 41) | class DomainError(ValidationError):
  class ContextError (line 45) | class ContextError(ValidationError):
  class Action (line 52) | class Action(DeactivableMixin, ModelSQL, ModelView):
    method __setup__ (line 68) | def __setup__(cls):
    method default_records (line 75) | def default_records(cls):
    method default_usage (line 79) | def default_usage():
    method write (line 83) | def write(cls, actions, values, *args):
    method get_action_id (line 89) | def get_action_id(cls, action_id):
    method get_action_values (line 111) | def get_action_values(cls, type_, action_ids, columns=None):
    method get_action_value (line 138) | def get_action_value(self):
  class ActionKeyword (line 143) | class ActionKeyword(ModelSQL, ModelView):
    method __setup__ (line 159) | def __setup__(cls):
    method validate_fields (line 173) | def validate_fields(cls, actions, field_names):
    method check_wizard_model (line 178) | def check_wizard_model(cls, actions, field_names=None):
    method _convert_vals (line 199) | def _convert_vals(vals):
    method models_get (line 208) | def models_get():
    method delete (line 214) | def delete(cls, keywords):
    method create (line 221) | def create(cls, vlist):
    method write (line 231) | def write(cls, keywords, values, *args):
    method get_keyword (line 242) | def get_keyword(cls, keyword, value):
  class ActionMixin (line 301) | class ActionMixin(ModelSQL):
    method __setup__ (line 306) | def __setup__(cls):
    method _default_action (line 322) | def _default_action(name):
    method get_action (line 328) | def get_action(cls, ids, names):
    method set_action (line 354) | def set_action(cls, records, name, value):
    method search_action (line 362) | def search_action(cls, name, clause):
    method create (line 366) | def create(cls, vlist):
    method write (line 409) | def write(cls, records, values, *args):
    method delete (line 418) | def delete(cls, records):
    method copy (line 428) | def copy(cls, records, default=None):
    method fetch_action (line 442) | def fetch_action(cls, action_id):
  class ActionReport (line 448) | class ActionReport(ActionMixin, ModelSQL, ModelView):
    method __register__ (line 568) | def __register__(cls, module_name):
    method default_type (line 586) | def default_type():
    method default_report_content (line 590) | def default_report_content():
    method default_direct_print (line 594) | def default_direct_print():
    method default_single (line 598) | def default_single(cls):
    method default_translatable (line 602) | def default_translatable(cls):
    method default_template_extension (line 606) | def default_template_extension():
    method default_extension (line 610) | def default_extension():
    method default_module (line 614) | def default_module():
    method get_is_custom (line 617) | def get_is_custom(self, name):
    method get_report_content (line 621) | def get_report_content(cls, reports, name):
    method set_report_content (line 644) | def set_report_content(cls, records, name, value):
    method get_report_content_html (line 648) | def get_report_content_html(cls, reports, name):
    method set_report_content_html (line 652) | def set_report_content_html(cls, reports, name, value):
    method on_change_with_report_content_name (line 658) | def on_change_with_report_content_name(self, name=None):
    method get_pyson (line 663) | def get_pyson(cls, reports, name):
    method copy (line 673) | def copy(cls, reports, default=None):
    method write (line 690) | def write(cls, reports, values, *args):
    method get_template_cached (line 704) | def get_template_cached(self):
    method set_template_cached (line 707) | def set_template_cached(self, template):
    method validate_fields (line 711) | def validate_fields(cls, reports, field_names):
    method check_record_name (line 716) | def check_record_name(cls, reports, field_names=None):
  class ActionActWindow (line 731) | class ActionActWindow(ActionMixin, ModelSQL, ModelView):
    method __setup__ (line 761) | def __setup__(cls):
    method __register__ (line 768) | def __register__(cls, module_name):
    method default_type (line 788) | def default_type():
    method default_context (line 792) | def default_context():
    method default_search_value (line 796) | def default_search_value():
    method validate (line 800) | def validate(cls, actions):
    method validate_fields (line 805) | def validate_fields(cls, actions, field_names):
    method check_views (line 811) | def check_views(cls, actions):
    method check_domain (line 842) | def check_domain(cls, actions, field_names=None):
    method check_context (line 878) | def check_context(cls, actions, field_names=None):
    method get_views (line 911) | def get_views(self, name):
    method get_domains (line 915) | def get_domains(self, name):
    method get_pyson (line 920) | def get_pyson(cls, windows, name):
    method get (line 942) | def get(cls, xml_id):
  class ActionActWindowView (line 954) | class ActionActWindowView(
    method __register__ (line 964) | def __register__(cls, module_name):
    method create (line 973) | def create(cls, vlist):
    method write (line 980) | def write(cls, windows, values, *args):
    method delete (line 986) | def delete(cls, windows):
  class ActionActWindowDomain (line 992) | class ActionActWindowDomain(
    method __register__ (line 1003) | def __register__(cls, module_name):
    method default_count (line 1012) | def default_count(cls):
    method validate_fields (line 1016) | def validate_fields(cls, actions, field_names):
    method check_domain (line 1021) | def check_domain(cls, actions, field_names=None):
    method create (line 1055) | def create(cls, vlist):
    method write (line 1062) | def write(cls, domains, values, *args):
    method delete (line 1068) | def delete(cls, domains):
  class ActionWizard (line 1074) | class ActionWizard(ActionMixin, ModelSQL, ModelView):
    method default_type (line 1085) | def default_type():
    method get_models (line 1089) | def get_models(cls, name, action_id=None):
  class ActionURL (line 1100) | class ActionURL(ActionMixin, ModelSQL, ModelView):
    method default_type (line 1108) | def default_type():

FILE: trytond/ir/attachment.py
  class Attachment (line 27) | class Attachment(ResourceMixin, ModelSQL, ModelView):
    method __setup__ (line 51) | def __setup__(cls):
    method __register__ (line 59) | def __register__(cls, module_name):
    method default_type (line 87) | def default_type():
    method get_size (line 90) | def get_size(self, name):
    method on_change_with_summary (line 98) | def on_change_with_summary(self, name=None):
    method fields_view_get (line 102) | def fields_view_get(cls, view_id=None, view_type='form', level=None):
  class AttachmentCopyMixin (line 113) | class AttachmentCopyMixin(

FILE: trytond/ir/avatar.py
  class ImageMixin (line 34) | class ImageMixin:
  class Avatar (line 41) | class Avatar(ImageMixin, ResourceMixin, ModelSQL):
    method __setup__ (line 49) | def __setup__(cls):
    method default_uuid (line 58) | def default_uuid(cls):
    method create (line 62) | def create(cls, vlist):
    method write (line 69) | def write(cls, *args):
    method copy (line 75) | def copy(cls, avatars, default=None):
    method url (line 85) | def url(self):
    method get (line 94) | def get(self, size=64):
    method convert (line 117) | def convert(cls, image, **_params):
    method _resize (line 136) | def _resize(self, size=64, **_params):
    method _store_cache (line 145) | def _store_cache(self, size, image):
    method clear_cache (line 154) | def clear_cache(cls, avatars):
  class AvatarCache (line 161) | class AvatarCache(ImageMixin, ModelSQL):
    method __setup__ (line 175) | def __setup__(cls):
  function generate (line 185) | def generate(size, string):

FILE: trytond/ir/cache.py
  class Cache (line 6) | class Cache(ModelSQL):

FILE: trytond/ir/calendar_.py
  class _Calendar (line 10) | class _Calendar(ModelSQL):
    method __setup__ (line 17) | def __setup__(cls):
    method locale (line 37) | def locale(cls, language=None, field='name'):
  class Month (line 54) | class Month(_Calendar):
  class Day (line 62) | class Day(_Calendar):

FILE: trytond/ir/configuration.py
  class Configuration (line 8) | class Configuration(ModelSingleton, ModelSQL):
    method default_language (line 16) | def default_language():
    method get_language (line 20) | def get_language(cls):
    method check (line 30) | def check(self):
    method create (line 35) | def create(cls, vlist):
    method write (line 41) | def write(cls, *args):
    method delete (line 46) | def delete(cls, records):

FILE: trytond/ir/cron.py
  class Cron (line 24) | class Cron(DeactivableMixin, ModelSQL, ModelView):
    method __setup__ (line 80) | def __setup__(cls):
    method __register__ (line 92) | def __register__(cls, module_name):
    method get_timezone (line 105) | def get_timezone(self, name):
    method check_xml_record (line 109) | def check_xml_record(crons, values):
    method view_attributes (line 113) | def view_attributes(cls):
    method compute_next_call (line 120) | def compute_next_call(self, now):
    method run_once (line 147) | def run_once(cls, crons):
    method run (line 155) | def run(cls, db_name):

FILE: trytond/ir/date.py
  class Date (line 9) | class Date(Model):
    method __setup__ (line 14) | def __setup__(cls):
    method today (line 21) | def today(timezone=None):

FILE: trytond/ir/email_.py
  class EmailTemplateError (line 47) | class EmailTemplateError(ValidationError):
  function _get_emails (line 51) | def _get_emails(value):
  function _formataddr (line 56) | def _formataddr(pair):
  class Email (line 69) | class Email(ResourceAccessMixin, ModelSQL, ModelView):
    method __setup__ (line 84) | def __setup__(cls):
    method get_user (line 93) | def get_user(self, name):
    method get_at (line 96) | def get_at(self, name):
    method send (line 100) | def send(cls, to='', cc='', bcc='', subject='', body='',
    method complete (line 198) | def complete(cls, text, limit):
    method _match (line 227) | def _match(cls, name, email):
  class EmailAddress (line 243) | class EmailAddress(ModelSQL):
  class EmailTemplate (line 252) | class EmailTemplate(ModelSQL, ModelView):
    method __setup__ (line 317) | def __setup__(cls):
    method on_change_with_model_name (line 342) | def on_change_with_model_name(self, name=None):
    method validate_fields (line 347) | def validate_fields(cls, templates, field_names):
    method check_subject (line 354) | def check_subject(cls, templates, field_names=None):
    method check_body (line 369) | def check_body(self, templates, field_names=None):
    method check_fields_pyson (line 384) | def check_fields_pyson(cls, templates, field_names=None):
    method get (line 415) | def get(self, record):
    method get_context (line 462) | def get_context(self, record):
    method eval (line 476) | def eval(self, record, pyson, _env=None):
    method _get_default_exclude (line 487) | def _get_default_exclude(cls, record):
    method get_default (line 491) | def get_default(cls, model, record):
    method email_models (line 529) | def email_models(cls):
    method get_addresses (line 533) | def get_addresses(cls, value):
    method _get_address (line 544) | def _get_address(cls, record):
    method get_languages (line 553) | def get_languages(cls, value):
    method _get_language (line 569) | def _get_language(cls, record):
  class EmailTemplate_Report (line 576) | class EmailTemplate_Report(ModelSQL):

FILE: trytond/ir/error.py
  function set_user (line 19) | def set_user(field):
  function reset_user (line 34) | def reset_user(*fields):
  class Error (line 45) | class Error(Workflow, ModelView, ModelSQL):
    method __setup__ (line 78) | def __setup__(cls):
    method default_state (line 108) | def default_state(cls):
    method on_change_with_summary (line 112) | def on_change_with_summary(self, name=None):
    method get_rec_name (line 115) | def get_rec_name(self, name):
    method log (line 121) | def log(cls, origin, exception):
    method clean (line 142) | def clean(cls, date=None):
    method open (line 153) | def open(cls, errors):
    method process (line 160) | def process(cls, errors):
    method solve (line 167) | def solve(cls, errors):

FILE: trytond/ir/export.py
  class _ClearCache (line 9) | class _ClearCache(ModelSQL):
    method create (line 11) | def create(cls, vlist):
    method write (line 16) | def write(cls, *args):
    method delete (line 21) | def delete(cls, records):
  class Export (line 26) | class Export(_ClearCache, ModelSQL, ModelView):
    method __setup__ (line 38) | def __setup__(cls):
    method default_header (line 44) | def default_header(cls):
    method update (line 48) | def update(cls, exports, fields):
  class ExportLine (line 60) | class ExportLine(_ClearCache, ModelSQL, ModelView):

FILE: trytond/ir/lang.py
  class GroupingError (line 25) | class GroupingError(UserError):
  class DateError (line 29) | class DateError(UserError):
  class TranslatableError (line 33) | class TranslatableError(UserError):
  class DeleteDefaultError (line 37) | class DeleteDefaultError(UserError):
  class Lang (line 41) | class Lang(DeactivableMixin, ModelSQL, ModelView):
    method __setup__ (line 86) | def __setup__(cls):
    method search_rec_name (line 105) | def search_rec_name(cls, name, clause):
    method read (line 113) | def read(cls, ids, fields_names):
    method default_translatable (line 135) | def default_translatable():
    method default_direction (line 139) | def default_direction():
    method default_date (line 143) | def default_date():
    method default_grouping (line 147) | def default_grouping():
    method default_decimal_point (line 151) | def default_decimal_point():
    method default_thousands_sep (line 155) | def default_thousands_sep():
    method default_mon_grouping (line 159) | def default_mon_grouping(cls):
    method default_mon_thousands_sep (line 163) | def default_mon_thousands_sep(cls):
    method default_mon_decimal_point (line 167) | def default_mon_decimal_point(cls):
    method default_p_sign_posn (line 171) | def default_p_sign_posn(cls):
    method default_n_sign_posn (line 175) | def default_n_sign_posn(cls):
    method default_negative_sign (line 179) | def default_negative_sign(cls):
    method default_positive_sign (line 183) | def default_positive_sign(cls):
    method default_p_cs_precedes (line 187) | def default_p_cs_precedes(cls):
    method default_n_cs_precedes (line 191) | def default_n_cs_precedes(cls):
    method default_p_sep_by_space (line 195) | def default_p_sep_by_space(cls):
    method default_n_sep_by_space (line 199) | def default_n_sep_by_space(cls):
    method load_translations (line 204) | def load_translations(cls, languages):
    method unload_translations (line 223) | def unload_translations(cls, languages):
    method validate_fields (line 234) | def validate_fields(cls, languages, field_names):
    method check_grouping (line 241) | def check_grouping(cls, langs, fields_names=None):
    method check_date (line 261) | def check_date(cls, langs, field_names=None):
    method check_translatable (line 294) | def check_translatable(cls, langs, field_names=None):
    method check_xml_record (line 311) | def check_xml_record(langs, values):
    method get_translatable_languages (line 315) | def get_translatable_languages(cls):
    method create (line 326) | def create(cls, vlist):
    method write (line 337) | def write(cls, langs, values, *args):
    method delete (line 348) | def delete(cls, langs):
    method get (line 365) | def get(cls, code=None):
    method _group (line 380) | def _group(self, s, monetary=False):
    method format (line 429) | def format(self, percent, value, grouping=False, monetary=False,
    method currency (line 478) | def currency(
    method strftime (line 530) | def strftime(self, value, format=None):
    method format_number (line 563) | def format_number(self, value, digits=None, grouping=True, monetary=No...
    method format_number_symbol (line 572) | def format_number_symbol(self, value, symbol, digits=None, grouping=Tr...
  class LangConfigStart (line 584) | class LangConfigStart(ModelView):
    method default_languages (line 591) | def default_languages(cls):
  class LangConfig (line 597) | class LangConfig(Wizard):
    method transition_load (line 608) | def transition_load(self):
  function get_parent_language (line 620) | def get_parent_language(code):

FILE: trytond/ir/message.py
  class Message (line 10) | class Message(ModelSQL, ModelView):
    method gettext (line 18) | def gettext(cls, *args, **variables):
    method write (line 35) | def write(cls, messages, values, *args):
    method delete (line 40) | def delete(cls, messages):
    method search_rec_name (line 45) | def search_rec_name(cls, name, clause):

FILE: trytond/ir/model.py
  class ConditionError (line 34) | class ConditionError(ValidationError):
  class Model (line 38) | class Model(ModelSQL, ModelView):
    method __setup__ (line 65) | def __setup__(cls):
    method register (line 82) | def register(cls, model, module_name):
    method clean (line 114) | def clean(cls):
    method list_models (line 134) | def list_models(cls):
    method list_history (line 144) | def list_history(cls):
    method get_notification (line 150) | def get_notification(cls):
    method get_name_items (line 159) | def get_name_items(cls):
    method get_names (line 169) | def get_names(cls):
    method global_search (line 178) | def global_search(cls, text, limit, menu='ir.ui.menu'):
    method get_name (line 216) | def get_name(cls, model):
  class ModelField (line 220) | class ModelField(ModelSQL, ModelView):
    method __setup__ (line 269) | def __setup__(cls):
    method register (line 279) | def register(cls, model, module_name, model_id):
    method clean (line 337) | def clean(cls):
    method default_name (line 361) | def default_name():
    method default_field_description (line 365) | def default_field_description():
    method get_rec_name (line 368) | def get_rec_name(self, name):
    method search_rec_name (line 375) | def search_rec_name(cls, name, clause):
    method get_name (line 386) | def get_name(cls, model, field):
    method read (line 402) | def read(cls, ids, fields_names):
  class ModelAccess (line 474) | class ModelAccess(DeactivableMixin, ModelSQL, ModelView):
    method __setup__ (line 489) | def __setup__(cls):
    method check_xml_record (line 496) | def check_xml_record(accesses, values):
    method default_perm_read (line 500) | def default_perm_read():
    method default_perm_write (line 504) | def default_perm_write():
    method default_perm_create (line 508) | def default_perm_create():
    method default_perm_delete (line 512) | def default_perm_delete():
    method get_rec_name (line 515) | def get_rec_name(self, name):
    method search_rec_name (line 519) | def search_rec_name(cls, name, clause):
    method get_access (line 523) | def get_access(cls, models):
    method check (line 611) | def check(cls, model_name, mode='read', raise_exception=True):
    method check_relation (line 632) | def check_relation(cls, model_name, field_name, mode='read'):
    method write (line 669) | def write(cls, accesses, values, *args):
    method create (line 676) | def create(cls, vlist):
    method delete (line 684) | def delete(cls, accesses):
  class ModelFieldAccess (line 691) | class ModelFieldAccess(DeactivableMixin, ModelSQL, ModelView):
    method check_xml_record (line 705) | def check_xml_record(field_accesses, values):
    method default_perm_read (line 709) | def default_perm_read():
    method default_perm_write (line 713) | def default_perm_write():
    method default_perm_create (line 717) | def default_perm_create():
    method default_perm_delete (line 721) | def default_perm_delete():
    method get_rec_name (line 724) | def get_rec_name(self, name):
    method search_rec_name (line 728) | def search_rec_name(cls, name, clause):
    method get_access (line 732) | def get_access(cls, models):
    method check (line 800) | def check(cls, model_name, fields, mode='read', raise_exception=True,
    method write (line 831) | def write(cls, field_accesses, values, *args):
    method create (line 838) | def create(cls, vlist):
    method delete (line 846) | def delete(cls, field_accesses):
  class ModelButton (line 853) | class ModelButton(DeactivableMixin, ModelSQL, ModelView):
    method __register__ (line 886) | def __register__(cls, module_name):
    method __setup__ (line 895) | def __setup__(cls):
    method create (line 907) | def create(cls, vlist):
    method write (line 915) | def write(cls, buttons, values, *args):
    method delete (line 922) | def delete(cls, buttons):
    method copy (line 930) | def copy(cls, buttons, default=None):
    method get_rules (line 939) | def get_rules(cls, model, name):
    method get_reset (line 960) | def get_reset(cls, model, name):
    method get_view_attributes (line 979) | def get_view_attributes(cls, model, name):
  class ModelButtonRule (line 1002) | class ModelButtonRule(ModelSQL, ModelView):
    method default_number_user (line 1015) | def default_number_user(cls):
    method validate_fields (line 1019) | def validate_fields(cls, rules, field_names):
    method check_condition (line 1024) | def check_condition(cls, rules, field_names=None):
    method test (line 1038) | def test(self, record, clicks):
    method create (line 1052) | def create(cls, vlist):
    method write (line 1061) | def write(cls, buttons, values, *args):
    method delete (line 1069) | def delete(cls, buttons):
  class ModelButtonClick (line 1077) | class ModelButtonClick(DeactivableMixin, ModelSQL, ModelView):
    method __setup__ (line 1085) | def __setup__(cls):
    method register (line 1092) | def register(cls, model, name, records):
    method reset (line 1121) | def reset(cls, model, names, records):
    method get_click (line 1136) | def get_click(cls, model, button, record_id):
  class ModelButtonReset (line 1145) | class ModelButtonReset(ModelSQL):
  class ModelData (line 1156) | class ModelData(ModelSQL, ModelView):
    method __setup__ (line 1178) | def __setup__(cls):
    method __register__ (line 1208) | def __register__(cls, module_name):
    method default_noupdate (line 1226) | def default_noupdate():
    method get_out_of_sync (line 1229) | def get_out_of_sync(self, name):
    method search_out_of_sync (line 1233) | def search_out_of_sync(cls, name, clause):
    method create (line 1244) | def create(cls, *args):
    method write (line 1250) | def write(cls, data, values, *args):
    method delete (line 1257) | def delete(cls, records):
    method has_model (line 1262) | def has_model(cls, model):
    method get_id (line 1274) | def get_id(cls, module, fs_id=None):
    method dump_values (line 1296) | def dump_values(cls, values):
    method load_values (line 1302) | def load_values(cls, values):
    method sync (line 1316) | def sync(cls, records):
  class PrintModelGraphStart (line 1356) | class PrintModelGraphStart(ModelView):
    method default_level (line 1364) | def default_level():
  class PrintModelGraph (line 1368) | class PrintModelGraph(Wizard):
    method transition_print_ (line 1378) | def transition_print_(self):
    method do_print_ (line 1381) | def do_print_(self, action):
  class ModelGraph (line 1390) | class ModelGraph(Report):
    method execute (line 1394) | def execute(cls, ids, data):
    method fill_graph (line 1421) | def fill_graph(cls, models, graph, level=1, filter=None):
  class ModelWorkflowGraph (line 1503) | class ModelWorkflowGraph(Report):
    method execute (line 1507) | def execute(cls, ids, data):
    method fill_graph (line 1532) | def fill_graph(cls, models, graph):

FILE: trytond/ir/module.py
  class DeactivateDependencyError (line 23) | class DeactivateDependencyError(UserError):
  function filter_state (line 27) | def filter_state(state):
  class Module (line 37) | class Module(ModelSQL, ModelView):
    method __setup__ (line 57) | def __setup__(cls):
    method __register__ (line 96) | def __register__(cls, module_name):
    method default_state (line 133) | def default_state():
    method get_version (line 136) | def get_version(self, name):
    method get_parents (line 140) | def get_parents(cls, modules, name):
    method get_childs (line 151) | def get_childs(cls, modules, name):
    method delete (line 164) | def delete(cls, records):
    method on_write (line 176) | def on_write(cls, modules):
    method activate (line 199) | def activate(cls, modules):
    method upgrade (line 218) | def upgrade(cls, modules):
    method activate_cancel (line 237) | def activate_cancel(cls, modules):
    method deactivate (line 245) | def deactivate(cls, modules):
    method deactivate_cancel (line 269) | def deactivate_cancel(cls, modules):
    method upgrade_cancel (line 275) | def upgrade_cancel(cls, modules):
    method update_list (line 279) | def update_list(cls):
    method _update_dependencies (line 309) | def _update_dependencies(cls, module, depends=None):
  class ModuleDependency (line 330) | class ModuleDependency(ModelSQL, ModelView):
    method __setup__ (line 346) | def __setup__(cls):
    method __register__ (line 355) | def __register__(cls, module_name):
    method get_state (line 363) | def get_state(self, name):
  class ModuleConfigWizardItem (line 375) | class ModuleConfigWizardItem(sequence_ordered(), ModelSQL, ModelView):
    method __register__ (line 386) | def __register__(cls, module_name):
    method default_state (line 410) | def default_state():
    method default_sequence (line 414) | def default_sequence():
  class ModuleConfigWizardFirst (line 418) | class ModuleConfigWizardFirst(ModelView):
  class ModuleConfigWizardOther (line 423) | class ModuleConfigWizardOther(ModelView):
    method default_percentage (line 430) | def default_percentage():
  class ModuleConfigWizardDone (line 440) | class ModuleConfigWizardDone(ModelView):
  class ModuleConfigWizard (line 445) | class ModuleConfigWizard(Wizard):
    class ConfigStateAction (line 449) | class ConfigStateAction(StateAction):
      method __init__ (line 451) | def __init__(self):
      method get_action (line 454) | def get_action(self):
    method transition_start (line 486) | def transition_start(self):
    method transition_action (line 492) | def transition_action(self):
    method end (line 512) | def end(self):
  class ModuleActivateUpgradeStart (line 516) | class ModuleActivateUpgradeStart(ModelView):
  class ModuleActivateUpgradeDone (line 522) | class ModuleActivateUpgradeDone(ModelView):
  class ModuleActivateUpgrade (line 527) | class ModuleActivateUpgrade(Wizard):
    method check_access (line 545) | def check_access(cls):
    method default_start (line 551) | def default_start(fields):
    method __init__ (line 562) | def __init__(self, session_id):
    method _save (line 565) | def _save(self):
    method transition_upgrade (line 568) | def transition_upgrade(self):
    method transition_next_ (line 587) | def transition_next_(self):
    method end (line 598) | def end(self):
  class ModuleConfig (line 602) | class ModuleConfig(Wizard):
    method do_activate (line 613) | def do_activate(self, action):
    method transition_activate (line 620) | def transition_activate(cls):
  class ModuleConfigStart (line 624) | class ModuleConfigStart(ModelView):

FILE: trytond/ir/note.py
  class Note (line 20) | class Note(ResourceMixin, ModelSQL, ModelView):
    method default_unread (line 32) | def default_unread():
    method get_wrapper (line 36) | def get_wrapper(cls):
    method on_change_with_message_wrapped (line 40) | def on_change_with_message_wrapped(self, name=None):
    method get_unread (line 46) | def get_unread(cls, ids, name):
    method search_unread (line 68) | def search_unread(cls, name, clause):
    method set_unread (line 87) | def set_unread(cls, notes, name, value):
    method write (line 103) | def write(cls, notes, values, *args):
  class NoteRead (line 115) | class NoteRead(ModelSQL):
  class NoteCopyMixin (line 124) | class NoteCopyMixin(

FILE: trytond/ir/queue_.py
  class Queue (line 20) | class Queue(ModelSQL):
    method __setup__ (line 37) | def __setup__(cls):
    method default_enqueued_at (line 50) | def default_enqueued_at(cls):
    method copy (line 54) | def copy(cls, records, default=None):
    method push (line 65) | def push(cls, name, data, scheduled_at=None, expected_at=None):
    method pull (line 83) | def pull(cls, database, connection, name=None):
    method run (line 151) | def run(self):
    method clean (line 185) | def clean(cls, date=None):
    method caller (line 196) | def caller(cls, model):
  class _Model (line 200) | class _Model(object):
    method __init__ (line 201) | def __init__(self, queue, model):
    method __getattr__ (line 205) | def __getattr__(self, name):
  class _Method (line 209) | class _Method(object):
    method __init__ (line 210) | def __init__(self, queue, model, name):
    method __call__ (line 215) | def __call__(self, instances, *args, **kwargs):

FILE: trytond/ir/resource.py
  class ResourceAccessMixin (line 14) | class ResourceAccessMixin(ModelStorage):
    method __setup__ (line 20) | def __setup__(cls):
    method default_resource (line 28) | def default_resource(cls):
    method get_models (line 32) | def get_models():
    method check_access (line 41) | def check_access(cls, ids, mode='read'):
    method _convert_check_access (line 58) | def _convert_check_access(cls, model, mode):
    method read (line 63) | def read(cls, ids, fields_names):
    method delete (line 68) | def delete(cls, records):
    method write (line 73) | def write(cls, records, values, *args):
    method create (line 83) | def create(cls, vlist):
  class ResourceMixin (line 89) | class ResourceMixin(ResourceAccessMixin, ModelStorage, ModelView):
    method __setup__ (line 112) | def __setup__(cls):
    method get_copy_to_resources (line 118) | def get_copy_to_resources(self):
    method on_change_with_copy_to_resources_visible (line 128) | def on_change_with_copy_to_resources_visible(self, name=None):
    method get_last_user (line 131) | def get_last_user(self, name):
    method get_last_modification (line 135) | def get_last_modification(self, name):
    method order_last_modification (line 140) | def order_last_modification(tables):
  class ResourceCopyMixin (line 145) | class ResourceCopyMixin(ModelStorage):
    method get_resources_to_copy (line 148) | def get_resources_to_copy(cls, name):
  function resource_copy (line 152) | def resource_copy(resource, name, string):

FILE: trytond/ir/routes.py
  function get_token (line 32) | def get_token(record):
  function get_config (line 36) | def get_config(names, section='html', default=None):
  function html_editor (line 52) | def html_editor(request, pool, model, record, field):
  function data (line 196) | def data(request, pool, model):
  function avatar (line 287) | def avatar(request, pool, uuid):

FILE: trytond/ir/rule.py
  class DomainError (line 17) | class DomainError(ValidationError):
  class RuleGroup (line 21) | class RuleGroup(ModelSQL, ModelView):
    method __setup__ (line 41) | def __setup__(cls):
    method default_global_p (line 60) | def default_global_p():
    method default_default_p (line 64) | def default_default_p():
    method default_perm_read (line 68) | def default_perm_read():
    method default_perm_write (line 72) | def default_perm_write():
    method default_perm_create (line 76) | def default_perm_create():
    method default_perm_delete (line 80) | def default_perm_delete():
    method delete (line 84) | def delete(cls, groups):
    method create (line 90) | def create(cls, vlist):
    method write (line 97) | def write(cls, groups, vals, *args):
  class Rule (line 103) | class Rule(ModelSQL, ModelView):
    method __setup__ (line 117) | def __setup__(cls):
    method validate_fields (line 125) | def validate_fields(cls, rules, field_names):
    method check_domain (line 130) | def check_domain(cls, rules, field_names=None):
    method _get_context (line 151) | def _get_context():
    method _get_cache_key (line 164) | def _get_cache_key():
    method get (line 169) | def get(cls, model_name, mode='read'):
    method domain_get (line 268) | def domain_get(cls, model_name, mode='read'):
    method query_get (line 302) | def query_get(cls, model_name, mode='read'):
    method delete (line 314) | def delete(cls, rules):
    method create (line 320) | def create(cls, vlist):
    method write (line 327) | def write(cls, rules, vals, *args):

FILE: trytond/ir/sequence.py
  class AffixError (line 18) | class AffixError(ValidationError):
  class MissingError (line 22) | class MissingError(UserError):
  class LastTimestampError (line 26) | class LastTimestampError(ValidationError):
  class SQLSequenceError (line 30) | class SQLSequenceError(ValidationError):
  class SequenceType (line 34) | class SequenceType(ModelSQL, ModelView):
    method __register__ (line 41) | def __register__(cls, module):
  class Sequence (line 50) | class Sequence(DeactivableMixin, ModelSQL, ModelView):
    method __setup__ (line 107) | def __setup__(cls):
    method __register__ (line 117) | def __register__(cls, module):
    method default_type (line 138) | def default_type():
    method default_number_increment (line 142) | def default_number_increment():
    method default_number_next (line 146) | def default_number_next():
    method default_padding (line 150) | def default_padding():
    method default_timestamp_rounding (line 154) | def default_timestamp_rounding():
    method default_timestamp_offset (line 158) | def default_timestamp_offset():
    method default_last_timestamp (line 162) | def default_last_timestamp():
    method get_number_next (line 165) | def get_number_next(self, name):
    method set_number_next (line 177) | def set_number_next(cls, sequences, name, value):
    method view_attributes (line 183) | def view_attributes(cls):
    method create (line 195) | def create(cls, vlist):
    method write (line 204) | def write(cls, *args):
    method delete (line 220) | def delete(cls, sequences):
    method validate (line 227) | def validate(cls, sequences):
    method validate_fields (line 232) | def validate_fields(cls, sequences, field_names):
    method check_affixes (line 237) | def check_affixes(cls, sequences, field_names=None):
    method check_last_timestamp (line 253) | def check_last_timestamp(cls, sequences):
    method _sql_sequence_name (line 264) | def _sql_sequence_name(self):
    method create_sql_sequence (line 268) | def create_sql_sequence(self, number_next=None):
    method update_sql_sequence (line 287) | def update_sql_sequence(self, number_next=None):
    method delete_sql_sequence (line 313) | def delete_sql_sequence(self):
    method _process (line 322) | def _process(cls, string, date=None):
    method _get_substitutions (line 327) | def _get_substitutions(cls, date):
    method _timestamp (line 343) | def _timestamp(sequence):
    method _get_sequence (line 348) | def _get_sequence(cls, sequence):
    method get (line 377) | def get(self, _lock=False):
  class SequenceStrict (line 399) | class SequenceStrict(Sequence):
    method get (line 405) | def get(self, _lock=True):

FILE: trytond/ir/session.py
  class Session (line 16) | class Session(ModelSQL):
    method __setup__ (line 25) | def __setup__(cls):
    method default_key (line 43) | def default_key(cls, nbytes=None):
    method write (line 47) | def write(cls, *args):
    method new (line 54) | def new(cls, values=None):
    method remove (line 62) | def remove(cls, key, domain=None):
    method check (line 77) | def check(cls, user, key, domain=None):
    method check_timeout (line 107) | def check_timeout(cls, user, key, domain=None):
    method reset (line 127) | def reset(cls, key, domain=None):
    method clear (line 144) | def clear(cls, users, domain=None):
    method create (line 153) | def create(cls, vlist):
  class SessionWizard (line 162) | class SessionWizard(ModelSQL):
    method __setup__ (line 169) | def __setup__(cls):
    method default_data (line 174) | def default_data():

FILE: trytond/ir/translation.py
  class OverriddenError (line 45) | class OverriddenError(UserError):
  class TrytonPOFile (line 49) | class TrytonPOFile(polib.POFile):
    method sort (line 51) | def sort(self):
  class Translation (line 56) | class Translation(ModelSQL, ModelView):
    method __setup__ (line 79) | def __setup__(cls):
    method __register__ (line 110) | def __register__(cls, module_name):
    method register_model (line 130) | def register_model(cls, model, module_name):
    method register_fields (line 170) | def register_fields(cls, model, module_name):
    method register_wizard (line 222) | def register_wizard(cls, wizard, module_name):
    method default_fuzzy (line 264) | def default_fuzzy():
    method default_res_id (line 268) | def default_res_id():
    method get_model (line 271) | def get_model(self, name):
    method search_rec_name (line 275) | def search_rec_name(cls, name, clause):
    method search_model (line 288) | def search_model(cls, name, clause):
    method get_language (line 300) | def get_language(cls):
    method view_attributes (line 313) | def view_attributes(cls):
    method get_ids (line 317) | def get_ids(cls, name, ttype, lang, ids, cached_after=None):
    method set_ids (line 429) | def set_ids(cls, name, ttype, lang, ids, values):
    method delete_ids (line 553) | def delete_ids(cls, model, ttype, ids):
    method get_source (line 566) | def get_source(cls, name, ttype, lang, source=None):
    method get_sources (line 573) | def get_sources(cls, args):
    method get_report (line 640) | def get_report(cls, report_name, text):
    method copy (line 663) | def copy(cls, translations, default=None):
    method delete (line 670) | def delete(cls, translations):
    method create (line 684) | def create(cls, vlist):
    method write (line 704) | def write(cls, *args):
    method extra_model_data (line 718) | def extra_model_data(cls, model_data):
    method unique_key (line 729) | def unique_key(self):
    method from_poentry (line 737) | def from_poentry(cls, entry):
    method translation_import (line 749) | def translation_import(cls, lang, module, po_path):
    method translation_export (line 894) | def translation_export(cls, lang, module):
  class TranslationSetStart (line 953) | class TranslationSetStart(ModelView):
  class TranslationSetSucceed (line 958) | class TranslationSetSucceed(ModelView):
  class TranslationSet (line 963) | class TranslationSet(Wizard):
    method extract_report_opendocument (line 978) | def extract_report_opendocument(self, content):
    method extract_report_genshi (line 1011) | def extract_report_genshi(template_class):
    method set_report (line 1038) | def set_report(self):
    method _translate_view (line 1124) | def _translate_view(self, element):
    method set_view (line 1135) | def set_view(self):
    method transition_set_ (line 1222) | def transition_set_(self):
  class TranslationCleanStart (line 1228) | class TranslationCleanStart(ModelView):
  class TranslationCleanSucceed (line 1233) | class TranslationCleanSucceed(ModelView):
  class TranslationClean (line 1238) | class TranslationClean(Wizard):
    method _clean_field (line 1254) | def _clean_field(translation):
    method _clean_model (line 1271) | def _clean_model(translation):
    method _clean_report (line 1292) | def _clean_report(translation):
    method _clean_selection (line 1303) | def _clean_selection(translation):
    method _clean_view (line 1325) | def _clean_view(translation):
    method _clean_wizard_button (line 1334) | def _clean_wizard_button(translation):
    method _clean_help (line 1355) | def _clean_help(translation):
    method transition_clean (line 1373) | def transition_clean(self):
  class TranslationUpdateStart (line 1405) | class TranslationUpdateStart(ModelView):
    method default_language (line 1413) | def default_language():
  class TranslationUpdate (line 1426) | class TranslationUpdate(Wizard):
    method transition_update (line 1442) | def transition_update():
    method do_update (line 1445) | def do_update(self, action):
  class TranslationExportStart (line 1607) | class TranslationExportStart(ModelView):
    method default_language (line 1622) | def default_language(cls):
  class TranslationExportResult (line 1633) | class TranslationExportResult(ModelView):
  class TranslationExport (line 1643) | class TranslationExport(Wizard):
    method transition_export (line 1658) | def transition_export(self):
    method default_result (line 1665) | def default_result(self, fields):
  class TranslationReport (line 1677) | class TranslationReport(Wizard):
    method do_open_ (line 1683) | def do_open_(self, action):

FILE: trytond/ir/trigger.py
  class ConditionError (line 23) | class ConditionError(ValidationError):
  class Trigger (line 27) | class Trigger(DeactivableMixin, ModelSQL, ModelView):
    method __setup__ (line 65) | def __setup__(cls):
    method __register__ (line 79) | def __register__(cls, module_name):
    method validate_fields (line 118) | def validate_fields(cls, triggers, field_names):
    method check_condition (line 123) | def check_condition(cls, triggers, field_names=None):
    method default_limit_number (line 139) | def default_limit_number():
    method on_change_on_time (line 143) | def on_change_on_time(self):
    method on_change_on_create (line 150) | def on_change_on_create(self):
    method on_change_on_write (line 155) | def on_change_on_write(self):
    method on_change_on_delete (line 160) | def on_change_on_delete(self):
    method get_triggers (line 165) | def get_triggers(cls, model_name, mode):
    method eval (line 187) | def eval(self, record):
    method queue_trigger_action (line 198) | def queue_trigger_action(self, records):
    method trigger_action (line 205) | def trigger_action(self, ids):
    method trigger_time (line 281) | def trigger_time(cls):
    method create (line 296) | def create(cls, vlist):
    method write (line 303) | def write(cls, triggers, values, *args):
    method delete (line 309) | def delete(cls, records):
  class TriggerLog (line 315) | class TriggerLog(ModelSQL):
    method __setup__ (line 323) | def __setup__(cls):

FILE: trytond/ir/ui/icon.py
  class Icon (line 13) | class Icon(sequence_ordered(), ModelSQL, ModelView):
    method __setup__ (line 24) | def __setup__(cls):
    method __register__ (line 31) | def __register__(cls, module_name):
    method default_module (line 40) | def default_module():
    method default_sequence (line 44) | def default_sequence():
    method list_icons (line 48) | def list_icons(cls):
    method get_icon (line 61) | def get_icon(self, name):
    method create (line 70) | def create(cls, vlist):
    method write (line 76) | def write(cls, *args):
    method delete (line 81) | def delete(cls, icons):

FILE: trytond/ir/ui/menu.py
  function one_in (line 14) | def one_in(i, j):
  class UIMenu (line 78) | class UIMenu(
    method order_complete_name (line 105) | def order_complete_name(cls, tables):
    method default_icon (line 109) | def default_icon():
    method default_sequence (line 113) | def default_sequence(cls):
    method list_icons (line 117) | def list_icons():
    method search_global (line 124) | def search_global(cls, text):
    method search (line 133) | def search(cls, domain, offset=0, limit=None, order=None, count=False,
    method get_action (line 156) | def get_action(cls, menus, name):
    method set_action (line 186) | def set_action(cls, menus, name, value):
    method get_favorite (line 222) | def get_favorite(cls, menus, name):
  class UIMenuFavorite (line 236) | class UIMenuFavorite(sequence_ordered(), ModelSQL, ModelView):
    method __setup__ (line 246) | def __setup__(cls):
    method default_user (line 255) | def default_user():
    method get (line 259) | def get(cls):
    method set (line 267) | def set(cls, menu_id):
    method unset (line 275) | def unset(cls, menu_id):

FILE: trytond/ir/ui/view.py
  class XMLError (line 22) | class XMLError(ValidationError):
  class View (line 26) | class View(ModelSQL, ModelView):
    method __setup__ (line 73) | def __setup__(cls):
    method default_priority (line 96) | def default_priority():
    method default_module (line 100) | def default_module():
    method get_rec_name (line 103) | def get_rec_name(self, name):
    method show (line 110) | def show(cls, views):
    method get_rng (line 114) | def get_rng(cls, type_):
    method rng_type (line 127) | def rng_type(self):
    method validate (line 133) | def validate(cls, views):
    method check_xml (line 138) | def check_xml(cls, views):
    method get_arch (line 182) | def get_arch(self, name):
    method set_arch (line 197) | def set_arch(cls, views, name, value):
    method delete (line 201) | def delete(cls, views):
    method create (line 208) | def create(cls, vlist):
    method write (line 216) | def write(cls, views, values, *args):
    method _module_index (line 223) | def _module_index(self):
    method view_get (line 232) | def view_get(self, model=None):
    method inherit_apply (line 279) | def inherit_apply(cls, tree, inherit):
    method _inherit_apply_replace (line 294) | def _inherit_apply_replace(cls, tree, element, target):
    method _inherit_apply_replace_attributes (line 303) | def _inherit_apply_replace_attributes(cls, tree, element, target):
    method _inherit_apply_inside (line 309) | def _inherit_apply_inside(cls, tree, element, target):
    method _inherit_apply_after (line 313) | def _inherit_apply_after(cls, tree, element, target):
    method _inherit_apply_before (line 324) | def _inherit_apply_before(cls, tree, element, target):
    method _translate (line 331) | def _translate(cls, element, model, language):
  class ShowViewStart (line 344) | class ShowViewStart(ModelView):
  class ShowView (line 350) | class ShowView(Wizard):
    class ShowStateView (line 354) | class ShowStateView(StateView):
      method __init__ (line 356) | def __init__(self, model_name, buttons):
      method get_view (line 359) | def get_view(self, wizard, state_name):
      method get_defaults (line 370) | def get_defaults(self, wizard, state_name, fields):
  class ViewTreeWidth (line 378) | class ViewTreeWidth(ModelSQL, ModelView):
    method __setup__ (line 389) | def __setup__(cls):
    method delete (line 403) | def delete(cls, records):
    method create (line 408) | def create(cls, vlist):
    method write (line 414) | def write(cls, records, values, *args):
    method set_width (line 419) | def set_width(cls, model, fields):
  class ViewTreeOptional (line 443) | class ViewTreeOptional(ModelSQL, ModelView):
    method __setup__ (line 457) | def __setup__(cls):
    method create (line 470) | def create(cls, vlist):
    method write (line 476) | def write(cls, *args):
    method delete (line 481) | def delete(cls, records):
    method set_optional (line 486) | def set_optional(cls, view_id, fields):
  class ViewTreeState (line 506) | class ViewTreeState(ModelSQL, ModelView):
    method __setup__ (line 519) | def __setup__(cls):
    method default_nodes (line 536) | def default_nodes():
    method default_selected_nodes (line 540) | def default_selected_nodes():
    method set (line 544) | def set(cls, model, domain, child_name, nodes, selected_nodes):
    method get (line 565) | def get(cls, model, domain, child_name):
  class ViewSearch (line 584) | class ViewSearch(ModelSQL, ModelView):
    method __setup__ (line 594) | def __setup__(cls):
    method __register__ (line 601) | def __register__(cls, module):
    method default_user (line 609) | def default_user():
    method validate_fields (line 613) | def validate_fields(cls, searches, field_names):
    method check_domain (line 618) | def check_domain(cls, searches, field_names):
    method get_search (line 651) | def get_search(cls):

FILE: trytond/model/active.py
  class DeactivableMixin (line 11) | class DeactivableMixin(Model):
    method default_active (line 20) | def default_active(cls):
    method __post_setup__ (line 24) | def __post_setup__(cls):

FILE: trytond/model/avatar.py
  function avatar_mixin (line 9) | def avatar_mixin(size=64, default=None):

FILE: trytond/model/descriptors.py
  class dualmethod (line 6) | class dualmethod(object):
    method __init__ (line 23) | def __init__(self, func):
    method __get__ (line 26) | def __get__(self, instance, owner):

FILE: trytond/model/dictschema.py
  class DomainError (line 18) | class DomainError(ValidationError):
  class SelectionError (line 22) | class SelectionError(ValidationError):
  class DictSchemaMixin (line 26) | class DictSchemaMixin(object):
    method __setup__ (line 90) | def __setup__(cls):
    method default_digits (line 98) | def default_digits():
    method default_selection_sorted (line 102) | def default_selection_sorted():
    method on_change_string (line 106) | def on_change_string(self):
    method validate_fields (line 111) | def validate_fields(cls, schemas, field_names):
    method check_domain (line 117) | def check_domain(cls, schemas, field_names=None):
    method check_selection (line 135) | def check_selection(cls, schemas, field_names=None):
    method get_selection_json (line 150) | def get_selection_json(self, name):
    method get_keys (line 158) | def get_keys(cls, records):
    method search_get_keys (line 188) | def search_get_keys(cls, domain, limit=None):
    method get_relation_fields (line 193) | def get_relation_fields(cls):
    method create (line 205) | def create(cls, vlist):
    method write (line 211) | def write(cls, *args):
    method delete (line 216) | def delete(cls, records):
    method format (line 220) | def format(self, value, lang=None):

FILE: trytond/model/digits.py
  class DigitsMixin (line 7) | class DigitsMixin:
    method __setup__ (line 13) | def __setup__(cls):
    method get_digits (line 19) | def get_digits(self):
    method _get_digits (line 28) | def _get_digits(self):
    method write (line 32) | def write(cls, *args):

FILE: trytond/model/fields/binary.py
  function caster (line 12) | def caster(d):
  class Binary (line 20) | class Binary(Field):
    method __init__ (line 28) | def __init__(self, string='', help='', required=False, readonly=False,
    method display_depends (line 41) | def display_depends(self):
    method get (line 47) | def get(self, ids, model, name, values=None):
    method set (line 108) | def set(self, Model, name, ids, value, *args):
    method definition (line 129) | def definition(self, model, language):

FILE: trytond/model/fields/boolean.py
  class Boolean (line 7) | class Boolean(Field):
    method __init__ (line 15) | def __init__(self, string='', help='', readonly=False, domain=None,
    method _domain_add_null (line 25) | def _domain_add_null(self, column, operator, value, expression):

FILE: trytond/model/fields/char.py
  class Char (line 18) | class Char(FieldTranslate):
    method __init__ (line 28) | def __init__(self, string='', size=None, help='', required=False,
    method _get_size (line 53) | def _get_size(self):
    method _set_size (line 56) | def _set_size(self, value):
    method strip (line 63) | def strip(self):
    method strip (line 67) | def strip(self, value):
    method _sql_type (line 72) | def _sql_type(self):
    method __set__ (line 78) | def __set__(self, inst, value):
    method sql_format (line 88) | def sql_format(self, value):
    method set_rpc (line 108) | def set_rpc(self, model):
    method _domain_column (line 116) | def _domain_column(self, operator, column):
    method _domain_value (line 123) | def _domain_value(self, operator, value):
    method convert_domain (line 130) | def convert_domain(self, domain, tables, Model):
    method convert_order (line 191) | def convert_order(self, name, tables, Model):
    method definition (line 232) | def definition(self, model, language):

FILE: trytond/model/fields/date.py
  class SQLite_Date (line 14) | class SQLite_Date(Function):
  class SQLite_DateTime (line 19) | class SQLite_DateTime(Function):
  class SQLite_Time (line 24) | class SQLite_Time(Function):
  class Date (line 29) | class Date(Field):
    method sql_format (line 37) | def sql_format(self, value):
    method sql_cast (line 45) | def sql_cast(self, expression, timezone=None):
  class FormatMixin (line 54) | class FormatMixin(Field):
    method definition (line 56) | def definition(self, model, language):
    method display_depends (line 63) | def display_depends(self):
    method validation_depends (line 70) | def validation_depends(self):
  class Timestamp (line 77) | class Timestamp(FormatMixin, Field):
    method sql_format (line 86) | def sql_format(self, value):
    method sql_cast (line 91) | def sql_cast(self, expression):
  class DateTime (line 97) | class DateTime(Timestamp):
    method __init__ (line 104) | def __init__(self, string='', format='%H:%M:%S', help='', required=False,
    method sql_format (line 119) | def sql_format(self, value):
  class Time (line 126) | class Time(FormatMixin, Field):
    method __init__ (line 134) | def __init__(self, string='', format='%H:%M:%S', help='', required=False,
    method sql_format (line 147) | def sql_format(self, value):
    method sql_cast (line 155) | def sql_cast(self, expression):
  class TimeDelta (line 161) | class TimeDelta(Field):
    method __init__ (line 169) | def __init__(self, string='', converter=None, help='', required=False,
    method sql_format (line 183) | def sql_format(self, value):
    method get (line 196) | def get(cls, ids, model, name, values=None):
    method definition (line 213) | def definition(self, model, language):

FILE: trytond/model/fields/dict.py
  class Dict (line 23) | class Dict(Field):
    method __init__ (line 29) | def __init__(self, schema_model, string='', help='', required=False,
    method get (line 38) | def get(self, ids, model, name, values=None):
    method sql_format (line 52) | def sql_format(self, value):
    method __set__ (line 65) | def __set__(self, inst, value):
    method translated (line 70) | def translated(self, name=None, type_='values'):
    method _domain_column (line 78) | def _domain_column(self, operator, column, key=None):
    method _domain_value (line 88) | def _domain_value(self, operator, value):
    method _domain_add_null (line 105) | def _domain_add_null(self, column, operator, value, expression):
    method convert_domain (line 115) | def convert_domain(self, domain, tables, Model):
    method convert_order (line 166) | def convert_order(self, name, tables, Model):
    method definition (line 175) | def definition(self, model, language):
  class TranslatedDict (line 181) | class TranslatedDict(object):
    method __init__ (line 184) | def __init__(self, name, type_):
    method __get__ (line 189) | def __get__(self, inst, cls):

FILE: trytond/model/fields/field.py
  function domain_validate (line 26) | def domain_validate(value):
  function states_validate (line 51) | def states_validate(value):
  function depends_validate (line 65) | def depends_validate(value):
  function context_validate (line 69) | def context_validate(value):
  function size_validate (line 73) | def size_validate(value):
  function search_order_validate (line 81) | def search_order_validate(value):
  function _set_value (line 88) | def _set_value(record, field):
  function depends (line 106) | def depends(*fields, **kwargs):
  function _iter_eval_fields (line 129) | def _iter_eval_fields(value):
  function get_eval_fields (line 143) | def get_eval_fields(value):
  function instanciate_values (line 148) | def instanciate_values(Target, value, **extra):
  function instantiate_context (line 177) | def instantiate_context(field, record):
  function on_change_result (line 192) | def on_change_result(record):
  function with_inactive_records (line 196) | def with_inactive_records(func):
  function sanitize_sql_expression (line 220) | def sanitize_sql_expression(expression):
  class Field (line 228) | class Field(object):
    method __init__ (line 233) | def __init__(self, string='', help='', required=False, readonly=False,
    method string (line 293) | def string(self):
    method string (line 297) | def string(self, value):
    method help (line 301) | def help(self):
    method help (line 305) | def help(self, value):
    method _get_domain (line 308) | def _get_domain(self):
    method _set_domain (line 311) | def _set_domain(self, value):
    method _get_states (line 319) | def _get_states(self):
    method _set_states (line 322) | def _set_states(self, value):
    method _get_depends (line 328) | def _get_depends(self):
    method _set_depends (line 331) | def _set_depends(self, value):
    method display_depends (line 339) | def display_depends(self):
    method edition_depends (line 344) | def edition_depends(self):
    method validation_depends (line 351) | def validation_depends(self):
    method _get_context (line 356) | def _get_context(self):
    method _set_context (line 359) | def _set_context(self, value):
    method __get__ (line 365) | def __get__(self, inst, cls):
    method __set__ (line 373) | def __set__(self, inst, value):
    method sql_format (line 384) | def sql_format(self, value):
    method sql_type (line 395) | def sql_type(self):
    method sql_cast (line 399) | def sql_cast(self, expression):
    method sql_column (line 402) | def sql_column(self, table):
    method _domain_column (line 405) | def _domain_column(self, operator, column):
    method _domain_value (line 408) | def _domain_value(self, operator, value):
    method _domain_add_null (line 416) | def _domain_add_null(self, column, operator, value, expression):
    method convert_domain (line 426) | def convert_domain(self, domain, tables, Model):
    method convert_order (line 442) | def convert_order(self, name, tables, Model):
    method set_rpc (line 452) | def set_rpc(self, model):
    method definition (line 465) | def definition(self, model, language):
    method definition_translations (line 524) | def definition_translations(self, model, language):
  class FieldTranslate (line 535) | class FieldTranslate(Field):
    method _get_translation_join (line 537) | def _get_translation_join(
    method _get_translation_column (line 636) | def _get_translation_column(self, Model, name, domain=None):
    method convert_domain (line 655) | def convert_domain(self, domain, tables, Model):
    method _get_translation_order (line 675) | def _get_translation_order(self, tables, Model, name):
    method convert_order (line 711) | def convert_order(self, name, tables, Model):
    method definition (line 719) | def definition(self, model, language):

FILE: trytond/model/fields/float.py
  function digits_validate (line 9) | def digits_validate(value):
  function _get_digits_depends (line 22) | def _get_digits_depends(field):
  class Float (line 29) | class Float(Field):
    method __init__ (line 37) | def __init__(self, string='', digits=None, help='', required=False,
    method _get_digits (line 54) | def _get_digits(self):
    method _set_digits (line 57) | def _set_digits(self, value):
    method definition (line 63) | def definition(self, model, language):
    method display_depends (line 70) | def display_depends(self):
    method edition_depends (line 74) | def edition_depends(self):
    method validation_depends (line 78) | def validation_depends(self):

FILE: trytond/model/fields/function.py
  function getter_context (line 14) | def getter_context(func):
  class Function (line 30) | class Function(Field):
    method __init__ (line 35) | def __init__(self, field, getter, setter=None, searcher=None,
    method __copy__ (line 60) | def __copy__(self):
    method __deepcopy__ (line 66) | def __deepcopy__(self, memo):
    method __getattr__ (line 72) | def __getattr__(self, name):
    method __getitem__ (line 75) | def __getitem__(self, name):
    method __setattr__ (line 78) | def __setattr__(self, name, value):
    method set_rpc (line 85) | def set_rpc(self, model):
    method sql_format (line 88) | def sql_format(self, value):
    method sql_type (line 91) | def sql_type(self):
    method convert_domain (line 94) | def convert_domain(self, domain, tables, Model):
    method get (line 107) | def get(self, ids, Model, name, values=None):
    method set (line 143) | def set(self, Model, name, ids, value, *args):
    method __get__ (line 159) | def __get__(self, inst, cls):
    method __set__ (line 172) | def __set__(self, inst, value):
    method definition (line 175) | def definition(self, model, language):
    method getter_multiple (line 182) | def getter_multiple(self, method):
  function getter (line 191) | def getter(name):
  function setter (line 194) | def setter(name):
  class MultiValue (line 200) | class MultiValue(Function):
    method __init__ (line 202) | def __init__(self, field, loading='lazy'):
    method __copy__ (line 207) | def __copy__(self):
    method __deepcopy__ (line 210) | def __deepcopy__(self, memo):

FILE: trytond/model/fields/integer.py
  class Integer (line 6) | class Integer(Field):
  class BigInteger (line 15) | class BigInteger(Integer):

FILE: trytond/model/fields/many2many.py
  class Many2Many (line 21) | class Many2Many(Field):
    method __init__ (line 27) | def __init__(self, relation_name, origin, target, string='', order=None,
    method _get_size (line 66) | def _get_size(self):
    method _set_size (line 69) | def _set_size(self, value):
    method search_order (line 76) | def search_order(self):
    method search_order (line 80) | def search_order(self, value):
    method search_context (line 85) | def search_context(self):
    method search_context (line 89) | def search_context(self, value):
    method filter (line 94) | def filter(self):
    method filter (line 98) | def filter(self, value):
    method add_remove (line 104) | def add_remove(self):
    method display_depends (line 108) | def display_depends(self):
    method edition_depends (line 115) | def edition_depends(self):
    method validation_depends (line 121) | def validation_depends(self):
    method sql_type (line 126) | def sql_type(self):
    method get (line 129) | def get(self, ids, model, name, values=None):
    method set (line 172) | def set(self, Model, name, ids, values, *args):
    method get_relation (line 294) | def get_relation(self):
    method get_target (line 298) | def get_target(self):
    method __set__ (line 305) | def __set__(self, inst, value):
    method delete (line 312) | def delete(self, inst, records):
    method convert_domain_tree (line 321) | def convert_domain_tree(self, domain, tables):
    method convert_domain (line 357) | def convert_domain(self, domain, tables, Model):
    method definition (line 483) | def definition(self, model, language):

FILE: trytond/model/fields/many2one.py
  class Many2One (line 18) | class Many2One(Field):
    method __init__ (line 25) | def __init__(self, model_name, string='', left=None, right=None, path=...
    method __get_required (line 68) | def __get_required(self):
    method __set_required (line 71) | def __set_required(self, value):
    method search_order (line 79) | def search_order(self):
    method search_order (line 83) | def search_order(self, value):
    method search_context (line 88) | def search_context(self):
    method search_context (line 92) | def search_context(self, value):
    method display_depends (line 97) | def display_depends(self):
    method get_target (line 103) | def get_target(self):
    method __set__ (line 107) | def __set__(self, inst, value):
    method sql_format (line 119) | def sql_format(self, value):
    method convert_domain_path (line 125) | def convert_domain_path(self, domain, tables):
    method convert_domain_mptt (line 146) | def convert_domain_mptt(self, domain, tables):
    method convert_domain_tree (line 167) | def convert_domain_tree(self, domain, tables):
    method convert_domain (line 195) | def convert_domain(self, domain, tables, Model):
    method convert_order (line 276) | def convert_order(self, name, tables, Model):
    method _get_target_tables (line 302) | def _get_target_tables(self, tables):
    method definition (line 331) | def definition(self, model, language):

FILE: trytond/model/fields/multiselection.py
  class MultiSelection (line 18) | class MultiSelection(SelectionMixin, Field):
    method __init__ (line 24) | def __init__(self, selection, string='', sort=True, translate=True,
    method set_rpc (line 48) | def set_rpc(self, model):
    method get (line 58) | def get(self, ids, model, name, values=None):
    method sql_format (line 69) | def sql_format(self, value):
    method _domain_column (line 75) | def _domain_column(self, operator, column):
    method _domain_value (line 79) | def _domain_value(self, operator, value):
    method convert_domain (line 86) | def convert_domain(self, domain, tables, Model):

FILE: trytond/model/fields/numeric.py
  class SQLite_Cast (line 12) | class SQLite_Cast(Cast):
    method as_ (line 14) | def as_(self, output_name):
  class Numeric (line 19) | class Numeric(Float):
    method sql_column (line 27) | def sql_column(self, table):
    method _domain_value (line 35) | def _domain_value(self, operator, value):

FILE: trytond/model/fields/one2many.py
  class One2Many (line 20) | class One2Many(Field):
    method __init__ (line 26) | def __init__(self, model_name, field, string='', add_remove=None,
    method _get_add_remove (line 67) | def _get_add_remove(self):
    method _set_add_remove (line 70) | def _set_add_remove(self, value):
    method _get_size (line 77) | def _get_size(self):
    method _set_size (line 80) | def _set_size(self, value):
    method search_order (line 87) | def search_order(self):
    method search_order (line 91) | def search_order(self, value):
    method search_context (line 96) | def search_context(self):
    method search_context (line 100) | def search_context(self, value):
    method display_depends (line 105) | def display_depends(self):
    method edition_depends (line 112) | def edition_depends(self):
    method validation_depends (line 119) | def validation_depends(self):
    method sql_type (line 122) | def sql_type(self):
    method filter (line 126) | def filter(self):
    method filter (line 130) | def filter(self, value):
    method get (line 135) | def get(self, ids, model, name, values=None):
    method set (line 171) | def set(self, Model, name, ids, values, *args):
    method get_target (line 287) | def get_target(self):
    method __set__ (line 291) | def __set__(self, inst, value):
    method remove (line 301) | def remove(self, inst, records):
    method convert_domain (line 310) | def convert_domain(self, domain, tables, Model):
    method definition (line 384) | def definition(self, model, language):

FILE: trytond/model/fields/one2one.py
  class One2One (line 9) | class One2One(Many2Many):
    method get (line 15) | def get(self, ids, model, name, values=None):
    method set (line 30) | def set(self, Model, name, ids, value, *args):
    method __set__ (line 56) | def __set__(self, inst, value):

FILE: trytond/model/fields/reference.py
  class Reference (line 20) | class Reference(SelectionMixin, Field):
    method __init__ (line 27) | def __init__(self, string='', selection=None, sort=True,
    method domain (line 66) | def domain(self):
    method domain (line 70) | def domain(self, value):
    method search_order (line 79) | def search_order(self):
    method search_order (line 83) | def search_order(self, value):
    method search_context (line 92) | def search_context(self):
    method search_context (line 96) | def search_context(self, value):
    method display_depends (line 101) | def display_depends(self):
    method set_rpc (line 107) | def set_rpc(self, model):
    method get (line 117) | def get(self, ids, model, name, values=None):
    method __set__ (line 167) | def __set__(self, inst, value):
    method sql_format (line 183) | def sql_format(self, value):
    method sql_id (line 191) | def sql_id(self, column, Model):
    method convert_domain (line 198) | def convert_domain(self, domain, tables, Model):
    method definition (line 217) | def definition(self, model, language):

FILE: trytond/model/fields/selection.py
  class SelectionMixin (line 17) | class SelectionMixin(Field):
    method translated (line 21) | def translated(self, name=None):
    method definition (line 29) | def definition(self, model, language):
    method definition_translations (line 60) | def definition_translations(self, model, language):
  class Selection (line 75) | class Selection(SelectionMixin, Field):
    method __init__ (line 83) | def __init__(self, selection, string='', sort=True,
    method set_rpc (line 113) | def set_rpc(self, model):
    method convert_order (line 123) | def convert_order(self, name, tables, Model):
  class TranslatedSelection (line 150) | class TranslatedSelection(object):
    method __init__ (line 153) | def __init__(self, name):
    method __get__ (line 156) | def __get__(self, inst, cls):

FILE: trytond/model/fields/text.py
  class Text (line 12) | class Text(Char):
    method __init__ (line 21) | def __init__(self, *args, strip=False, **kwarg):
  class FullText (line 25) | class FullText(Field):
    method sql_format (line 33) | def sql_format(self, value):
    method _rank_column (line 46) | def _rank_column(self, column, name, Model):
    method convert_domain (line 57) | def convert_domain(self, domain, tables, Model):
    method convert_order (line 88) | def convert_order(self, name, tables, Model):

FILE: trytond/model/match.py
  class MatchMixin (line 5) | class MatchMixin(object):
    method match (line 8) | def match(self, pattern, match_none=False):

FILE: trytond/model/model.py
  class ModelMeta (line 22) | class ModelMeta(PoolMeta):
    method __queue__ (line 24) | def __queue__(self):
  class Model (line 31) | class Model(URLMixin, PoolBase, metaclass=ModelMeta):
    method __setup__ (line 41) | def __setup__(cls):
    method __post_setup__ (line 68) | def __post_setup__(cls):
    method _get_name (line 103) | def _get_name(cls):
    method __register__ (line 115) | def __register__(cls, module_name):
    method default_get (line 132) | def default_get(cls, fields_names, with_rec_name=True):
    method fields_get (line 165) | def fields_get(cls, fields_names=None, level=0):
    method pre_validate (line 233) | def pre_validate(self):
    method __names__ (line 237) | def __names__(cls, field=None, record=None):
    method __init__ (line 263) | def __init__(self, id=None, **kwargs):
    method __copy__ (line 295) | def __copy__(self):
    method __getattr__ (line 301) | def __getattr__(self, name):
    method __contains__ (line 310) | def __contains__(self, name):
    method __int__ (line 313) | def __int__(self):
    method __str__ (line 316) | def __str__(self):
    method __repr__ (line 319) | def __repr__(self):
    method __eq__ (line 326) | def __eq__(self, other):
    method __lt__ (line 333) | def __lt__(self, other):
    method __ne__ (line 338) | def __ne__(self, other):
    method __hash__ (line 341) | def __hash__(self):
    method __bool__ (line 344) | def __bool__(self):
    method _default_values (line 348) | def _default_values(self):
  function record (line 375) | def record(name, field_names):

FILE: trytond/model/modelsingleton.py
  class ModelSingleton (line 8) | class ModelSingleton(ModelStorage):
    method __setup__ (line 14) | def __setup__(cls):
    method get_singleton (line 20) | def get_singleton(cls):
    method create (line 29) | def create(cls, vlist):
    method read (line 38) | def read(cls, ids, fields_names):
    method write (line 58) | def write(cls, records, values, *args):
    method delete (line 77) | def delete(cls, records):
    method copy (line 87) | def copy(cls, records, default=None):
    method search (line 93) | def search(cls, domain, offset=0, limit=None, order=None, count=False):
    method default_get (line 103) | def default_get(cls, fields_names, with_rec_name=True):

FILE: trytond/model/modelsql.py
  class ForeignKeyError (line 35) | class ForeignKeyError(ValidationError):
  class SQLConstraintError (line 39) | class SQLConstraintError(ValidationError):
  class Constraint (line 43) | class Constraint(object):
    method __init__ (line 46) | def __init__(self, table):
    method table (line 51) | def table(self):
    method __str__ (line 54) | def __str__(self):
    method params (line 58) | def params(self):
  class Check (line 62) | class Check(Constraint):
    method __init__ (line 65) | def __init__(self, table, expression):
    method expression (line 71) | def expression(self):
    method __str__ (line 74) | def __str__(self):
    method params (line 78) | def params(self):
  class Unique (line 82) | class Unique(Constraint):
    method __init__ (line 85) | def __init__(self, table, *columns):
    method columns (line 91) | def columns(self):
    method operators (line 95) | def operators(self):
    method __str__ (line 98) | def __str__(self):
    method params (line 102) | def params(self):
  class Exclude (line 109) | class Exclude(Constraint):
    method __init__ (line 112) | def __init__(self, table, *excludes, **kwargs):
    method excludes (line 123) | def excludes(self):
    method columns (line 127) | def columns(self):
    method operators (line 131) | def operators(self):
    method where (line 135) | def where(self):
    method __str__ (line 138) | def __str__(self):
    method params (line 147) | def params(self):
  class Index (line 156) | class Index:
    method __init__ (line 159) | def __init__(self, table, *expressions, **options):
    method __hash__ (line 167) | def __hash__(self):
    method __eq__ (line 174) | def __eq__(self, other):
    class Unaccent (line 183) | class Unaccent(Expression):
      method __init__ (line 187) | def __init__(self, expression):
      method expression (line 191) | def expression(self):
      method __str__ (line 198) | def __str__(self):
      method params (line 202) | def params(self):
    class Usage (line 205) | class Usage:
      method __init__ (line 208) | def __init__(self, **options):
      method __hash__ (line 211) | def __hash__(self):
      method __eq__ (line 214) | def __eq__(self, other):
    class Equality (line 218) | class Equality(Usage):
    class Range (line 221) | class Range(Usage):
    class Similarity (line 224) | class Similarity(Usage):
  function no_table_query (line 228) | def no_table_query(func):
  class ModelSQL (line 237) | class ModelSQL(ModelStorage):
    method __setup__ (line 249) | def __setup__(cls):
    method __post_setup__ (line 287) | def __post_setup__(cls):
    method __table__ (line 338) | def __table__(cls):
    method __table_history__ (line 345) | def __table_history__(cls):
    method __table_handler__ (line 351) | def __table_handler__(cls, module_name=None, history=False):
    method __register__ (line 355) | def __register__(cls, module_name):
    method _update_sql_indexes (line 478) | def _update_sql_indexes(cls):
    method _update_history_table (line 485) | def _update_history_table(cls):
    method __raise_integrity_error (line 494) | def __raise_integrity_error(
    method __raise_data_error (line 540) | def __raise_data_error(
    method history_revisions (line 565) | def history_revisions(cls, ids):
    method _insert_history (line 597) | def _insert_history(cls, ids, deleted=False):
    method _restore_history (line 636) | def _restore_history(cls, ids, datetime, _before=False):
    method restore_history (line 697) | def restore_history(cls, ids, datetime):
    method restore_history_before (line 702) | def restore_history_before(cls, ids, datetime):
    method __check_timestamp (line 707) | def __check_timestamp(cls, ids):
    method create (line 736) | def create(cls, vlist):
    method read (line 878) | def read(cls, ids, fields_names):
    method write (line 1184) | def write(cls, records, values, *args):
    method delete (line 1293) | def delete(cls, records):
    method __check_domain_rule (line 1420) | def __check_domain_rule(cls, ids, mode, nodomain=None):
    method __search_query (line 1499) | def __search_query(cls, domain, count, query, order):
    method __searched_columns (line 1573) | def __searched_columns(
    method __search_order (line 1605) | def __search_order(cls, order, tables):
    method search (line 1635) | def search(cls, domain, offset=0, limit=None, order=None, count=False,
    method search_domain (line 1749) | def search_domain(cls, domain, active_test=True, tables=None):
    method _rebuild_path (line 1791) | def _rebuild_path(cls, field_name):
    method _set_path (line 1812) | def _set_path(cls, field_names, list_ids):
    method _update_path (line 1831) | def _update_path(cls, field_names, list_ids):
    method _update_mptt (line 1872) | def _update_mptt(cls, field_names, list_ids, values=None):
    method _rebuild_tree (line 1889) | def _rebuild_tree(cls, parent, parent_id, left):
    method _update_tree (line 1912) | def _update_tree(cls, record_id, field_name, left, right):
    method validate (line 1971) | def validate(cls, records):
    method lock (line 2023) | def lock(cls, records=None):
  function convert_from (line 2040) | def convert_from(table, tables):
  function split_subquery_domain (line 2054) | def split_subquery_domain(domain):

FILE: trytond/model/modelstorage.py
  function local_cache (line 41) | def local_cache(Model, transaction=None):
  class AccessError (line 47) | class AccessError(UserError):
  class ImportDataError (line 51) | class ImportDataError(UserError):
  class ValidationError (line 55) | class ValidationError(UserError):
  class DomainValidationError (line 59) | class DomainValidationError(ValidationError):
  class RequiredValidationError (line 63) | class RequiredValidationError(ValidationError):
  class SizeValidationError (line 67) | class SizeValidationError(ValidationError):
  class DigitsValidationError (line 71) | class DigitsValidationError(ValidationError):
  class ForbiddenCharValidationError (line 75) | class ForbiddenCharValidationError(ValidationError):
  class SelectionValidationError (line 79) | class SelectionValidationError(ValidationError):
  class TimeFormatValidationError (line 83) | class TimeFormatValidationError(ValidationError):
  function without_check_access (line 87) | def without_check_access(func):
  function is_leaf (line 95) | def is_leaf(expression):
  class ModelStorage (line 102) | class ModelStorage(Model):
    method __setup__ (line 124) | def __setup__(cls):
    method __post_setup__ (line 147) | def __post_setup__(cls):
    method default_create_uid (line 161) | def default_create_uid():
    method default_create_date (line 166) | def default_create_date():
    method create (line 171) | def create(cls, vlist):
    method trigger_create (line 196) | def trigger_create(cls, records):
    method read (line 208) | def read(cls, ids, fields_names):
    method index_get_field (line 221) | def index_get_field(cls, name):
    method write (line 226) | def write(cls, records, values, *args):
    method trigger_write_get_eligibles (line 265) | def trigger_write_get_eligibles(cls, records):
    method trigger_write (line 283) | def trigger_write(cls, eligibles):
    method index_set_field (line 292) | def index_set_field(cls, name):
    method delete (line 297) | def delete(cls, records):
    method trigger_delete (line 345) | def trigger_delete(cls, records):
    method copy (line 358) | def copy(cls, records, default=None):
    method search (line 485) | def search(cls, domain, offset=0, limit=None, order=None, count=False):
    method search_count (line 547) | def search_count(cls, domain, offset=0, limit=None):
    method search_read (line 558) | def search_read(cls, domain, offset=0, limit=None, order=None,
    method _search_domain_active (line 576) | def _search_domain_active(cls, domain, active_test=True):
    method count (line 609) | def count(cls):
    method resources (line 617) | def resources(self):
    method get_rec_name (line 635) | def get_rec_name(self, name):
    method search_rec_name (line 646) | def search_rec_name(cls, name, clause):
    method search_global (line 656) | def search_global(cls, text):
    method browse (line 667) | def browse(cls, ids):
    method __export_row (line 681) | def __export_row(record, fields_names):
    method _convert_field_names (line 741) | def _convert_field_names(cls, fields_names):
    method export_data (line 768) | def export_data(cls, records, fields_names, header=False):
    method export_data_domain (line 778) | def export_data_domain(
    method import_data (line 785) | def import_data(cls, fields_names, data):
    method check_xml_record (line 1124) | def check_xml_record(cls, records, values):
    method validate (line 1161) | def validate(cls, records):
    method validate_fields (line 1165) | def validate_fields(cls, records, field_names):
    method _validate (line 1170) | def _validate(cls, records, field_names=None):
    method _clean_defaults (line 1532) | def _clean_defaults(cls, defaults):
    method __init__ (line 1558) | def __init__(self, id=None, **kwargs):
    method _cache (line 1590) | def _cache(self):
    method __getattr__ (line 1593) | def __getattr__(self, name):
    method _save_values (line 1829) | def _save_values(self):
    method save (line 1914) | def save(cls, records):
  class EvalEnvironment (line 1964) | class EvalEnvironment(dict):
    method __init__ (line 1967) | def __init__(self, record, Model):
    method __getitem__ (line 1972) | def __getitem__(self, item):
    method __getattr__ (line 1991) | def __getattr__(self, item):
    method get (line 1997) | def get(self, item, default=None):
    method __bool__ (line 2004) | def __bool__(self):
  function _record_eval_pyson (line 2008) | def _record_eval_pyson(record, source, encoded=False):

FILE: trytond/model/modelview.py
  class AccessButtonError (line 24) | class AccessButtonError(UserError):
  function on_change (line 28) | def on_change(func):
  class ModelView (line 38) | class ModelView(Model):
    method __setup__ (line 47) | def __setup__(cls):
    method __post_setup__ (line 65) | def __post_setup__(cls):
    method fields_view_get (line 185) | def fields_view_get(cls, view_id=None, view_type='form', level=None):
    method view_toolbar_get (line 280) | def view_toolbar_get(cls):
    method view_attributes (line 317) | def view_attributes(cls):
    method parse_view (line 322) | def parse_view(
    method __parse_fields (line 481) | def __parse_fields(
    method button (line 649) | def button(func):
    method button_action (line 701) | def button_action(action):
    method button_change (line 726) | def button_change(*fields, **kwargs):
    method on_change (line 738) | def on_change(self, fieldnames):
    method on_change_with (line 746) | def on_change_with(self, fieldnames):
    method on_change_notify (line 753) | def on_change_notify(self):
    method _changed_values (line 760) | def _changed_values(self):

FILE: trytond/model/multivalue.py
  class MultiValueMixin (line 10) | class MultiValueMixin(object):
    method multivalue_model (line 14) | def multivalue_model(cls, field):
    method multivalue_records (line 21) | def multivalue_records(self, field):
    method multivalue_record (line 29) | def multivalue_record(self, field, **pattern):
    method __values (line 47) | def __values(self, field, pattern, match_none=True):
    method get_multivalue (line 51) | def get_multivalue(self, name, **pattern):
    method _multivalue_getter (line 63) | def _multivalue_getter(self, name):
    method set_multivalue (line 75) | def set_multivalue(self, name, value, save=True, **pattern):
    method _multivalue_setter (line 89) | def _multivalue_setter(cls, records, name, val):
  class ValueMixin (line 97) | class ValueMixin(MatchMixin):
    method match (line 99) | def match(self, pattern, match_none=True):
  function filter_pattern (line 103) | def filter_pattern(pattern, Value):

FILE: trytond/model/order.py
  function sequence_ordered (line 9) | def sequence_ordered(

FILE: trytond/model/symbol.py
  class SymbolMixin (line 6) | class SymbolMixin(object):
    method __setup__ (line 10) | def __setup__(cls):
    method get_symbol (line 16) | def get_symbol(self, sign, symbol=None):

FILE: trytond/model/tree.py
  class RecursionError (line 11) | class RecursionError(ValidationError):
  function tree (line 15) | def tree(parent='parent', name='name', separator=None):

FILE: trytond/model/union.py
  class UnionMixin (line 9) | class UnionMixin:
    method union_models (line 14) | def union_models():
    method union_shard (line 18) | def union_shard(cls, column, model):
    method union_unshard (line 25) | def union_unshard(cls, record_id):
    method union_column (line 34) | def union_column(cls, name, field, table, Model):
    method union_columns (line 49) | def union_columns(cls, model):
    method table_query (line 63) | def table_query(cls):

FILE: trytond/model/workflow.py
  class Workflow (line 7) | class Workflow(object):
    method __setup__ (line 15) | def __setup__(cls):
    method transition (line 20) | def transition(state):
    method copy (line 51) | def copy(cls, records, default=None):

FILE: trytond/modules/__init__.py
  function update_egg_modules (line 35) | def update_egg_modules():
  function import_module (line 48) | def import_module(name, fullname=None):
  function get_module_info (line 82) | def get_module_info(name):
  class Graph (line 96) | class Graph(dict):
    method get (line 97) | def get(self, name):
    method add (line 104) | def add(self, name, deps):
    method __iter__ (line 110) | def __iter__(self):
  class Node (line 115) | class Node(list):
    method __init__ (line 116) | def __init__(self, name):
    method __repr__ (line 122) | def __repr__(self):
    method depth (line 126) | def depth(self):
    method depth (line 130) | def depth(self, value):
    method append (line 136) | def append(self, node):
  function create_graph (line 142) | def create_graph(module_list):
  function is_module_to_install (line 161) | def is_module_to_install(module, update):
  function load_translations (line 167) | def load_translations(pool, node, languages):
  function load_module_graph (line 187) | def load_module_graph(graph, pool, update=None, lang=None):
  function get_module_list (line 321) | def get_module_list():
  function register_classes (line 339) | def register_classes():
  function load_modules (line 365) | def load_modules(

FILE: trytond/pool.py
  class PoolMeta (line 16) | class PoolMeta(type):
    method __new__ (line 18) | def __new__(cls, name, bases, dct):
  class PoolBase (line 30) | class PoolBase(object, metaclass=PoolMeta):
    method __setup__ (line 32) | def __setup__(cls):
    method __post_setup__ (line 36) | def __post_setup__(cls):
    method __register__ (line 40) | def __register__(cls, module_name):
  class Pool (line 44) | class Pool(object):
    method __new__ (line 60) | def __new__(cls, database_name=None):
    method __init__ (line 74) | def __init__(self, database_name=None):
    method register (line 80) | def register(*classes, **kwargs):
    method register_mixin (line 95) | def register_mixin(mixin, classinfo, module):
    method start (line 99) | def start(cls):
    method stop (line 110) | def stop(cls, database_name):
    method database_list (line 125) | def database_list(cls):
    method lock (line 139) | def lock(self):
    method init (line 145) | def init(self, update=None, lang=None, activatedeps=False):
    method get (line 175) | def get(self, name, type='model'):
    method add (line 202) | def add(self, cls, type='model'):
    method iterobject (line 209) | def iterobject(self, type='model'):
    method fill (line 218) | def fill(self, module, modules):
    method setup (line 242) | def setup(self, classes=None):
    method setup_mixin (line 255) | def setup_mixin(self, type=None, name=None):
    method refresh (line 276) | def refresh(self, modules):
  function isregisteredby (line 281) | def isregisteredby(obj, module, type_='model'):

FILE: trytond/protocols/dispatcher.py
  function rpc (line 41) | def rpc(request, database_name):
  function login (line 53) | def login(request, database_name, user, parameters, language=None):
  function logout (line 74) | def logout(request, database_name):
  function root (line 82) | def root(request, *args):
  function options (line 93) | def options(request, path=None):
  function db_exist (line 97) | def db_exist(request, database_name):
  function db_list (line 105) | def db_list(request, *args):
  function authentication_services (line 116) | def authentication_services(request):
  function register_authentication_service (line 120) | def register_authentication_service(name, url):
  function list_method (line 129) | def list_method(request, pool):
  function get_object_method (line 138) | def get_object_method(request, pool):
  function help_method (line 148) | def help_method(request, pool):
  function _safe_repr (line 153) | def _safe_repr(args, kwargs, short=False):
  function _dispatch (line 163) | def _dispatch(request, pool, *args, **kwargs):

FILE: trytond/protocols/jsonrpc.py
  class JSONDecoder (line 20) | class JSONDecoder(object):
    method register (line 25) | def register(cls, klass, decoder):
    method __call__ (line 29) | def __call__(self, dct):
  function _bytes_decoder (line 47) | def _bytes_decoder(dct):
  class JSONEncoder (line 56) | class JSONEncoder(json.JSONEncoder):
    method register (line 61) | def register(cls, klass, encoder):
    method default (line 65) | def default(self, obj):
  function _bytes_encoder (line 104) | def _bytes_encoder(o):
  class JSONRequest (line 120) | class JSONRequest(Request):
    method parsed_data (line 124) | def parsed_data(self):
    method rpc_method (line 137) | def rpc_method(self):
    method rpc_params (line 144) | def rpc_params(self):
  class JSONProtocol (line 151) | class JSONProtocol:
    method request (line 155) | def request(cls, environ):
    method response (line 159) | def response(cls, data, request):

FILE: trytond/protocols/wrappers.py
  class Request (line 30) | class Request(_Request):
    method __repr__ (line 34) | def __repr__(self):
    method decoded_data (line 56) | def decoded_data(self):
    method parsed_data (line 64) | def parsed_data(self):
    method rpc_method (line 68) | def rpc_method(self):
    method rpc_params (line 72) | def rpc_params(self):
    method authorization (line 76) | def authorization(self):
    method user_id (line 84) | def user_id(self):
    method context (line 108) | def context(self):
  function parse_authorization_header (line 117) | def parse_authorization_header(value):
  function set_max_request_size (line 141) | def set_max_request_size(size):
  function allow_null_origin (line 148) | def allow_null_origin(func):
  function with_pool (line 153) | def with_pool(func):
  function with_transaction (line 181) | def with_transaction(readonly=None, user=0, context=None):
  function user_application (line 225) | def user_application(name, json=True):

FILE: trytond/protocols/xmlrpc.py
  function dump_decimal (line 27) | def dump_decimal(self, value, write):
  function dump_date (line 33) | def dump_date(self, value, write):
  function dump_time (line 42) | def dump_time(self, value, write):
  function dump_timedelta (line 52) | def dump_timedelta(self, value, write):
  function dump_long (line 59) | def dump_long(self, value, write):
  function dump_struct (line 75) | def dump_struct(self, value, write, escape=client.escape):
  class XMLRPCDecoder (line 90) | class XMLRPCDecoder(object):
    method register (line 95) | def register(cls, klass, decoder):
    method __call__ (line 99) | def __call__(self, dct):
  function end_struct (line 115) | def end_struct(self, data):
  class XMLRequest (line 130) | class XMLRequest(Request):
    method parsed_data (line 134) | def parsed_data(self):
    method rpc_method (line 145) | def rpc_method(self):
    method rpc_params (line 149) | def rpc_params(self):
  class XMLProtocol (line 153) | class XMLProtocol:
    method request (line 157) | def request(cls, environ):
    method response (line 161) | def response(cls, data, request):

FILE: trytond/pyson.py
  class PYSON (line 11) | class PYSON(object):
    method pyson (line 13) | def pyson(self):
    method types (line 16) | def types(self):
    method eval (line 20) | def eval(dct, context):
    method __invert__ (line 23) | def __invert__(self):
    method __and__ (line 29) | def __and__(self, other):
    method __or__ (line 43) | def __or__(self, other):
    method __eq__ (line 56) | def __eq__(self, other):
    method __ne__ (line 59) | def __ne__(self, other):
    method __gt__ (line 62) | def __gt__(self, other):
    method __ge__ (line 65) | def __ge__(self, other):
    method __lt__ (line 68) | def __lt__(self, other):
    method __le__ (line 71) | def __le__(self, other):
    method get (line 74) | def get(self, k, d=''):
    method in_ (line 77) | def in_(self, obj):
    method contains (line 80) | def contains(self, k):
    method __repr__ (line 83) | def __repr__(self):
    method __repr_params__ (line 88) | def __repr_params__(self):
  class PYSONEncoder (line 92) | class PYSONEncoder(json.JSONEncoder):
    method default (line 94) | def default(self, obj):
  class PYSONDecoder (line 109) | class PYSONDecoder(json.JSONDecoder):
    method __init__ (line 111) | def __init__(self, context=None, noeval=False):
    method _object_hook (line 116) | def _object_hook(self, dct):
  class Eval (line 129) | class Eval(PYSON):
    method __init__ (line 131) | def __init__(self, v, d=''):
    method __repr_params__ (line 137) | def __repr_params__(self):
    method pyson (line 140) | def pyson(self):
    method types (line 147) | def types(self):
    method eval (line 154) | def eval(dct, context):
    method basename (line 164) | def basename(self):
  class Not (line 173) | class Not(PYSON):
    method __init__ (line 175) | def __init__(self, v):
    method __repr_params__ (line 185) | def __repr_params__(self):
    method pyson (line 188) | def pyson(self):
    method types (line 194) | def types(self):
    method eval (line 198) | def eval(dct, context):
  class Bool (line 202) | class Bool(PYSON):
    method __init__ (line 204) | def __init__(self, v):
    method __repr_params__ (line 209) | def __repr_params__(self):
    method pyson (line 212) | def pyson(self):
    method types (line 218) | def types(self):
    method eval (line 222) | def eval(dct, context):
  class And (line 226) | class And(PYSON):
    method __init__ (line 228) | def __init__(self, *statements, **kwargs):
    method __repr_params__ (line 241) | def __repr_params__(self):
    method pyson (line 244) | def pyson(self):
    method types (line 250) | def types(self):
    method eval (line 254) | def eval(dct, context):
  class Or (line 258) | class Or(And):
    method pyson (line 260) | def pyson(self):
    method eval (line 266) | def eval(dct, context):
  class Equal (line 270) | class Equal(PYSON):
    method __init__ (line 272) | def __init__(self, s1, s2):
    method __repr_params__ (line 288) | def __repr_params__(self):
    method pyson (line 291) | def pyson(self):
    method types (line 298) | def types(self):
    method eval (line 302) | def eval(dct, context):
  class Greater (line 306) | class Greater(PYSON):
    method __init__ (line 308) | def __init__(self, s1, s2, e=False):
    method __repr_params__ (line 332) | def __repr_params__(self):
    method pyson (line 335) | def pyson(self):
    method types (line 343) | def types(self):
    method _convert (line 347) | def _convert(dct):
    method eval (line 363) | def eval(dct, context):
  class Less (line 373) | class Less(Greater):
    method pyson (line 375) | def pyson(self):
    method eval (line 381) | def eval(dct, context):
  class If (line 391) | class If(PYSON):
    method __init__ (line 393) | def __init__(self, c, t, e=None):
    method __repr_params__ (line 406) | def __repr_params__(self):
    method pyson (line 409) | def pyson(self):
    method types (line 417) | def types(self):
    method eval (line 429) | def eval(dct, context):
  class Get (line 436) | class Get(PYSON):
    method __init__ (line 438) | def __init__(self, v, k, d=''):
    method __repr_params__ (line 454) | def __repr_params__(self):
    method pyson (line 457) | def pyson(self):
    method types (line 465) | def types(self):
    method eval (line 472) | def eval(dct, context):
  class In (line 476) | class In(PYSON):
    method __init__ (line 478) | def __init__(self, k, v):
    method __repr_params__ (line 506) | def __repr_params__(self):
    method pyson (line 509) | def pyson(self):
    method types (line 516) | def types(self):
    method eval (line 520) | def eval(dct, context):
  class Date (line 527) | class Date(PYSON):
    method __init__ (line 529) | def __init__(self, year=None, month=None, day=None,
    method __repr_params__ (line 554) | def __repr_params__(self):
    method pyson (line 559) | def pyson(self):
    method types (line 571) | def types(self):
    method eval (line 575) | def eval(dct, context):
  class DateTime (line 591) | class DateTime(Date):
    method __init__ (line 593) | def __init__(self, year=None, month=None, day=None,
    method __repr_params__ (line 627) | def __repr_params__(self):
    method pyson (line 636) | def pyson(self):
    method types (line 649) | def types(self):
    method eval (line 653) | def eval(dct, context):
  class TimeDelta (line 678) | class TimeDelta(PYSON):
    method __init__ (line 680) | def __init__(self, days=0, seconds=0, microseconds=0):
    method __repr_params__ (line 693) | def __repr_params__(self):
    method pyson (line 696) | def pyson(self):
    method types (line 704) | def types(self):
    method eval (line 708) | def eval(dct, context):
  class Len (line 716) | class Len(PYSON):
    method __init__ (line 718) | def __init__(self, v):
    method __repr_params__ (line 729) | def __repr_params__(self):
    method pyson (line 732) | def pyson(self):
    method types (line 738) | def types(self):
    method eval (line 742) | def eval(dct, context):
  class Id (line 746) | class Id(PYSON):
    method __init__ (line 749) | def __init__(self, module, fs_id):
    method __repr_params__ (line 755) | def __repr_params__(self):
    method pyson (line 758) | def pyson(self):
    method types (line 763) | def types(self):

FILE: trytond/report/report.py
  class TranslateFactory (line 104) | class TranslateFactory:
    method __init__ (line 106) | def __init__(self, report_name, translation):
    method __call__ (line 110) | def __call__(self, text):
  class Report (line 114) | class Report(URLMixin, PoolBase):
    method __setup__ (line 117) | def __setup__(cls):
    method check_access (line 124) | def check_access(cls):
    method header_key (line 138) | def header_key(cls, record):
    method execute (line 142) | def execute(cls, ids, data):
    method _execute (line 249) | def _execute(cls, records, header, data, action):
    method _get_records (line 257) | def _get_records(cls, ids, model, data):
    method get_context (line 299) | def get_context(cls, records, header, data):
    method _callback_loader (line 328) | def _callback_loader(cls, report, template):
    method render (line 341) | def render(cls, report, report_context):
    method convert (line 357) | def convert(cls, report, data, timeout=5 * 60, retry=5):
    method format_date (line 410) | def format_date(cls, value, lang=None, format=None):
    method format_datetime (line 418) | def format_datetime(cls, value, lang=None, format=None, timezone=None):
    method format_timedelta (line 432) | def format_timedelta(cls, value, converter=None, lang=None):
    method format_currency (line 475) | def format_currency(
    method format_number (line 486) | def format_number(
    method format_number_symbol (line 496) | def format_number_symbol(
  function get_email (line 506) | def get_email(report, record, languages):

FILE: trytond/res/__init__.py
  function register (line 10) | def register():

FILE: trytond/res/group.py
  class MenuMany2Many (line 13) | class MenuMany2Many(fields.Many2Many):
    method get (line 15) | def get(self, ids, model, name, values=None):
  class Group (line 31) | class Group(DeactivableMixin, tree(), ModelSQL, ModelView):
    method __setup__ (line 52) | def __setup__(cls):
    method write (line 62) | def write(cls, *args):
    method copy (line 75) | def copy(cls, groups, default=None):
    method group_parent_all_cte (line 93) | def group_parent_all_cte(cls):

FILE: trytond/res/ir.py
  class UIMenu (line 10) | class UIMenu(metaclass=PoolMeta):
  class UIMenuGroup (line 17) | class UIMenuGroup(ModelSQL):
    method create (line 26) | def create(cls, vlist):
    method write (line 33) | def write(cls, records, values, *args):
    method delete (line 39) | def delete(cls, records):
  class ActionGroup (line 45) | class ActionGroup(ModelSQL):
    method create (line 54) | def create(cls, vlist):
    method write (line 66) | def write(cls, records, values, *args):
    method delete (line 80) | def delete(cls, records):
  class Action (line 86) | class Action(metaclass=PoolMeta):
  class ActionMixin (line 93) | class ActionMixin(metaclass=PoolMeta):
    method get_groups (line 96) | def get_groups(cls, name, action_id=None):
  class ActionReport (line 108) | class ActionReport(ActionMixin):
  class ActionActWindow (line 112) | class ActionActWindow(ActionMixin):
  class ActionWizard (line 116) | class ActionWizard(ActionMixin):
  class ActionURL (line 120) | class ActionURL(ActionMixin):
  class ActionKeyword (line 124) | class ActionKeyword(metaclass=PoolMeta):
    method get_groups (line 130) | def get_groups(self, name):
    method search_groups (line 134) | def search_groups(cls, name, clause):
  class ModelButton (line 138) | class ModelButton(metaclass=PoolMeta):
    method create (line 146) | def create(cls, vlist):
    method write (line 152) | def write(cls, buttons, values, *args):
    method delete (line 157) | def delete(cls, buttons):
    method get_groups (line 162) | def get_groups(cls, model, name):
  class ModelButtonGroup (line 183) | class ModelButtonGroup(DeactivableMixin, ModelSQL):
    method create (line 192) | def create(cls, vlist):
    method write (line 200) | def write(cls, records, values, *args):
    method delete (line 207) | def delete(cls, records):
  class ModelButtonRule (line 214) | class ModelButtonRule(metaclass=PoolMeta):
  class ModelButtonClick (line 219) | class ModelButtonClick(metaclass=PoolMeta):
  class RuleGroup (line 224) | class RuleGroup(metaclass=PoolMeta):
  class RuleGroupGroup (line 231) | class RuleGroupGroup(ModelSQL):
  class SequenceType (line 240) | class SequenceType(metaclass=PoolMeta):
  class SequenceTypeGroup (line 247) | class SequenceTypeGroup(ModelSQL):
    method delete (line 256) | def delete(cls, records):
    method create (line 263) | def create(cls, vlist):
    method write (line 271) | def write(cls, records, values, *args):
  class Export (line 278) | class Export(metaclass=PoolMeta):
  class Export_Group (line 297) | class Export_Group(ModelSQL):
  class Export_Write_Group (line 307) | class Export_Write_Group(Export_Group):

FILE: trytond/res/routes.py
  function user_application (line 22) | def user_application(request, pool):

FILE: trytond/res/user.py
  function gen_password (line 79) | def gen_password(length=8):
  function _send_email (line 89) | def _send_email(from_, users, email_func):
  class PasswordError (line 102) | class PasswordError(UserError):
  class DeleteError (line 106) | class DeleteError(UserError):
  class User (line 110) | class User(avatar_mixin(100, 'login'), DeactivableMixin, ModelSQL, Model...
    method __setup__ (line 161) | def __setup__(cls):
    method __register__ (line 202) | def __register__(cls, module_name):
    method default_menu (line 232) | def default_menu():
    method get_pyson_menu (line 242) | def get_pyson_menu(self, name):
    method get_language_direction (line 246) | def get_language_direction(self, name):
    method get_status_bar (line 254) | def get_status_bar(self, name):
    method get_avatar_badge_url (line 257) | def get_avatar_badge_url(self, name):
    method get_password (line 260) | def get_password(self, name):
    method set_password (line 264) | def set_password(cls, users, name, value):
    method validate_password (line 279) | def validate_password(cls, password, users):
    method reset_password (line 308) | def reset_password(cls, users, length=8, from_=None):
    method get_email_reset_password (line 318) | def get_email_reset_password(self):
    method languages (line 323) | def languages(self):
    method get_sessions (line 335) | def get_sessions(users, name):
    method _convert_vals (line 356) | def _convert_vals(vals):
    method read (line 365) | def read(cls, ids, fields_names):
    method create (line 373) | def create(cls, vlist):
    method write (line 378) | def write(cls, users, values, *args):
    method delete (line 419) | def delete(cls, users):
    method get_rec_name (line 422) | def get_rec_name(self, name):
    method search_rec_name (line 426) | def search_rec_name(cls, name, clause):
    method copy (line 437) | def copy(cls, users, default=None):
    method _get_preferences (line 454) | def _get_preferences(cls, user, context_only=False):
    method get_preferences (line 527) | def get_preferences(cls, context_only=False):
    method set_preferences (line 533) | def set_preferences(cls, values):
    method get_preferences_fields_view (line 563) | def get_preferences_fields_view(cls):
    method get_groups (line 609) | def get_groups(cls, name=None):
    method _get_login (line 629) | def _get_login(cls, login):
    method get_login (line 642) | def get_login(cls, login, parameters):
    method _check_login_options (line 691) | def _check_login_options(cls, options, login, parameters):
    method _check_login_options_ip_address (line 704) | def _check_login_options_ip_address(cls, login, parameters):
    method _check_login_options_device_cookie (line 718) | def _check_login_options_device_cookie(cls, login, parameters):
    method _login_password (line 722) | def _login_password(cls, login, parameters):
    method hash_password (line 744) | def hash_password(cls, password):
    method check_password (line 752) | def check_password(cls, password, hash_):
    method hash_sha1 (line 770) | def hash_sha1(cls, password):
    method check_sha1 (line 779) | def check_sha1(cls, password, hash_):
    method hash_bcrypt (line 790) | def hash_bcrypt(cls, password):
    method check_bcrypt (line 797) | def check_bcrypt(cls, password, hash_):
  class LoginAttempt (line 807) | class LoginAttempt(ModelSQL):
    method delay (line 820) | def delay():
    method ipaddress (line 825) | def ipaddress(cls):
    method _login_size (line 839) | def _login_size(func):
    method add (line 847) | def add(cls, login, device_cookie=None):
    method remove (line 862) | def remove(cls, login, device_cookie=None):
    method count (line 872) | def count(cls, login, device_cookie=None):
    method count_ip (line 882) | def count_ip(cls):
  class UserDevice (line 894) | class UserDevice(ModelSQL):
    method __setup__ (line 902) | def __setup__(cls):
    method get_valid_cookie (line 909) | def get_valid_cookie(cls, login, cookie):
    method renew (line 921) | def renew(cls, current_cookie):
    method clear (line 943) | def clear(cls, logins):
  class UserAction (line 950) | class UserAction(ModelSQL):
    method _convert_values (line 959) | def _convert_values(values):
    method create (line 968) | def create(cls, vlist):
    method write (line 973) | def write(cls, records, values, *args):
  class UserGroup (line 981) | class UserGroup(ModelSQL):
    method create (line 990) | def create(cls, vlist):
    method write (line 1004) | def write(cls, groups, values, *args):
    method delete (line 1017) | def delete(cls, groups):
    method user_group_all_table (line 1030) | def user_group_all_table(cls):
  class Warning_ (line 1046) | class Warning_(ModelSQL, ModelView):
    method format (line 1055) | def format(cls, name, records):
    method check (line 1060) | def check(cls, warning_name):
  class UserApplication (line 1080) | class UserApplication(Workflow, ModelSQL, ModelView):
    method __setup__ (line 1095) | def __setup__(cls):
    method default_key (line 1130) | def default_key(cls):
    method default_state (line 1134) | def default_state(cls):
    method validate_ (line 1140) | def validate_(cls, applications):
    method cancel (line 1146) | def cancel(cls, applications):
    method count (line 1150) | def count(cls, user_id):
    method check (line 1157) | def check(cls, key, application):
    method create (line 1169) | def create(cls, vlist):
  class EmailResetPassword (line 1179) | class EmailResetPassword(Report):
    method get_context (line 1183) | def get_context(cls, records, header, data):
  class UserConfigStart (line 1198) | class UserConfigStart(ModelView):
  class UserConfig (line 1203) | class UserConfig(Wizard):
    method transition_add (line 1219) | def transition_add(self):

FILE: trytond/rpc.py
  class RPC (line 11) | class RPC(object):
    method __init__ (line 25) | def __init__(self, readonly=True, instantiate=None, result=None,
    method convert (line 41) | def convert(self, obj, *args, **kwargs):
  class RPCCache (line 88) | class RPCCache:
    method __init__ (line 91) | def __init__(self, days=0, seconds=0):
    method headers (line 94) | def headers(self):

FILE: trytond/security.py
  function _get_pool (line 14) | def _get_pool(dbname):
  function _get_remote_addr (line 22) | def _get_remote_addr(context):
  function login (line 27) | def login(dbname, loginname, parameters, cache=True, context=None):
  function logout (line 59) | def logout(dbname, user, session, context=None):
  function check (line 79) | def check(dbname, user, session, context=None):
  function check_timeout (line 107) | def check_timeout(dbname, user, session, context=None):
  function reset (line 127) | def reset(dbname, session, context):

FILE: trytond/sendmail.py
  function sendmail_transactional (line 20) | def sendmail_transactional(
  function sendmail (line 32) | def sendmail(from_addr, to_addrs, msg, server=None, strict=False):
  function send_test_email (line 71) | def send_test_email(to_addrs, server=None):
  function get_smtp_server (line 81) | def get_smtp_server(uri=None, strict=False):
  class SMTPDataManager (line 115) | class SMTPDataManager(object):
    method __init__ (line 117) | def __init__(self, uri=None, strict=False):
    method put (line 123) | def put(self, from_addr, to_addrs, msg):
    method __eq__ (line 127) | def __eq__(self, other):
    method abort (line 132) | def abort(self, trans):
    method tpc_begin (line 135) | def tpc_begin(self, trans):
    method commit (line 138) | def commit(self, trans):
    method tpc_vote (line 141) | def tpc_vote(self, trans):
    method tpc_finish (line 145) | def tpc_finish(self, trans):
    method tpc_abort (line 155) | def tpc_abort(self, trans):
    method _finish (line 160) | def _finish(self):

FILE: trytond/status.py
  function processing (line 25) | def processing(request):
  function log (line 35) | def log():
  function dump (line 51) | def dump(path):
  function dumper (line 69) | def dumper(path):
  function start (line 77) | def start(path):
  function listen (line 90) | def listen(path, callback=None):

FILE: trytond/tests/__init__.py
  function register (line 10) | def register():

FILE: trytond/tests/access.py
  class TestAccess (line 7) | class TestAccess(ModelSQL):
  class TestAccessRelate (line 20) | class TestAccessRelate(ModelSQL):
  class TestAccessModel (line 27) | class TestAccessModel(TestAccess):
    method __setup__ (line 33) | def __setup__(cls):
  function register (line 38) | def register(module):

FILE: trytond/tests/copy_.py
  class Copy (line 8) | class Copy(ModelSQL):
  class CopyOne2Many (line 14) | class CopyOne2Many(ModelSQL):
  class CopyOne2ManyTarget (line 22) | class CopyOne2ManyTarget(ModelSQL):
  class CopyOne2ManyReference (line 29) | class CopyOne2ManyReference(ModelSQL):
  class CopyOne2ManyReferenceTarget (line 37) | class CopyOne2ManyReferenceTarget(ModelSQL):
  class CopyMany2Many (line 47) | class CopyMany2Many(ModelSQL):
  class CopyMany2ManyTarget (line 55) | class CopyMany2ManyTarget(ModelSQL):
  class CopyMany2ManyRelation (line 61) | class CopyMany2ManyRelation(ModelSQL):
  class CopyMany2ManyReference (line 70) | class CopyMany2ManyReference(ModelSQL):
  class CopyMany2ManyReferenceTarget (line 78) | class CopyMany2ManyReferenceTarget(ModelSQL):
  class CopyMany2ManyReferenceRelation (line 84) | class CopyMany2ManyReferenceRelation(ModelSQL):
  class CopyBinary (line 96) | class CopyBinary(ModelSQL):
  class CopyAccess (line 104) | class CopyAccess(ModelSQL):
    method default_name (line 110) | def default_name(cls):
  class CopyTranslate (line 114) | class CopyTranslate(ModelSQL):
  function register (line 120) | def register(module):

FILE: trytond/tests/export_data.py
  class ExportDataTarget (line 8) | class ExportDataTarget(ModelSQL):
  class ExportData (line 14) | class ExportData(ModelSQL):
  class ExportDataTarget2 (line 43) | class ExportDataTarget2(metaclass=PoolMeta):
  class ExportDataRelation (line 49) | class ExportDataRelation(ModelSQL):
  function register (line 56) | def register(module):

FILE: trytond/tests/field_binary.py
  class Binary (line 8) | class Binary(ModelSQL):
  class BinaryDefault (line 14) | class BinaryDefault(ModelSQL):
    method default_binary (line 20) | def default_binary():
  class BinaryRequired (line 24) | class BinaryRequired(ModelSQL):
  class BinaryFileStorage (line 30) | class BinaryFileStorage(ModelSQL):
  function register (line 37) | def register(module):

FILE: trytond/tests/field_boolean.py
  class Boolean (line 8) | class Boolean(ModelSQL):
  class BooleanDefault (line 14) | class BooleanDefault(ModelSQL):
    method default_boolean (line 20) | def default_boolean():
  function register (line 24) | def register(module):

FILE: trytond/tests/field_char.py
  class Char (line 9) | class Char(ModelSQL):
  class CharDefault (line 18) | class CharDefault(ModelSQL):
    method default_char (line 24) | def default_char():
  class CharRequired (line 28) | class CharRequired(ModelSQL):
  class CharSize (line 34) | class CharSize(ModelSQL):
  class CharSizePYSON (line 40) | class CharSizePYSON(ModelSQL):
  class CharTranslate (line 49) | class CharTranslate(ModelSQL):
  class CharUnaccentedOn (line 58) | class CharUnaccentedOn(ModelSQL):
  class CharUnaccentedOff (line 64) | class CharUnaccentedOff(ModelSQL):
    method __setup__ (line 70) | def __setup__(cls):
  class CharUnaccentedTranslate (line 75) | class CharUnaccentedTranslate(ModelSQL):
  function register (line 81) | def register(module):

FILE: trytond/tests/field_context.py
  class FieldContextParent (line 9) | class FieldContextParent(ModelSQL):
  class FieldContextChild (line 21) | class FieldContextChild(ModelSQL):
  function register (line 26) | def register(module):

FILE: trytond/tests/field_date.py
  class Date (line 10) | class Date(ModelSQL):
  class DateDefault (line 17) | class DateDefault(ModelSQL):
    method default_date (line 24) | def default_date():
  class DateRequired (line 28) | class DateRequired(ModelSQL):
  function register (line 35) | def register(module):

FILE: trytond/tests/field_datetime.py
  class DateTime (line 10) | class DateTime(ModelSQL):
  class DateTimeDefault (line 17) | class DateTimeDefault(ModelSQL):
    method default_datetime (line 24) | def default_datetime():
  class DateTimeRequired (line 28) | class DateTimeRequired(ModelSQL):
  class DateTimeFormat (line 35) | class DateTimeFormat(ModelSQL):
  function register (line 41) | def register(module):

FILE: trytond/tests/field_dict.py
  class DictSchema (line 8) | class DictSchema(DictSchemaMixin, ModelSQL):
  class Dict (line 13) | class Dict(ModelSQL):
  class DictDefault (line 21) | class DictDefault(ModelSQL):
    method default_dico (line 27) | def default_dico():
  class DictRequired (line 31) | class DictRequired(ModelSQL):
  class DictText (line 37) | class DictText(ModelSQL):
  class DictNoSchema (line 44) | class DictNoSchema(ModelSQL):
  class DictUnaccentedOn (line 50) | class DictUnaccentedOn(ModelSQL):
  class DictUnaccentedOff (line 56) | class DictUnaccentedOff(ModelSQL):
    method __setup__ (line 62) | def __setup__(cls):
  function register (line 67) | def register(module):

FILE: trytond/tests/field_float.py
  class Float (line 9) | class Float(ModelSQL):
  class FloatDefault (line 16) | class FloatDefault(ModelSQL):
    method default_float (line 23) | def default_float():
  class FloatRequired (line 27) | class FloatRequired(ModelSQL):
  class FloatDigits (line 34) | class FloatDigits(ModelSQL):
  function register (line 43) | def register(module):

FILE: trytond/tests/field_function.py
  class FunctionAccessor (line 9) | class FunctionAccessor(ModelSQL):
    method on_change_with_function (line 19) | def on_change_with_function(self, name=None):
  class FunctionAccessorTarget (line 24) | class FunctionAccessorTarget(ModelSQL):
  class FunctionGetterContext (line 29) | class FunctionGetterContext(ModelSQL):
    method getter (line 40) | def getter(self, name):
  class FunctionGetterLocalCache (line 46) | class FunctionGetterLocalCache(ModelSQL):
    method get_function1 (line 55) | def get_function1(self, name):
    method get_function2 (line 58) | def get_function2(self, name):
    method index_get_field (line 62) | def index_get_field(cls, name):
  function register (line 69) | def register(module):

FILE: trytond/tests/field_integer.py
  class Integer (line 8) | class Integer(ModelSQL):
  class IntegerDefault (line 15) | class IntegerDefault(ModelSQL):
    method default_integer (line 22) | def default_integer():
  class IntegerRequired (line 26) | class IntegerRequired(ModelSQL):
  class IntegerDomain (line 33) | class IntegerDomain(ModelSQL):
  function register (line 39) | def register(module):

FILE: trytond/tests/field_many2many.py
  class Many2Many (line 9) | class Many2Many(ModelSQL):
  class Many2ManyTarget (line 16) | class Many2ManyTarget(ModelSQL):
  class Many2ManyRelation (line 22) | class Many2ManyRelation(ModelSQL):
  class Many2ManyRequired (line 29) | class Many2ManyRequired(ModelSQL):
  class Many2ManyRequiredTarget (line 36) | class Many2ManyRequiredTarget(ModelSQL):
  class Many2ManyRequiredRelation (line 42) | class Many2ManyRequiredRelation(ModelSQL):
  class Many2ManyReference (line 49) | class Many2ManyReference(ModelSQL):
  class Many2ManyReferenceTarget (line 56) | class Many2ManyReferenceTarget(ModelSQL):
  class Many2ManyReferenceRelation (line 62) | class Many2ManyReferenceRelation(ModelSQL):
  class Many2ManySize (line 73) | class Many2ManySize(ModelSQL):
  class Many2ManySizeTarget (line 80) | class Many2ManySizeTarget(ModelSQL):
  class Many2ManySizeRelation (line 86) | class Many2ManySizeRelation(ModelSQL):
  class Many2ManyFilter (line 93) | class Many2ManyFilter(ModelSQL):
  class Many2ManyFilterTarget (line 106) | class Many2ManyFilterTarget(ModelSQL):
  class Many2ManyFilterRelation (line 112) | class Many2ManyFilterRelation(ModelSQL):
  class Many2ManyFilterDomain (line 119) | class Many2ManyFilterDomain(ModelSQL):
  class Many2ManyFilterDomainTarget (line 129) | class Many2ManyFilterDomainTarget(ModelSQL):
  class Many2ManyFilterDomainRelation (line 135) | class Many2ManyFilterDomainRelation(ModelSQL):
  class Many2ManyTree (line 142) | class Many2ManyTree(ModelSQL):
  class Many2ManyTreeRelation (line 151) | class Many2ManyTreeRelation(ModelSQL):
  class Many2ManyContext (line 158) | class Many2ManyContext(ModelSQL):
  class Many2ManyContextRelation (line 166) | class Many2ManyContextRelation(ModelSQL):
  class Many2ManyContextTarget (line 173) | class Many2ManyContextTarget(ModelSQL):
    method get_context (line 178) | def get_context(self, name):
  function register (line 183) | def register(module):

FILE: trytond/tests/field_many2one.py
  class Many2OneTarget (line 9) | class Many2OneTarget(DeactivableMixin, ModelSQL):
  class Many2One (line 17) | class Many2One(ModelSQL):
  class Many2OneDomainValidation (line 23) | class Many2OneDomainValidation(ModelSQL):
  class Many2OneNoForeignKey (line 34) | class Many2OneNoForeignKey(ModelSQL):
  class Many2OneTargetStorage (line 40) | class Many2OneTargetStorage(ModelStorage):
  class Many2OneTree (line 45) | class Many2OneTree(ModelSQL):
  class Many2OneMPTT (line 51) | class Many2OneMPTT(ModelSQL):
    method default_left (line 60) | def default_left(cls):
    method default_right (line 64) | def default_right(cls):
  class Many2OnePath (line 68) | class Many2OnePath(ModelSQL):
  class Many2OneContext (line 75) | class Many2OneContext(ModelSQL):
  class Many2OneTargetContext (line 83) | class Many2OneTargetContext(ModelSQL):
    method get_context (line 88) | def get_context(self, name):
  function register (line 93) | def register(module):

FILE: trytond/tests/field_multiselection.py
  class MultiSelection (line 8) | class MultiSelection(ModelSQL):
    method get_dyn_selection (line 23) | def get_dyn_selection(self):
    method get_static_selection (line 30) | def get_static_selection(cls):
  class MultiSelectionRequired (line 34) | class MultiSelectionRequired(ModelSQL):
  function register (line 41) | def register(module):

FILE: trytond/tests/field_numeric.py
  class Numeric (line 11) | class Numeric(ModelSQL):
  class NumericDefault (line 18) | class NumericDefault(ModelSQL):
    method default_numeric (line 25) | def default_numeric():
  class NumericRequired (line 29) | class NumericRequired(ModelSQL):
  class NumericDigits (line 36) | class NumericDigits(ModelSQL):
  function register (line 45) | def register(module):

FILE: trytond/tests/field_one2many.py
  class One2Many (line 10) | class One2Many(ModelSQL):
  class One2ManyTarget (line 16) | class One2ManyTarget(ModelSQL):
  class One2ManyRequired (line 23) | class One2ManyRequired(ModelSQL):
  class One2ManyRequiredTarget (line 30) | class One2ManyRequiredTarget(ModelSQL):
  class One2ManyReference (line 37) | class One2ManyReference(ModelSQL):
  class One2ManyReferenceTarget (line 44) | class One2ManyReferenceTarget(ModelSQL):
  class One2ManySize (line 54) | class One2ManySize(ModelSQL):
  class One2ManySizeTarget (line 61) | class One2ManySizeTarget(ModelSQL):
  class One2ManySizePYSON (line 67) | class One2ManySizePYSON(ModelSQL):
  class One2ManySizePYSONTarget (line 75) | class One2ManySizePYSONTarget(ModelSQL):
  class One2ManyFilter (line 81) | class One2ManyFilter(ModelSQL):
  class One2ManyFilterTarget (line 90) | class One2ManyFilterTarget(ModelSQL):
  class One2ManyFilterDomain (line 97) | class One2ManyFilterDomain(ModelSQL):
  class One2ManyFilterDomainTarget (line 107) | class One2ManyFilterDomainTarget(ModelSQL):
  class One2ManyContext (line 114) | class One2ManyContext(ModelSQL):
  class One2ManyContextTarget (line 122) | class One2ManyContextTarget(ModelSQL):
    method get_context (line 128) | def get_context(self, name):
  function register (line 133) | def register(module):

FILE: trytond/tests/field_one2one.py
  class One2One (line 8) | class One2One(ModelSQL):
  class One2OneTarget (line 15) | class One2OneTarget(ModelSQL):
  class One2OneRelation (line 21) | class One2OneRelation(ModelSQL):
    method __setup__ (line 28) | def __setup__(cls):
  class One2OneRequired (line 39) | class One2OneRequired(ModelSQL):
  class One2OneRequiredRelation (line 46) | class One2OneRequiredRelation(ModelSQL):
    method __setup__ (line 53) | def __setup__(cls):
  class One2OneDomain (line 64) | class One2OneDomain(ModelSQL):
  class One2OneDomainRelation (line 72) | class One2OneDomainRelation(ModelSQL):
    method __setup__ (line 79) | def __setup__(cls):
  function register (line 90) | def register(module):

FILE: trytond/tests/field_reference.py
  class Reference (line 10) | class Reference(ModelSQL):
  class ReferenceTarget (line 19) | class ReferenceTarget(ModelSQL):
  class ReferenceRequired (line 25) | class ReferenceRequired(ModelSQL):
  class ReferenceContext (line 34) | class ReferenceContext(ModelSQL):
  class ReferenceContextTarget (line 43) | class ReferenceContextTarget(ModelSQL):
    method get_context (line 48) | def get_context(self, name):
  class ReferenceDomainValidation (line 53) | class ReferenceDomainValidation(ModelSQL):
  class ReferenceDomainValidationTarget (line 68) | class ReferenceDomainValidationTarget(ModelSQL):
  class ReferenceDomainValidationPYSON (line 74) | class ReferenceDomainValidationPYSON(ModelSQL):
  function register (line 91) | def register(module):

FILE: trytond/tests/field_selection.py
  class Selection (line 8) | class Selection(ModelSQL):
    method get_selection (line 30) | def get_selection(self):
    method static_selection (line 37) | def static_selection():
  class SelectionRequired (line 41) | class SelectionRequired(ModelSQL):
  class SelectionLabel (line 48) | class SelectionLabel(ModelSQL):
  function register (line 58) | def register(module):

FILE: trytond/tests/field_text.py
  class Text (line 8) | class Text(ModelSQL):
  class TextDefault (line 15) | class TextDefault(ModelSQL):
    method default_text (line 22) | def default_text():
  class TextRequired (line 26) | class TextRequired(ModelSQL):
  class TextSize (line 33) | class TextSize(ModelSQL):
  class TextTranslate (line 40) | class TextTranslate(ModelSQL):
  class FullText (line 47) | class FullText(ModelSQL):
  function register (line 53) | def register(module):

FILE: trytond/tests/field_time.py
  class Time (line 10) | class Time(ModelSQL):
  class TimeDefault (line 16) | class TimeDefault(ModelSQL):
    method default_time (line 22) | def default_time():
  class TimeRequired (line 26) | class TimeRequired(ModelSQL):
  class TimeFormat (line 32) | class TimeFormat(ModelSQL):
  class TimePrecision (line 38) | class TimePrecision(ModelSQL):
  function register (line 44) | def register(module):

FILE: trytond/tests/field_timedelta.py
  class TimeDelta (line 10) | class TimeDelta(ModelSQL):
  class TimeDeltaDefault (line 17) | class TimeDeltaDefault(ModelSQL):
    method default_timedelta (line 24) | def default_timedelta():
  class TimeDeltaRequired (line 28) | class TimeDeltaRequired(ModelSQL):
  function register (line 35) | def register(module):

FILE: trytond/tests/history.py
  class TestHistory (line 7) | class TestHistory(ModelSQL):
  class TestHistoryLine (line 19) | class TestHistoryLine(ModelSQL):
  function register (line 27) | def register(module):

FILE: trytond/tests/import_data.py
  class ImportDataBoolean (line 8) | class ImportDataBoolean(ModelSQL):
  class ImportDataInteger (line 14) | class ImportDataInteger(ModelSQL):
  class ImportDataFloat (line 20) | class ImportDataFloat(ModelSQL):
  class ImportDataNumeric (line 26) | class ImportDataNumeric(ModelSQL):
  class ImportDataChar (line 32) | class ImportDataChar(ModelSQL):
  class ImportDataText (line 38) | class ImportDataText(ModelSQL):
  class ImportDataDate (line 44) | class ImportDataDate(ModelSQL):
  class ImportDataDateTime (line 50) | class ImportDataDateTime(ModelSQL):
  class ImportDataTimeDelta (line 56) | class ImportDataTimeDelta(ModelSQL):
  class ImportDataSelection (line 62) | class ImportDataSelection(ModelSQL):
  class ImportDataMany2OneTarget (line 72) | class ImportDataMany2OneTarget(ModelSQL):
  class ImportDataMany2One (line 78) | class ImportDataMany2One(ModelSQL):
  class ImportDataMany2ManyTarget (line 85) | class ImportDataMany2ManyTarget(ModelSQL):
  class ImportDataMany2Many (line 91) | class ImportDataMany2Many(ModelSQL):
  class ImportDataMany2ManyRelation (line 98) | class ImportDataMany2ManyRelation(ModelSQL):
  class ImportDataOne2Many (line 105) | class ImportDataOne2Many(ModelSQL):
  class ImportDataOne2ManyTarget (line 113) | class ImportDataOne2ManyTarget(ModelSQL):
  class ImportDataOne2Manies (line 120) | class ImportDataOne2Manies(ModelSQL):
  class ImportDataOne2Many1Target (line 130) | class ImportDataOne2Many1Target(ModelSQL):
  class ImportDataOne2Many2Target (line 137) | class ImportDataOne2Many2Target(ModelSQL):
  class ImportDataBinary (line 144) | class ImportDataBinary(ModelSQL):
  class ImportDataReferenceSelection (line 150) | class ImportDataReferenceSelection(ModelSQL):
  class ImportDataReference (line 156) | class ImportDataReference(ModelSQL):
  class ImportDataUpdate (line 165) | class ImportDataUpdate(ModelSQL):
  function register (line 171) | def register(module):

FILE: trytond/tests/mixin.py
  class TestMixin (line 8) | class TestMixin:
  class TestSecondMixin (line 12) | class TestSecondMixin:
  class NotMixin (line 16) | class NotMixin:
  class ReportMixin (line 20) | class ReportMixin:
  class DeactivableModelView (line 24) | class DeactivableModelView(DeactivableMixin, ModelView):
  class DeactivableModelSQL (line 29) | class DeactivableModelSQL(DeactivableMixin, ModelSQL):
  function register (line 34) | def register(module):

FILE: trytond/tests/model.py
  class Model (line 9) | class Model(ModelSQL):
  class ModelParent (line 15) | class ModelParent(Model):
  class ModelChild (line 21) | class ModelChild(Model):
  class ModelChildChild (line 28) | class ModelChildChild(Model):
  class ModelContext (line 35) | class ModelContext(Model):
  class ModelContextParent (line 46) | class ModelContextParent(Model):
  class Singleton (line 57) | class Singleton(ModelSingleton, ModelSQL):
    method default_name (line 63) | def default_name():
  class URLObject (line 67) | class URLObject(ModelSQL):
  class Model4Union1 (line 73) | class Model4Union1(ModelSQL):
  class Model4Union2 (line 80) | class Model4Union2(ModelSQL):
  class Model4Union3 (line 86) | class Model4Union3(ModelSQL):
  class Model4Union4 (line 92) | class Model4Union4(ModelSQL):
  class Union (line 98) | class Union(UnionMixin, ModelSQL):
    method union_models (line 105) | def union_models():
  class UnionUnion (line 109) | class UnionUnion(UnionMixin, ModelSQL):
    method union_models (line 115) | def union_models():
  class Model4UnionTree1 (line 119) | class Model4UnionTree1(ModelSQL):
  class Model4UnionTree2 (line 125) | class Model4UnionTree2(ModelSQL):
  class UnionTree (line 132) | class UnionTree(UnionMixin, ModelSQL):
    method union_models (line 140) | def union_models():
  class SequenceOrderedModel (line 144) | class SequenceOrderedModel(sequence_ordered(), ModelSQL):
  function register (line 149) | def register(module):

FILE: trytond/tests/modelsql.py
  class ModelSQLRead (line 12) | class ModelSQLRead(ModelSQL):
  class ModelSQLReadTarget (line 22) | class ModelSQLReadTarget(ModelSQL):
  class ModelSQLReadContextID (line 30) | class ModelSQLReadContextID(ModelSQL):
  class ModelSQLRequiredField (line 38) | class ModelSQLRequiredField(ModelSQL):
  class ModelSQLTimestamp (line 46) | class ModelSQLTimestamp(ModelSQL):
  class ModelSQLFieldSet (line 51) | class ModelSQLFieldSet(ModelSQL):
    method get_field (line 58) | def get_field(self, name=None):
    method set_field (line 62) | def set_field(cls, records, name, value):
  class ModelSQLOne2Many (line 66) | class ModelSQLOne2Many(ModelSQL):
  class ModelSQLOne2ManyTarget (line 73) | class ModelSQLOne2ManyTarget(ModelSQL):
  class ModelSQLSearch (line 80) | class ModelSQLSearch(ModelSQL):
  class ModelSQLSearchOR2Union (line 86) | class ModelSQLSearchOR2Union(ModelSQL):
    method order_integer (line 102) | def order_integer(cls, tables):
  class ModelSQLSearchOR2UnionTarget (line 107) | class ModelSQLSearchOR2UnionTarget(ModelSQL):
  class ModelSQLSearchOR2UnionOrder (line 114) | class ModelSQLSearchOR2UnionOrder(ModelSQL):
    method __setup__ (line 127) | def __setup__(cls):
  class ModelSQLSearchOR2UnionOrderTarget (line 132) | class ModelSQLSearchOR2UnionOrderTarget(ModelSQL):
  class ModelSQLForeignKey (line 140) | class ModelSQLForeignKey(DeactivableMixin, ModelSQL):
  class ModelSQLForeignKeyTarget (line 152) | class ModelSQLForeignKeyTarget(ModelSQL):
  class NullOrder (line 157) | class NullOrder(ModelSQL):
  class ModelTranslation (line 163) | class ModelTranslation(ModelSQL):
  class ModelCheck (line 169) | class ModelCheck(ModelSQL):
    method __setup__ (line 175) | def __setup__(cls):
  class ModelUnique (line 184) | class ModelUnique(ModelSQL):
    method __setup__ (line 190) | def __setup__(cls):
  class ModelExclude (line 198) | class ModelExclude(ModelSQL):
    method default_condition (line 205) | def default_condition(cls):
    method __setup__ (line 209) | def __setup__(cls):
  class ModelLock (line 219) | class ModelLock(ModelSQL):
  function register (line 224) | def register(module):

FILE: trytond/tests/modelstorage.py
  class ModelStorage (line 11) | class ModelStorage(ModelSQL):
  class ModelStorageRequired (line 17) | class ModelStorageRequired(ModelSQL):
  class ModelStorageSave2Many (line 23) | class ModelStorageSave2Many(ModelSQL):
  class ModelStorageSave2ManyTarget (line 32) | class ModelStorageSave2ManyTarget(ModelSQL):
  class ModelStorageSave2ManyRelation (line 38) | class ModelStorageSave2ManyRelation(ModelSQL):
  class ModelStorageContext (line 45) | class ModelStorageContext(ModelSQL):
    method get_context (line 50) | def get_context(self, name):
  class ModelStoragePYSONDomain (line 54) | class ModelStoragePYSONDomain(ModelSQL):
  class ModelStorageRelationDomain (line 66) | class ModelStorageRelationDomain(ModelSQL):
  class ModelStorageRelationDomainTarget (line 104) | class ModelStorageRelationDomainTarget(ModelSQL):
    method get_valid (line 111) | def get_valid(self, name):
    method search_valid (line 115) | def search_valid(cls, name, domain):
  class ModelStorageRelationMultiDomain (line 122) | class ModelStorageRelationMultiDomain(ModelSQL):
  class ModelStorageRelationMultiDomainTarget (line 133) | class ModelStorageRelationMultiDomainTarget(ModelSQL):
  class ModelStorageRelationDomain2 (line 140) | class ModelStorageRelationDomain2(ModelSQL):
  class ModelStorageRelationDomain2Target (line 150) | class ModelStorageRelationDomain2Target(ModelSQL):
  class ModelStorageEvalEnvironment (line 157) | class ModelStorageEvalEnvironment(ModelStorage_):
  function register (line 175) | def register(module):

FILE: trytond/tests/modelview.py
  class ModelViewChangedValues (line 9) | class ModelViewChangedValues(ModelView):
  class ModelViewChangedValuesDictSchema (line 30) | class ModelViewChangedValuesDictSchema(DictSchemaMixin, ModelSQL):
  class ModelViewChangedValuesTarget (line 35) | class ModelViewChangedValuesTarget(ModelView):
  class ModelViewChangedValuesStoredTarget (line 42) | class ModelViewChangedValuesStoredTarget(ModelSQL):
  class ModelViewStoredChangedValues (line 48) | class ModelViewStoredChangedValues(ModelSQL, ModelView):
  class ModelViewStoredChangedValuesTarget (line 55) | class ModelViewStoredChangedValuesTarget(ModelSQL, ModelView):
  class ModelViewButton (line 62) | class ModelViewButton(ModelView):
    method __setup__ (line 68) | def __setup__(cls):
    method test (line 76) | def test(cls, records):
    method test_non_decorated (line 80) | def test_non_decorated(cls, records):
  class ModelViewButtonDepends (line 84) | class ModelViewButtonDepends(ModelView):
    method __setup__ (line 90) | def __setup__(cls):
    method test (line 100) | def test(cls, records):
  class ModelViewButtonAction (line 104) | class ModelViewButtonAction(ModelView):
    method __setup__ (line 109) | def __setup__(cls):
    method test (line 117) | def test(cls, records):
    method test_update (line 122) | def test_update(cls, records):
  class ModelViewButtonChange (line 126) | class ModelViewButtonChange(ModelView):
    method __setup__ (line 134) | def __setup__(cls):
    method test (line 141) | def test(self):
    method extra_method (line 145) | def extra_method(self):
  class ModelViewLink (line 149) | class ModelViewLink(ModelView):
  class ModelViewLinkTarget (line 154) | class ModelViewLinkTarget(ModelSQL):
  class ModelViewRPC (line 159) | class ModelViewRPC(ModelView):
    method on_change_with_integer (line 183) | def on_change_with_integer(self):
    method on_change_float (line 187) | def on_change_float(self):
    method autocomplete_char (line 191) | def autocomplete_char(self):
    method get_selection (line 195) | def get_selection(cls):
    method get_function_selection (line 199) | def get_function_selection(cls):
    method get_reference (line 203) | def get_reference(cls):
    method get_function_reference (line 207) | def get_function_reference(cls):
  class ModelViewEmptyPage (line 211) | class ModelViewEmptyPage(ModelView):
  class ModelViewCircularDepends (line 216) | class ModelViewCircularDepends(ModelView):
  class ModeViewDependsDepends (line 225) | class ModeViewDependsDepends(ModelView):
  class ModelViewViewAttributes (line 234) | class ModelViewViewAttributes(ModelView):
    method view_attributes (line 241) | def view_attributes(cls):
  class ModelViewViewAttributesDepends (line 248) | class ModelViewViewAttributesDepends(ModelView):
    method view_attributes (line 256) | def view_attributes(cls):
  class ModelViewStatesDepends (line 263) | class ModelViewStatesDepends(ModelView):
  function register (line 278) | def register(module):

FILE: trytond/tests/mptt.py
  class MPTT (line 11) | class MPTT(DeactivableMixin, tree(), ModelSQL, ModelView):
    method order_sequence (line 21) | def order_sequence(tables):
    method default_left (line 26) | def default_left():
    method default_right (line 30) | def default_right():
  function register (line 34) | def register(module):

FILE: trytond/tests/multivalue.py
  class ModelMultiValue (line 7) | class ModelMultiValue(ModelSQL, MultiValueMixin):
    method multivalue_model (line 30) | def multivalue_model(cls, field):
    method default_value (line 44) | def default_value(cls, **pattern):
    method default_value_default (line 48) | def default_value_default(cls, **pattern):
    method default_value_multiselection (line 52) | def default_value_multiselection(cls, **pattern):
  class ModelValue (line 56) | class ModelValue(ModelSQL, ValueMixin):
  class ModelMultiValueTarget (line 78) | class ModelMultiValueTarget(ModelSQL):
  function register (line 84) | def register(module):

FILE: trytond/tests/path.py
  class Path (line 7) | class Path(DeactivableMixin, tree(), ModelSQL):
  function register (line 16) | def register(module):

FILE: trytond/tests/resource.py
  class TestResource (line 8) | class TestResource(ModelSQL, NoteCopyMixin):
    method get_resources_to_copy (line 13) | def get_resources_to_copy(cls, name):
  class TestResourceOther (line 17) | class TestResourceOther(ModelSQL):
  function register (line 22) | def register(module):

FILE: trytond/tests/rule.py
  class TestRule (line 7) | class TestRule(ModelSQL):
  class TestRuleRelation (line 14) | class TestRuleRelation(ModelSQL):
  class TestRuleModel (line 20) | class TestRuleModel(ModelSQL):
    method __setup__ (line 29) | def __setup__(cls):
  function register (line 34) | def register(module):

FILE: trytond/tests/test_access.py
  class _ModelAccessTestCase (line 14) | class _ModelAccessTestCase(unittest.TestCase):
    method setUpClass (line 18) | def setUpClass(cls):
    method model (line 24) | def model(self):
    method group (line 31) | def group(self):
    method _assert (line 37) | def _assert(self, record):
    method _assert_raises (line 40) | def _assert_raises(self, record):
    method test_access_empty (line 44) | def test_access_empty(self):
    method test_access_without_group (line 53) | def test_access_without_group(self):
    method test_no_access_without_group (line 68) | def test_no_access_without_group(self):
    method test_one_access_with_groups (line 83) | def test_one_access_with_groups(self):
    method test_one_access_without_group (line 103) | def test_one_access_without_group(self):
    method test_all_access_with_groups (line 123) | def test_all_access_with_groups(self):
    method test_no_access_with_groups (line 143) | def test_no_access_with_groups(self):
    method test_one_access_with_group (line 163) | def test_one_access_with_group(self):
    method test_no_access_with_group (line 178) | def test_no_access_with_group(self):
    method test_one_access_with_other_group (line 193) | def test_one_access_with_other_group(self):
    method test_no_access_with_other_group (line 215) | def test_no_access_with_other_group(self):
    method test_one_access_with_other_group_no_perm (line 237) | def test_one_access_with_other_group_no_perm(self):
    method test_access_inherited_from_parent (line 259) | def test_access_inherited_from_parent(self):
  class ModelAccessReadTestCase (line 284) | class ModelAccessReadTestCase(_ModelAccessTestCase):
    method _assert (line 287) | def _assert(self, record):
    method _assert_raises (line 293) | def _assert_raises(self, record):
    method test_access_relate_empty (line 302) | def test_access_relate_empty(self):
    method test_access_relate (line 313) | def test_access_relate(self):
    method test_no_access_relate (line 334) | def test_no_access_relate(self):
  class ModelAccessWriteTestCase (line 358) | class ModelAccessWriteTestCase(_ModelAccessTestCase):
    method _assert (line 361) | def _assert(self, record):
    method _assert_raises (line 366) | def _assert_raises(self, record):
  class ModelAccessCreateTestCase (line 373) | class ModelAccessCreateTestCase(_ModelAccessTestCase):
    method _assert (line 376) | def _assert(self, record):
    method _assert_raises (line 381) | def _assert_raises(self, record):
  class ModelAccessDeleteTestCase (line 388) | class ModelAccessDeleteTestCase(_ModelAccessTestCase):
    method _assert (line 391) | def _assert(self, record):
    method _assert_raises (line 396) | def _assert_raises(self, record):
  class ModelAccessModelTestCase (line 403) | class ModelAccessModelTestCase(_ModelAccessTestCase):
    method _assert (line 407) | def _assert(self, record):
    method _assert_raises (line 413) | def _assert_raises(self, record):
  class _ModelFieldAccessTestCase (line 422) | class _ModelFieldAccessTestCase(unittest.TestCase):
    method setUpClass (line 426) | def setUpClass(cls):
    method _field (line 429) | def _field(self, name):
    method field1 (line 439) | def field1(self):
    method field2 (line 443) | def field2(self):
    method group (line 447) | def group(self):
    method _assert1 (line 453) | def _assert1(self, record):
    method _assert2 (line 456) | def _assert2(self, record):
    method _assert_raises1 (line 459) | def _assert_raises1(self, record):
    method _assert_raises2 (line 462) | def _assert_raises2(self, record):
    method test_access_empty (line 466) | def test_access_empty(self):
    method test_access_without_group (line 476) | def test_access_without_group(self):
    method test_no_access_without_group (line 492) | def test_no_access_without_group(self):
    method test_one_access_with_groups (line 508) | def test_one_access_with_groups(self):
    method test_one_access_without_group (line 529) | def test_one_access_without_group(self):
    method test_all_access_with_groups (line 550) | def test_all_access_with_groups(self):
    method test_no_access_with_groups (line 571) | def test_no_access_with_groups(self):
    method test_one_access_with_group (line 592) | def test_one_access_with_group(self):
    method test_no_access_with_group (line 608) | def test_no_access_with_group(self):
    method test_one_access_with_other_group (line 624) | def test_one_access_with_other_group(self):
    method test_no_access_with_other_group (line 647) | def test_no_access_with_other_group(self):
    method test_one_access_with_other_group_no_perm (line 670) | def test_one_access_with_other_group_no_perm(self):
    method test_access_inherited_from_parent (line 693) | def test_access_inherited_from_parent(self):
    method test_two_access (line 719) | def test_two_access(self):
    method test_two_no_access (line 742) | def test_two_no_access(self):
    method test_two_both_access (line 765) | def test_two_both_access(self):
    method test_two_access_with_group (line 788) | def test_two_access_with_group(self):
    method test_two_access_with_groups (line 811) | def test_two_access_with_groups(self):
    method test_two_no_access_with_group (line 834) | def test_two_no_access_with_group(self):
    method test_two_both_access_with_group (line 857) | def test_two_both_access_with_group(self):
  class ModelFieldAccessReadTestCase (line 880) | class ModelFieldAccessReadTestCase(_ModelFieldAccessTestCase):
    method _assert1 (line 883) | def _assert1(self, record):
    method _assert2 (line 889) | def _assert2(self, record):
    method _assert_raises1 (line 895) | def _assert_raises1(self, record):
    method _assert_raises2 (line 903) | def _assert_raises2(self, record):
    method test_access_search_relate_empty (line 912) | def test_access_search_relate_empty(self):
    method test_access_search_relate (line 921) | def test_access_search_relate(self):
    method test_no_access_search_relate (line 943) | def test_no_access_search_relate(self):
    method test_access_search_relate_parent_field (line 970) | def test_access_search_relate_parent_field(self):
    method test_no_access_search_relate_parent_field (line 988) | def test_no_access_search_relate_parent_field(self):
  class ModelFieldAccessWriteTestCase (line 1007) | class ModelFieldAccessWriteTestCase(_ModelFieldAccessTestCase):
    method _assert1 (line 1010) | def _assert1(self, record):
    method _assert2 (line 1015) | def _assert2(self, record):
    method _assert_raises1 (line 1020) | def _assert_raises1(self, record):
    method _assert_raises2 (line 1026) | def _assert_raises2(self, record):

FILE: trytond/tests/test_backend.py
  class BackendTestCase (line 14) | class BackendTestCase(unittest.TestCase):
    method setUpClass (line 18) | def setUpClass(cls):
    method test_current_timestamp_static_transaction (line 22) | def test_current_timestamp_static_transaction(self):
    method test_current_timestamp_reset_after_commit (line 35) | def test_current_timestamp_reset_after_commit(self):
    method test_current_timestamp_different_transaction (line 49) | def test_current_timestamp_different_transaction(self):
    method test_to_char_datetime (line 65) | def test_to_char_datetime(self):
    method test_to_char_date (line 77) | def test_to_char_date(self):
    method test_functions (line 89) | def test_functions(self):
    method test_function_random (line 142) | def test_function_random(self):
    method test_function_setseed (line 151) | def test_function_setseed(self):
    method test_function_date_trunc (line 157) | def test_function_date_trunc(self):

FILE: trytond/tests/test_bus.py
  class MessageQueueTestCase (line 15) | class MessageQueueTestCase(unittest.TestCase):
    method setUp (line 17) | def setUp(self):
    method _time (line 20) | def _time(self):
    method test_get_next (line 25) | def test_get_next(self):
    method test_get_next_channels (line 35) | def test_get_next_channels(self):
    method test_get_next_timeout_expired (line 46) | def test_get_next_timeout_expired(self):
    method test_get_next_message_id_missing (line 56) | def test_get_next_message_id_missing(self):
    method test_get_next_message_id_None (line 66) | def test_get_next_message_id_None(self):
  class BusTestCase (line 77) | class BusTestCase(unittest.TestCase):
    method setUpClass (line 81) | def setUpClass(cls):
    method setUp (line 85) | def setUp(self):
    method tearDown (line 98) | def tearDown(self):
    method test_notify (line 108) | def test_notify(self):
    method test_subscribe_nothing (line 113) | def test_subscribe_nothing(self):
    method test_subscribe_message (line 120) | def test_subscribe_message(self):

FILE: trytond/tests/test_cache.py
  class CacheTestCase (line 20) | class CacheTestCase(unittest.TestCase):
    method testFreeze (line 23) | def testFreeze(self):
    method testUnfreeze (line 45) | def testUnfreeze(self):
  class MemoryCacheTestCase (line 68) | class MemoryCacheTestCase(unittest.TestCase):
    method setUpClass (line 72) | def setUpClass(cls):
    method setUp (line 75) | def setUp(self):
    method tearDown (line 82) | def tearDown(self):
    method wait_cache_sync (line 85) | def wait_cache_sync(self, after=None):
    method test_memory_cache_set_get (line 89) | def test_memory_cache_set_get(self):
    method test_memory_cache_drop (line 96) | def test_memory_cache_drop(self):
    method test_memory_cache_transactions (line 103) | def test_memory_cache_transactions(self):
    method test_memory_cache_nested_transactions (line 128) | def test_memory_cache_nested_transactions(self):
    method test_memory_cache_sync (line 141) | def test_memory_cache_sync(self):
    method test_memory_cache_old_transaction (line 151) | def test_memory_cache_old_transaction(self):
    method test_memory_cache_expire (line 175) | def test_memory_cache_expire(self):
  class MemoryCacheChannelTestCase (line 184) | class MemoryCacheChannelTestCase(MemoryCacheTestCase):
    method setUp (line 187) | def setUp(self):
    method wait_cache_sync (line 194) | def wait_cache_sync(self, after=None):
    method test_memory_cache_sync (line 201) | def test_memory_cache_sync(self):
  class LRUDictTestCase (line 205) | class LRUDictTestCase(unittest.TestCase):
    method test_setitem (line 208) | def test_setitem(self):
    method test_update (line 218) | def test_update(self):
    method test_setdefault (line 229) | def test_setdefault(self):
    method test_default_factory (line 239) | def test_default_factory(self):
    method test_default_factory_with_key (line 247) | def test_default_factory_with_key(self):
  class LRUDictTransactionTestCase (line 254) | class LRUDictTransactionTestCase(unittest.TestCase):
    method setUpClass (line 258) | def setUpClass(cls):
    method test_init (line 262) | def test_init(self):
    method test_clear (line 269) | def test_clear(self):
    method test_refresh (line 279) | def test_refresh(self):

FILE: trytond/tests/test_copy.py
  class CopyTestCase (line 15) | class CopyTestCase(unittest.TestCase):
    method setUpClass (line 19) | def setUpClass(cls):
    method test_copy (line 23) | def test_copy(self):
    method test_copy_default (line 36) | def test_copy_default(self):
    method test_copy_default_callable (line 49) | def test_copy_default_callable(self):
    method test_one2many (line 66) | def test_one2many(self):
    method test_one2many_default (line 96) | def test_one2many_default(self):
    method test_one2many_default_nested (line 114) | def test_one2many_default_nested(self):
    method test_many2many (line 131) | def test_many2many(self):
    method test_many2many_default (line 161) | def test_many2many_default(self):
    method test_binary (line 178) | def test_binary(self):
    method test_binary_file_id (line 190) | def test_binary_file_id(self):
    method test_no_acccess_copy_with_custom_value (line 203) | def test_no_acccess_copy_with_custom_value(self):
    method test_no_acccess_copy_with_default (line 227) | def test_no_acccess_copy_with_default(self):
    method test_no_acccess_copy_with_defaults (line 251) | def test_no_acccess_copy_with_defaults(self):
  class CopyTranslationTestCase (line 276) | class CopyTranslationTestCase(TranslationTestCase):
    method test_copy (line 280) | def test_copy(self):
    method test_copy_multiple (line 300) | def test_copy_multiple(self):

FILE: trytond/tests/test_descriptors.py
  function load_tests (line 8) | def load_tests(loader, tests, pattern):

FILE: trytond/tests/test_exportdata.py
  class ExportDataTestCase (line 12) | class ExportDataTestCase(unittest.TestCase):
    method setUpClass (line 16) | def setUpClass(cls):
    method test_boolean (line 20) | def test_boolean(self):
    method test_integer (line 44) | def test_integer(self):
    method test_float (line 66) | def test_float(self):
    method test_numeric (line 88) | def test_numeric(self):
    method test_char (line 112) | def test_char(self):
    method test_text (line 134) | def test_text(self):
    method test_date (line 156) | def test_date(self):
    method test_datetime (line 178) | def test_datetime(self):
    method test_timedelta (line 202) | def test_timedelta(self):
    method test_selection (line 229) | def test_selection(self):
    method test_many2one (line 254) | def test_many2one(self):
    method test_many2many (line 283) | def test_many2many(self):
    method test_one2many (line 323) | def test_one2many(self):
    method test_reference (line 358) | def test_reference(self):
    method test_domain (line 392) | def test_domain(self):
    method test_header (line 409) | def test_header(self):
    method test_nested_header (line 423) | def test_nested_header(self):
    method test_header_domain (line 439) | def test_header_domain(self):

FILE: trytond/tests/test_field_binary.py
  class FieldBinaryTestCase (line 19) | class FieldBinaryTestCase(unittest.TestCase):
    method setUpClass (line 23) | def setUpClass(cls):
    method setUp (line 26) | def setUp(self):
    method test_create (line 34) | def test_create(self):
    method test_create_without_default (line 45) | def test_create_without_default(self):
    method test_create_with_default (line 54) | def test_create_with_default(self):
    method test_create_required_without_value (line 63) | def test_create_required_without_value(self):
    method test_create_required_with_value (line 71) | def test_create_required_with_value(self):
    method test_create_required_with_empty (line 82) | def test_create_required_with_empty(self):
    method test_create_filestorage (line 92) | def test_create_filestorage(self):
    method test_create_empty_filestorage (line 104) | def test_create_empty_filestorage(self):
    method test_create_with_sql_value (line 116) | def test_create_with_sql_value(self):
    method test_set_sql_value (line 127) | def test_set_sql_value(self):
    method test_read_size (line 137) | def test_read_size(self):
    method test_read_size_filestorage (line 150) | def test_read_size_filestorage(self):
    method test_write (line 164) | def test_write(self):
    method test_write_filestorage (line 178) | def test_write_filestorage(self):
    method test_write_empty_filestorage (line 192) | def test_write_empty_filestorage(self):

FILE: trytond/tests/test_field_boolean.py
  class FieldBooleanTestCase (line 11) | class FieldBooleanTestCase(unittest.TestCase):
    method setUpClass (line 15) | def setUpClass(cls):
    method test_create (line 19) | def test_create(self):
    method test_create_without_default (line 36) | def test_create_without_default(self):
    method test_create_with_default (line 45) | def test_create_with_default(self):
    method test_create_with_sql_value (line 54) | def test_create_with_sql_value(self):
    method test_set_sql_value (line 63) | def test_set_sql_value(self):
    method test_search_equals_true (line 73) | def test_search_equals_true(self):
    method test_search_equals_false (line 89) | def test_search_equals_false(self):
    method test_search_non_equals (line 105) | def test_search_non_equals(self):
    method test_search_in_true (line 118) | def test_search_in_true(self):
    method test_search_in_false (line 132) | def test_search_in_false(self):
    method test_search_not_in_true (line 146) | def test_search_not_in_true(self):
    method test_search_not_in_false (line 160) | def test_search_not_in_false(self):
    method test_search_in_true_false (line 174) | def test_search_in_true_false(self):
    method test_search_not_in_true_false (line 190) | def test_search_not_in_true_false(self):
    method test_search_equals_false_with_none (line 206) | def test_search_equals_false_with_none(self):
    method test_search_non_equals_false_with_none (line 219) | def test_search_non_equals_false_with_none(self):
    method test_write_false (line 232) | def test_write_false(self):
    method test_write_true (line 246) | def test_write_true(self):

FILE: trytond/tests/test_field_char.py
  class CommonTestCaseMixin (line 17) | class CommonTestCaseMixin:
    method test_create (line 20) | def test_create(self):
    method test_create_unicode (line 34) | def test_create_unicode(self):
    method test_search_equals (line 45) | def test_search_equals(self):
    method test_search_equals_none (line 63) | def test_search_equals_none(self):
    method test_search_equals_unicode (line 77) | def test_search_equals_unicode(self):
    method test_search_equals_non_unicode (line 91) | def test_search_equals_non_unicode(self):
    method test_search_non_equals (line 105) | def test_search_non_equals(self):
    method test_search_non_equals_none (line 123) | def test_search_non_equals_none(self):
    method test_search_in (line 137) | def test_search_in(self):
    method test_search_in_none (line 159) | def test_search_in_none(self):
    method test_search_not_in (line 173) | def test_search_not_in(self):
    method test_search_not_in_none (line 195) | def test_search_not_in_none(self):
    method test_search_like (line 209) | def test_search_like(self):
    method test_search_ilike (line 235) | def test_search_ilike(self):
    method test_search_not_like (line 261) | def test_search_not_like(self):
    method test_search_not_ilike (line 287) | def test_search_not_ilike(self):
    method test_write_unicode (line 313) | def test_write_unicode(self):
    method test_create_strip (line 327) | def test_create_strip(self):
    method test_write_strip (line 345) | def test_write_strip(self):
    method test_set_strip (line 369) | def test_set_strip(self):
  class FieldCharTestCase (line 385) | class FieldCharTestCase(unittest.TestCase, CommonTestCaseMixin):
    method setUpClass (line 389) | def setUpClass(cls):
    method Char (line 392) | def Char(self):
    method test_create_with_sql_value (line 396) | def test_create_with_sql_value(self):
    method test_set_sql_value (line 405) | def test_set_sql_value(self):
    method test_create_without_default (line 415) | def test_create_without_default(self):
    method test_create_with_default (line 424) | def test_create_with_default(self):
    method test_create_required_with_value (line 433) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 444) | def test_create_required_without_value(self):
    method test_create_required_with_empty (line 452) | def test_create_required_with_empty(self):
    method test_create_size_valid (line 462) | def test_create_size_valid(self):
    method test_create_size_invalid (line 473) | def test_create_size_invalid(self):
    method test_create_size_pyson_valid (line 483) | def test_create_size_pyson_valid(self):
    method test_create_size_pyson_invalid (line 495) | def test_create_size_pyson_invalid(self):
    method test_create_size_pyson_none (line 506) | def test_create_size_pyson_none(self):
    method test_create_invalid_char (line 517) | def test_create_invalid_char(self):
    method test_write (line 527) | def test_write(self):
    method test_write_none (line 541) | def test_write_none(self):
    method test_write_size_invalid (line 555) | def test_write_size_invalid(self):
    method test_create_strip_with_sql_value (line 569) | def test_create_strip_with_sql_value(self):
    method test_write_strip_with_sql_value (line 587) | def test_write_strip_with_sql_value(self):
  class FieldCharTranslatedTestCase (line 611) | class FieldCharTranslatedTestCase(unittest.TestCase, CommonTestCaseMixin):
    method setUpClass (line 615) | def setUpClass(cls):
    method Char (line 618) | def Char(self):
    method test_create_with_sql_value (line 622) | def test_create_with_sql_value(self):
    method test_translation_default_language_cache (line 630) | def test_translation_default_language_cache(self):
  class FieldCharUnaccentedTestCase (line 650) | class FieldCharUnaccentedTestCase(ExtensionTestCase):
    method setUpClass (line 655) | def setUpClass(cls):
    method test_normal_search (line 660) | def test_normal_search(self):
    method test_accented_search (line 674) | def test_accented_search(self):
    method test_unaccented_search (line 688) | def test_unaccented_search(self):
    method test_unaccented_translated_search (line 701) | def test_unaccented_translated_search(self):
  class FieldCharSimilarityTestCase (line 730) | class FieldCharSimilarityTestCase(ExtensionTestCase):
    method setUpClass (line 735) | def setUpClass(cls):
    method _test_search (line 739) | def _test_search(self, Model):
    method test_search (line 752) | def test_search(self):
    method test_search_translated (line 758) | def test_search_translated(self):
    method _test_order (line 763) | def _test_order(self, Model):
    method test_order (line 777) | def test_order(self):
    method test_order_translated (line 783) | def test_order_translated(self):

FILE: trytond/tests/test_field_context.py
  class FieldContextTestCase (line 10) | class FieldContextTestCase(unittest.TestCase):
    method setUpClass (line 14) | def setUpClass(cls):
    method test_context (line 18) | def test_context(self):

FILE: trytond/tests/test_field_date.py
  class FieldDateTestCase (line 21) | class FieldDateTestCase(unittest.TestCase):
    method setUpClass (line 25) | def setUpClass(cls):
    method test_create (line 29) | def test_create(self):
    method test_create_date_string (line 43) | def test_create_date_string(self):
    method test_create_invalid_date_string (line 54) | def test_create_invalid_date_string(self):
    method test_create_without_default (line 64) | def test_create_without_default(self):
    method test_create_with_default (line 73) | def test_create_with_default(self):
    method test_create_with_sql_value (line 82) | def test_create_with_sql_value(self):
    method test_set_sql_value (line 91) | def test_set_sql_value(self):
    method test_create_non_date (line 101) | def test_create_non_date(self):
    method test_create_integer (line 111) | def test_create_integer(self):
    method test_create_datetime (line 121) | def test_create_datetime(self):
    method test_create_required_with_value (line 131) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 142) | def test_create_required_without_value(self):
    method test_search_equals (line 150) | def test_search_equals(self):
    method test_search_equals_none (line 168) | def test_search_equals_none(self):
    method test_search_non_equals (line 182) | def test_search_non_equals(self):
    method test_search_non_equals_none (line 200) | def test_search_non_equals_none(self):
    method test_search_in (line 214) | def test_search_in(self):
    method test_search_in_none (line 236) | def test_search_in_none(self):
    method test_search_not_in (line 250) | def test_search_not_in(self):
    method test_search_not_in_none (line 272) | def test_search_not_in_none(self):
    method test_search_in_multi (line 286) | def test_search_in_multi(self):
    method test_search_not_in_multi (line 302) | def test_search_not_in_multi(self):
    method test_search_less (line 318) | def test_search_less(self):
    method test_search_less_equals (line 340) | def test_search_less_equals(self):
    method test_search_greater (line 362) | def test_search_greater(self):
    method test_search_greater_equals (line 384) | def test_search_greater_equals(self):
    method test_write (line 406) | def test_write(self):
    method test_write_non_date (line 420) | def test_write_non_date(self):
    method test_write_integer (line 433) | def test_write_integer(self):
    method test_write_datetime (line 446) | def test_write_datetime(self):
    method test_sql_cast_timezone (line 461) | def test_sql_cast_timezone(self):

FILE: trytond/tests/test_field_datetime.py
  class FieldDateTimeTestCase (line 19) | class FieldDateTimeTestCase(unittest.TestCase):
    method setUpClass (line 23) | def setUpClass(cls):
    method test_create (line 27) | def test_create(self):
    method test_create_datetime_string (line 41) | def test_create_datetime_string(self):
    method test_create_invalid_datetime_string (line 52) | def test_create_invalid_datetime_string(self):
    method test_create_without_default (line 62) | def test_create_without_default(self):
    method test_create_with_default (line 71) | def test_create_with_default(self):
    method test_create_with_sql_value (line 80) | def test_create_with_sql_value(self):
    method test_set_sql_value (line 91) | def test_set_sql_value(self):
    method test_create_non_datetime (line 101) | def test_create_non_datetime(self):
    method test_create_integer (line 111) | def test_create_integer(self):
    method test_create_date (line 121) | def test_create_date(self):
    method test_create_microsecond (line 131) | def test_create_microsecond(self):
    method test_create_required_with_value (line 142) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 153) | def test_create_required_without_value(self):
    method test_create_format_valid (line 161) | def test_create_format_valid(self):
    method test_create_format_invalid (line 173) | def test_create_format_invalid(self):
    method test_search_equals (line 183) | def test_search_equals(self):
    method test_search_equals_none (line 201) | def test_search_equals_none(self):
    method test_search_non_equals (line 215) | def test_search_non_equals(self):
    method test_search_non_equals_none (line 233) | def test_search_non_equals_none(self):
    method test_search_in (line 247) | def test_search_in(self):
    method test_search_in_none (line 269) | def test_search_in_none(self):
    method test_search_not_in (line 283) | def test_search_not_in(self):
    method test_search_not_in_none (line 305) | def test_search_not_in_none(self):
    method test_search_in_multi (line 319) | def test_search_in_multi(self):
    method test_search_not_in_multi (line 335) | def test_search_not_in_multi(self):
    method test_search_less (line 351) | def test_search_less(self):
    method test_search_less_equals (line 373) | def test_search_less_equals(self):
    method test_search_greater (line 395) | def test_search_greater(self):
    method test_search_greater_equals (line 417) | def test_search_greater_equals(self):
    method test_write (line 439) | def test_write(self):
    method test_write_non_datetime (line 453) | def test_write_non_datetime(self):
    method test_write_integer (line 466) | def test_write_integer(self):
    method test_write_date (line 479) | def test_write_date(self):

FILE: trytond/tests/test_field_depends.py
  class FieldDependsTestCase (line 10) | class FieldDependsTestCase(unittest.TestCase):
    method setUpClass (line 14) | def setUpClass(cls):
    method test_empty_depends (line 17) | def test_empty_depends(self):
    method test_empty_depends_default (line 30) | def test_empty_depends_default(self):
    method test_set_depends (line 48) | def test_set_depends(self):
    method test_parent (line 62) | def test_parent(self):
    method test_nested_parent (line 80) | def test_nested_parent(self):
    method test_inherit (line 104) | def test_inherit(self):
    method test_methods (line 127) | def test_methods(self):
    method test_methods_2 (line 148) | def test_methods_2(self):
    method test_field_context (line 174) | def test_field_context(self):
    method test_field_context_parent (line 195) | def test_field_context_parent(self):
    method test_property_depends (line 222) | def test_property_depends(self):
    method test_get_eval_fields (line 251) | def test_get_eval_fields(self):

FILE: trytond/tests/test_field_dict.py
  class FieldDictTestCase (line 13) | class FieldDictTestCase(unittest.TestCase):
    method setUpClass (line 17) | def setUpClass(cls):
    method create_schema (line 20) | def create_schema(self):
    method test_create (line 51) | def test_create(self):
    method test_create_without_schema (line 63) | def test_create_without_schema(self):
    method test_create_without_default (line 74) | def test_create_without_default(self):
    method test_create_with_default (line 84) | def test_create_with_default(self):
    method test_create_required_with_value (line 94) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 106) | def test_create_required_without_value(self):
    method test_create_required_with_empty (line 115) | def test_create_required_with_empty(self):
    method test_create_selection (line 126) | def test_create_selection(self):
    method test_create_multiselection (line 138) | def test_create_multiselection(self):
    method test_invalid_selection_schema (line 150) | def test_invalid_selection_schema(self):
    method test_create_text (line 164) | def test_create_text(self):
    method test_write (line 175) | def test_write(self):
    method test_write_wthout_schema (line 190) | def test_write_wthout_schema(self):
    method test_write_text (line 204) | def test_write_text(self):
    method test_search_element_equals (line 216) | def test_search_element_equals(self):
    method test_search_multiselection_equals (line 240) | def test_search_multiselection_equals(self):
    method test_search_element_equals_none (line 265) | def test_search_element_equals_none(self):
    method test_search_non_element_equals_none (line 281) | def test_search_non_element_equals_none(self):
    method test_search_element_non_equals (line 297) | def test_search_element_non_equals(self):
    method test_search_multiselection_not_equals (line 321) | def test_search_multiselection_not_equals(self):
    method test_search_element_non_equals_none (line 350) | def test_search_element_non_equals_none(self):
    method test_search_non_element_non_equals_none (line 366) | def test_search_non_element_non_equals_none(self):
    method test_search_element_equals_true (line 382) | def test_search_element_equals_true(self):
    method test_search_element_equals_false (line 400) | def test_search_element_equals_false(self):
    method test_search_element_non_equals_true (line 418) | def test_search_element_non_equals_true(self):
    method test_search_element_in (line 434) | def test_search_element_in(self):
    method test_search_multiselection_in (line 465) | def test_search_multiselection_in(self):
    method test_search_element_in_none (line 494) | def test_search_element_in_none(self):
    method test_search_element_not_in (line 510) | def test_search_element_not_in(self):
    method test_search_multiselection_not_in (line 541) | def test_search_multiselection_not_in(self):
    method test_search_element_not_in_none (line 570) | def test_search_element_not_in_none(self):
    method test_search_element_less (line 586) | def test_search_element_less(self):
    method test_search_element_less_equals (line 610) | def test_search_element_less_equals(self):
    method test_search_element_greater (line 634) | def test_search_element_greater(self):
    method test_search_element_greater_equals (line 658) | def test_search_element_greater_equals(self):
    method test_search_element_like (line 682) | def test_search_element_like(self):
    method test_search_element_ilike (line 714) | def test_search_element_ilike(self):
    method test_search_element_not_like (line 746) | def test_search_element_not_like(self):
    method test_search_element_not_ilike (line 778) | def test_search_element_not_ilike(self):
    method test_search_element_text (line 810) | def test_search_element_text(self):
    method test_search_order_element (line 825) | def test_search_order_element(self):
    method test_string (line 838) | def test_string(self):
    method test_string_keys (line 850) | def test_string_keys(self):
    method test_set_key (line 863) | def test_set_key(self):
  class FieldDictUnaccentedTestCase (line 878) | class FieldDictUnaccentedTestCase(ExtensionTestCase):
    method setUpClass (line 883) | def setUpClass(cls):
    method test_search_unaccented_off (line 888) | def test_search_unaccented_off(self):
    method test_search_accented (line 903) | def test_search_accented(self):
    method test_search_unaccented (line 918) | def test_search_unaccented(self):

FILE: trytond/tests/test_field_float.py
  class FieldFloatTestCase (line 13) | class FieldFloatTestCase(unittest.TestCase):
    method setUpClass (line 17) | def setUpClass(cls):
    method test_create (line 21) | def test_create(self):
    method test_create_15_digits (line 35) | def test_create_15_digits(self):
    method test_create_without_default (line 46) | def test_create_without_default(self):
    method test_create_with_default (line 55) | def test_create_with_default(self):
    method test_create_with_sql_value (line 64) | def test_create_with_sql_value(self):
    method test_set_sql_value (line 73) | def test_set_sql_value(self):
    method test_create_non_float (line 83) | def test_create_non_float(self):
    method test_create_required_with_value (line 93) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 104) | def test_create_required_without_value(self):
    method test_create_digits_valid (line 112) | def test_create_digits_valid(self):
    method test_create_digits_invalid (line 124) | def test_create_digits_invalid(self):
    method test_float_digits_none (line 135) | def test_float_digits_none(self):
    method test_search_equals (line 147) | def test_search_equals(self):
    method test_search_equals_none (line 165) | def test_search_equals_none(self):
    method test_search_non_equals (line 179) | def test_search_non_equals(self):
    method test_search_non_equals_none (line 197) | def test_search_non_equals_none(self):
    method test_search_in (line 211) | def test_search_in(self):
    method test_search_in_none (line 233) | def test_search_in_none(self):
    method test_search_not_in (line 247) | def test_search_not_in(self):
    method test_search_not_in_none (line 269) | def test_search_not_in_none(self):
    method test_search_in_multi (line 283) | def test_search_in_multi(self):
    method test_search_not_in_multi (line 299) | def test_search_not_in_multi(self):
    method test_search_less (line 315) | def test_search_less(self):
    method test_search_less_equals (line 337) | def test_search_less_equals(self):
    method test_search_greater (line 359) | def test_search_greater(self):
    method test_search_greater_equals (line 381) | def test_search_greater_equals(self):
    method test_write (line 403) | def test_write(self):
    method test_write_non_float (line 417) | def test_write_non_float(self):
    method test_write_digits_invalid_value (line 430) | def test_write_digits_invalid_value(self):
    method test_write_digits_invalid_digits (line 445) | def test_write_digits_invalid_digits(self):

FILE: trytond/tests/test_field_function.py
  class FieldFunctionTestCase (line 11) | class FieldFunctionTestCase(unittest.TestCase):
    method setUpClass (line 15) | def setUpClass(cls):
    method test_accessor (line 19) | def test_accessor(self):
    method test_getter_context (line 33) | def test_getter_context(self):
    method test_getter_cached_readonly_transaction (line 48) | def test_getter_cached_readonly_transaction(self):
    method test_getter_local_cache (line 76) | def test_getter_local_cache(self):

FILE: trytond/tests/test_field_integer.py
  class FieldIntegerTestCase (line 13) | class FieldIntegerTestCase(unittest.TestCase):
    method setUpClass (line 17) | def setUpClass(cls):
    method test_create (line 21) | def test_create(self):
    method test_create_without_default (line 35) | def test_create_without_default(self):
    method test_create_with_default (line 44) | def test_create_with_default(self):
    method test_create_with_sql_value (line 53) | def test_create_with_sql_value(self):
    method test_set_sql_value (line 62) | def test_set_sql_value(self):
    method test_create_non_integer (line 72) | def test_create_non_integer(self):
    method test_create_required_with_value (line 82) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 93) | def test_create_required_without_value(self):
    method test_create_with_domain_valid (line 101) | def test_create_with_domain_valid(self):
    method test_create_with_domain_invalid (line 112) | def test_create_with_domain_invalid(self):
    method test_search_equals (line 122) | def test_search_equals(self):
    method test_search_non_equals (line 140) | def test_search_non_equals(self):
    method test_search_in (line 158) | def test_search_in(self):
    method test_search_not_in (line 180) | def test_search_not_in(self):
    method test_search_in_multi (line 202) | def test_search_in_multi(self):
    method test_search_not_in_multi (line 218) | def test_search_not_in_multi(self):
    method test_search_less (line 234) | def test_search_less(self):
    method test_search_less_equals (line 256) | def test_search_less_equals(self):
    method test_search_greater (line 278) | def test_search_greater(self):
    method test_search_greater_equals (line 300) | def test_search_greater_equals(self):
    method test_write (line 322) | def test_write(self):
    method test_write_non_integer (line 336) | def test_write_non_integer(self):

FILE: trytond/tests/test_field_many2many.py
  class CommonTestCaseMixin (line 11) | class CommonTestCaseMixin:
    method test_create (line 14) | def test_create(self):
    method test_search_equals (line 29) | def test_search_equals(self):
    method test_search_equals_no_link (line 43) | def test_search_equals_no_link(self):
    method test_search_non_equals (line 58) | def test_search_non_equals(self):
    method test_search_equals_none (line 72) | def test_search_equals_none(self):
    method test_search_non_equals_none (line 88) | def test_search_non_equals_none(self):
    method test_search_non_equals_no_link (line 104) | def test_search_non_equals_no_link(self):
    method test_search_in (line 119) | def test_search_in(self):
    method test_search_in_0 (line 134) | def test_search_in_0(self):
    method test_search_in_empty (line 148) | def test_search_in_empty(self):
    method test_search_not_in (line 162) | def test_search_not_in(self):
    method test_search_not_in_0 (line 177) | def test_search_not_in_0(self):
    method test_search_not_in_empty (line 191) | def test_search_not_in_empty(self):
    method test_search_join (line 205) | def test_search_join(self):
    method test_search_where (line 219) | def test_search_where(self):
    method test_search_not_where (line 233) | def test_search_not_where(self):
    method test_search_not_where_others (line 247) | def test_search_not_where_others(self):
    method test_write_write (line 262) | def test_write_write(self):
    method test_write_add (line 281) | def test_write_add(self):
    method test_write_remove (line 297) | def test_write_remove(self):
    method test_write_copy (line 317) | def test_write_copy(self):
    method test_write_delete (line 337) | def test_write_delete(self):
    method test_write_not_readd (line 358) | def test_write_not_readd(self):
  class FieldMany2ManyTestCase (line 377) | class FieldMany2ManyTestCase(unittest.TestCase, CommonTestCaseMixin):
    method setUpClass (line 381) | def setUpClass(cls):
    method Many2Many (line 384) | def Many2Many(self):
    method Many2ManyTarget (line 387) | def Many2ManyTarget(self):
    method test_create_required_with_value (line 391) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 406) | def test_create_required_without_value(self):
    method test_create_size_valid (line 414) | def test_create_size_valid(self):
    method test_create_size_invalid (line 427) | def test_create_size_invalid(self):
    method test_create_filter (line 439) | def test_create_filter(self):
    method test_create_filter_domain (line 453) | def test_create_filter_domain(self):
    method test_search_non_equals_filter (line 467) | def test_search_non_equals_filter(self):
    method test_search_join_filter (line 482) | def test_search_join_filter(self):
    method create_tree (line 496) | def create_tree(self, Many2Many):
    method test_search_child_of_root1 (line 519) | def test_search_child_of_root1(self):
    method test_search_not_child_of_root1 (line 535) | def test_search_not_child_of_root1(self):
    method test_search_child_of_second1 (line 551) | def test_search_child_of_second1(self):
    method test_search_not_child_of_second1 (line 563) | def test_search_not_child_of_second1(self):
    method test_search_child_of_empty (line 579) | def test_search_child_of_empty(self):
    method test_search_not_child_of_empty (line 591) | def test_search_not_child_of_empty(self):
    method test_search_parent_of_root1 (line 607) | def test_search_parent_of_root1(self):
    method test_search_not_parent_of_root1 (line 619) | def test_search_not_parent_of_root1(self):
    method test_search_parent_of_second4 (line 635) | def test_search_parent_of_second4(self):
    method test_search_not_parent_of_second4 (line 649) | def test_search_not_parent_of_second4(self):
    method test_search_parent_of_empty (line 665) | def test_search_parent_of_empty(self):
    method test_search_not_parent_of_empty (line 677) | def test_search_not_parent_of_empty(self):
    method test_context_attribute (line 693) | def test_context_attribute(self):
    method test_context_read (line 705) | def test_context_read(self):
    method test_context_set (line 718) | def test_context_set(self):
  class FieldMany2ManyReferenceTestCase (line 730) | class FieldMany2ManyReferenceTestCase(unittest.TestCase, CommonTestCaseM...
    method setUpClass (line 734) | def setUpClass(cls):
    method Many2Many (line 737) | def Many2Many(self):
    method Many2ManyTarget (line 740) | def Many2ManyTarget(self):

FILE: trytond/tests/test_field_many2one.py
  class FieldMany2OneTestCase (line 10) | class FieldMany2OneTestCase(unittest.TestCase):
    method setUpClass (line 14) | def setUpClass(cls):
    method test_create_id (line 18) | def test_create_id(self):
    method test_create_instance (line 32) | def test_create_instance(self):
    method test_create_no_foreign_key (line 46) | def test_create_no_foreign_key(self):
    method test_create_with_domain_valid (line 58) | def test_create_with_domain_valid(self):
    method test_create_with_domain_invalid (line 72) | def test_create_with_domain_invalid(self):
    method test_create_with_domain_inactive (line 85) | def test_create_with_domain_inactive(self):
    method test_search_order_default (line 99) | def test_search_order_default(self):
    method test_search_order_id (line 114) | def test_search_order_id(self):
    method test_search_order_value (line 132) | def test_search_order_value(self):
    method _test_search_join (line 147) | def _test_search_join(self, target_search):
    method test_search_join (line 171) | def test_search_join(self):
    method test_search_subquery (line 175) | def test_search_subquery(self):
    method test_context_attribute (line 180) | def test_context_attribute(self):
    method test_context_read (line 194) | def test_context_read(self):
    method test_context_set (line 209) | def test_context_set(self):
  class FieldMany2OneTreeTestCase (line 221) | class FieldMany2OneTreeTestCase(unittest.TestCase):
    method create_tree (line 225) | def create_tree(self, Many2One):
    method test_search_child_of_root1 (line 242) | def test_search_child_of_root1(self):
    method test_search_not_child_of_root1 (line 258) | def test_search_not_child_of_root1(self):
    method test_search_child_of_second1 (line 272) | def test_search_child_of_second1(self):
    method test_search_not_child_of_second1 (line 284) | def test_search_not_child_of_second1(self):
    method test_search_child_of_empty (line 300) | def test_search_child_of_empty(self):
    method test_search_not_child_of_empty (line 312) | def test_search_not_child_of_empty(self):
    method test_search_child_of_none (line 328) | def test_search_child_of_none(self):
    method test_search_parent_of_root1 (line 340) | def test_search_parent_of_root1(self):
    method test_search_not_parent_of_root1 (line 352) | def test_search_not_parent_of_root1(self):
    method test_search_parent_of_second4 (line 368) | def test_search_parent_of_second4(self):
    method test_search_not_parent_of_second4 (line 382) | def test_search_not_parent_of_second4(self):
    method test_search_parent_of_empty (line 398) | def test_search_parent_of_empty(self):
    method test_search_not_parent_of_empty (line 410) | def test_search_not_parent_of_empty(self):
  class FieldMany2OneMPTTTestCase (line 426) | class FieldMany2OneMPTTTestCase(FieldMany2OneTreeTestCase):
  class FieldMany2OnePathTestCase (line 431) | class FieldMany2OnePathTestCase(FieldMany2OneTreeTestCase):

FILE: trytond/tests/test_field_multiselection.py
  class FieldMultiSelectionTestCase (line 13) | class FieldMultiSelectionTestCase(unittest.TestCase):
    method setUpClass (line 17) | def setUpClass(cls):
    method test_create (line 21) | def test_create(self):
    method test_create_not_in (line 35) | def test_create_not_in(self):
    method test_create_dynamic (line 45) | def test_create_dynamic(self):
    method test_create_dynamic_none (line 61) | def test_create_dynamic_none(self):
    method test_create_dynamic_not_in (line 73) | def test_create_dynamic_not_in(self):
    method test_create_static (line 84) | def test_create_static(self):
    method test_create_static_none (line 95) | def test_create_static_none(self):
    method test_create_static_not_in (line 106) | def test_create_static_not_in(self):
    method test_create_required_with_value (line 116) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 127) | def test_create_required_without_value(self):
    method test_create_required_none (line 135) | def test_create_required_none(self):
    method test_create_required_empty (line 145) | def test_create_required_empty(self):
    method test_write (line 155) | def test_write(self):
    method test_string (line 169) | def test_string(self):
    method test_string_none (line 179) | def test_string_none(self):
    method test_search_equals (line 189) | def test_search_equals(self):
    method test_search_equals_string (line 207) | def test_search_equals_string(self):
    method test_search_equals_none (line 221) | def test_search_equals_none(self):
    method test_search_in_string (line 235) | def test_search_in_string(self):
    method test_search_not_in_string (line 253) | def test_search_not_in_string(self):
    method test_search_in_list (line 271) | def test_search_in_list(self):
    method test_search_not_in_list (line 297) | def test_search_not_in_list(self):
  class FieldMultiSelectionJSONBTestCase (line 325) | class FieldMultiSelectionJSONBTestCase(FieldMultiSelectionTestCase):
    method setUpClass (line 328) | def setUpClass(cls):
    method setup_model (line 334) | def setup_model(cls):

FILE: trytond/tests/test_field_numeric.py
  class FieldNumericTestCase (line 14) | class FieldNumericTestCase(unittest.TestCase):
    method setUpClass (line 18) | def setUpClass(cls):
    method test_create (line 22) | def test_create(self):
    method test_create_20_digits (line 36) | def test_create_20_digits(self):
    method test_create_without_default (line 47) | def test_create_without_default(self):
    method test_create_with_default (line 56) | def test_create_with_default(self):
    method test_create_with_sql_value (line 65) | def test_create_with_sql_value(self):
    method test_set_sql_value (line 74) | def test_set_sql_value(self):
    method test_create_non_numeric (line 84) | def test_create_non_numeric(self):
    method test_create_required_with_value (line 94) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 105) | def test_create_required_without_value(self):
    method test_create_digits_valid (line 113) | def test_create_digits_valid(self):
    method test_create_digits_invalid (line 125) | def test_create_digits_invalid(self):
    method test_create_digits_none (line 136) | def test_create_digits_none(self):
    method test_create_10_digits (line 148) | def test_create_10_digits(self):
    method test_create_10_digits_invalid (line 160) | def test_create_10_digits_invalid(self):
    method test_search_equals (line 171) | def test_search_equals(self):
    method test_search_equals_none (line 189) | def test_search_equals_none(self):
    method test_search_non_equals (line 203) | def test_search_non_equals(self):
    method test_search_non_equals_none (line 221) | def test_search_non_equals_none(self):
    method test_search_in (line 235) | def test_search_in(self):
    method test_search_in_none (line 257) | def test_search_in_none(self):
    method test_search_not_in (line 271) | def test_search_not_in(self):
    method test_search_not_in_none (line 293) | def test_search_not_in_none(self):
    method test_search_in_multi (line 307) | def test_search_in_multi(self):
    method test_search_not_in_multi (line 323) | def test_search_not_in_multi(self):
    method test_search_less (line 339) | def test_search_less(self):
    method test_search_less_equals (line 361) | def test_search_less_equals(self):
    method test_search_greater (line 383) | def test_search_greater(self):
    method test_search_greater_equals (line 405) | def test_search_greater_equals(self):
    method test_numeric_search_cast (line 427) | def test_numeric_search_cast(self):
    method test_write (line 444) | def test_write(self):
    method test_write_non_numeric (line 458) | def test_write_non_numeric(self):
    method test_write_digits_invalid_value (line 471) | def test_write_digits_invalid_value(self):
    method test_write_digits_invalid_value_small (line 486) | def test_write_digits_invalid_value_small(self):
    method test_write_digits_invalid_digits (line 501) | def test_write_digits_invalid_digits(self):
    method test_write_digits_invalid_digits_0 (line 516) | def test_write_digits_invalid_digits_0(self):

FILE: trytond/tests/test_field_one2many.py
  class CommonTestCaseMixin (line 11) | class CommonTestCaseMixin:
    method test_set_reverse_field_instance (line 14) | def test_set_reverse_field_instance(self):
    method test_save_reverse_field (line 26) | def test_save_reverse_field(self):
    method test_save_reverse_field_saved (line 38) | def test_save_reverse_field_saved(self):
    method test_set_reverse_field_dict (line 51) | def test_set_reverse_field_dict(self):
    method test_set_reverse_field_id (line 62) | def test_set_reverse_field_id(self):
    method test_create (line 76) | def test_create(self):
    method test_search_equals (line 91) | def test_search_equals(self):
    method test_search_equals_no_link (line 105) | def test_search_equals_no_link(self):
    method test_search_non_equals (line 120) | def test_search_non_equals(self):
    method test_search_equals_none (line 134) | def test_search_equals_none(self):
    method test_search_non_equals_none (line 150) | def test_search_non_equals_none(self):
    method test_search_non_equals_no_link (line 166) | def test_search_non_equals_no_link(self):
    method test_search_in (line 181) | def test_search_in(self):
    method test_search_in_0 (line 196) | def test_search_in_0(self):
    method test_search_in_empty (line 210) | def test_search_in_empty(self):
    method test_search_not_in (line 224) | def test_search_not_in(self):
    method test_search_not_in_0 (line 239) | def test_search_not_in_0(self):
    method test_search_not_in_empty (line 253) | def test_search_not_in_empty(self):
    method test_search_join (line 267) | def test_search_join(self):
    method test_search_where (line 281) | def test_search_where(self):
    method test_search_not_where (line 295) | def test_search_not_where(self):
    method test_search_not_where_others (line 309) | def test_search_not_where_others(self):
    method test_write_write (line 324) | def test_write_write(self):
    method test_write_add (line 343) | def test_write_add(self):
    method test_write_remove (line 359) | def test_write_remove(self):
    method test_write_copy (line 379) | def test_write_copy(self):
    method test_write_delete (line 398) | def test_write_delete(self):
    method test_write_not_readd (line 419) | def test_write_not_readd(self):
  class FieldOne2ManyTestCase (line 436) | class FieldOne2ManyTestCase(unittest.TestCase, CommonTestCaseMixin):
    method setUpClass (line 440) | def setUpClass(cls):
    method One2Many (line 443) | def One2Many(self):
    method One2ManyTarget (line 446) | def One2ManyTarget(self):
    method test_create_required_with_value (line 450) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 465) | def test_create_required_without_value(self):
    method test_create_size_valid (line 473) | def test_create_size_valid(self):
    method test_create_size_invalid (line 486) | def test_create_size_invalid(self):
    method test_create_size_pyson_valid (line 498) | def test_create_size_pyson_valid(self):
    method test_create_size_pyson_invalid (line 512) | def test_create_size_pyson_invalid(self):
    method test_create_size_pyson_none (line 525) | def test_create_size_pyson_none(self):
    method test_create_filter (line 538) | def test_create_filter(self):
    method test_create_filter_domain (line 552) | def test_create_filter_domain(self):
    method test_search_non_equals_filter (line 566) | def test_search_non_equals_filter(self):
    method test_search_join_filter (line 581) | def test_search_join_filter(self):
    method test_context_attribute (line 596) | def test_context_attribute(self):
    method test_context_read (line 608) | def test_context_read(self):
    method test_context_read_multi (line 621) | def test_context_read_multi(self):
    method test_context_set (line 637) | def test_context_set(self):
  class FieldOne2ManyReferenceTestCase (line 649) | class FieldOne2ManyReferenceTestCase(unittest.TestCase, CommonTestCaseMi...
    method setUpClass (line 653) | def setUpClass(cls):
    method One2Many (line 656) | def One2Many(self):
    method One2ManyTarget (line 659) | def One2ManyTarget(self):

FILE: trytond/tests/test_field_one2one.py
  class FieldOne2OneTestCase (line 11) | class FieldOne2OneTestCase(unittest.TestCase):
    method setUpClass (line 15) | def setUpClass(cls):
    method test_create_id (line 19) | def test_create_id(self):
    method test_create_instance (line 33) | def test_create_instance(self):
    method test_create_with_default (line 47) | def test_create_with_default(self):
    method test_create_duplicate (line 57) | def test_create_duplicate(self):
    method test_create_required_with_value (line 73) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 87) | def test_create_required_without_value(self):
    method test_create_with_domain_valid (line 98) | def test_create_with_domain_valid(self):
    method test_create_with_domain_invalid (line 114) | def test_create_with_domain_invalid(self):
    method test_search_equals (line 129) | def test_search_equals(self):
    method test_search_non_equals (line 146) | def test_search_non_equals(self):
    method test_search_equals_none (line 163) | def test_search_equals_none(self):
    method test_search_non_equals_none (line 176) | def test_search_non_equals_none(self):
    method test_search_in (line 189) | def test_search_in(self):
    method test_search_not_in (line 206) | def test_search_not_in(self):
    method test_search_in_none (line 223) | def test_search_in_none(self):
    method test_search_not_in_none (line 240) | def test_search_not_in_none(self):
    method test_search_join (line 257) | def test_search_join(self):
    method test_write_integer (line 274) | def test_write_integer(self):
    method test_write_none (line 289) | def test_write_none(self):
    method test_write_duplicate (line 306) | def test_write_duplicate(self):

FILE: trytond/tests/test_field_reference.py
  class FieldReferenceTestCase (line 11) | class FieldReferenceTestCase(unittest.TestCase):
    method setUpClass (line 15) | def setUpClass(cls):
    method test_create (line 19) | def test_create(self):
    method test_create_without_default (line 33) | def test_create_without_default(self):
    method test_create_required_with_value (line 43) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 57) | def test_create_required_without_value(self):
    method test_create_required_with_none (line 66) | def test_create_required_with_none(self):
    method test_create_required_with_negative (line 78) | def test_create_required_with_negative(self):
    method test_create_partial (line 90) | def test_create_partial(self):
    method test_create_negative (line 104) | def test_create_negative(self):
    method test_search_equals_string (line 118) | def test_search_equals_string(self):
    method test_search_equals_tuple (line 135) | def test_search_equals_tuple(self):
    method test_search_equals_list (line 152) | def test_search_equals_list(self):
    method test_search_equals_none (line 169) | def test_search_equals_none(self):
    method test_search_non_equals_string (line 186) | def test_search_non_equals_string(self):
    method test_search_non_equals_tuple (line 203) | def test_search_non_equals_tuple(self):
    method test_search_non_equals_none (line 220) | def test_search_non_equals_none(self):
    method test_search_in_string (line 237) | def test_search_in_string(self):
    method test_search_in_tuple (line 254) | def test_search_in_tuple(self):
    method test_search_in_none (line 271) | def test_search_in_none(self):
    method test_search_not_in_string (line 288) | def test_search_not_in_string(self):
    method test_search_not_in_tuple (line 305) | def test_search_not_in_tuple(self):
    method test_search_not_in_none (line 322) | def test_search_not_in_none(self):
    method test_search_join (line 339) | def test_search_join(self):
    method test_write_string (line 356) | def test_write_string(self):
    method test_write_tuple (line 371) | def test_write_tuple(self):
    method test_write_none (line 386) | def test_write_none(self):
    method test_context_attribute (line 403) | def test_context_attribute(self):
    method test_context_read (line 417) | def test_context_read(self):
    method test_context_read_multi (line 432) | def test_context_read_multi(self):
    method test_context_set (line 450) | def test_context_set(self):
    method test_domain_valid (line 462) | def test_domain_valid(self):
    method test_domain_invalid (line 476) | def test_domain_invalid(self):
    method test_no_domain (line 489) | def test_no_domain(self):
    method test_domain_none_value (line 503) | def test_domain_none_value(self):
    method test_domain_different_targets (line 514) | def test_domain_different_targets(self):
    method test_domain_pyson (line 533) | def test_domain_pyson(self):
    method test_domain_pyson_different_targets (line 548) | def test_domain_pyson_different_targets(self):

FILE: trytond/tests/test_field_selection.py
  class FieldSelectionTestCase (line 11) | class FieldSelectionTestCase(unittest.TestCase):
    method setUpClass (line 15) | def setUpClass(cls):
    method test_create (line 19) | def test_create(self):
    method test_create_not_in (line 33) | def test_create_not_in(self):
    method test_create_dynamic (line 43) | def test_create_dynamic(self):
    method test_create_dynamic_none (line 59) | def test_create_dynamic_none(self):
    method test_create_dynamic_static (line 71) | def test_create_dynamic_static(self):
    method test_create_dynamic_not_in (line 82) | def test_create_dynamic_not_in(self):
    method test_create_required_with_value (line 93) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 104) | def test_create_required_without_value(self):
    method test_create_required_none (line 112) | def test_create_required_none(self):
    method test_search_order_label (line 122) | def test_search_order_label(self):
    method test_search_order_fixed_selection (line 134) | def test_search_order_fixed_selection(self):
    method test_search_order_static_selection (line 146) | def test_search_order_static_selection(self):
    method test_search_order_dynamic_selection (line 159) | def test_search_order_dynamic_selection(self):
    method test_search_order_unsorted (line 176) | def test_search_order_unsorted(self):
    method test_string (line 195) | def test_string(self):
    method test_string_dynamic (line 208) | def test_string_dynamic(self):
    method test_string_dynamic_none (line 224) | def test_string_dynamic_none(self):
    method test_string_dynamic_selection_static (line 236) | def test_string_dynamic_selection_static(self):

FILE: trytond/tests/test_field_text.py
  class CommonTestCaseMixin (line 14) | class CommonTestCaseMixin:
    method test_create (line 17) | def test_create(self):
    method test_create_unicode (line 31) | def test_create_unicode(self):
    method test_create_multiline (line 42) | def test_create_multiline(self):
    method test_search_equals (line 53) | def test_search_equals(self):
    method test_search_equals_none (line 71) | def test_search_equals_none(self):
    method test_search_equals_unicode (line 85) | def test_search_equals_unicode(self):
    method test_search_equals_non_unicode (line 99) | def test_search_equals_non_unicode(self):
    method test_search_non_equals (line 113) | def test_search_non_equals(self):
    method test_search_non_equals_none (line 131) | def test_search_non_equals_none(self):
    method test_search_in (line 145) | def test_search_in(self):
    method test_search_in_none (line 167) | def test_search_in_none(self):
    method test_search_not_in (line 181) | def test_search_not_in(self):
    method test_search_not_in_none (line 203) | def test_search_not_in_none(self):
    method test_search_like (line 217) | def test_search_like(self):
    method test_search_ilike (line 243) | def test_search_ilike(self):
    method test_search_full_text (line 279) | def test_search_full_text(self):
    method test_search_full_text_order (line 301) | def test_search_full_text_order(self):
    method test_search_not_like (line 323) | def test_search_not_like(self):
    method test_search_not_ilike (line 349) | def test_search_not_ilike(self):
    method test_write_unicode (line 378) | def test_write_unicode(self):
  class FieldTextTestCase (line 392) | class FieldTextTestCase(unittest.TestCase, CommonTestCaseMixin):
    method setUpClass (line 396) | def setUpClass(cls):
    method Text (line 399) | def Text(self):
    method test_create_without_default (line 403) | def test_create_without_default(self):
    method test_create_with_default (line 412) | def test_create_with_default(self):
    method test_create_required_with_value (line 421) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 432) | def test_create_required_without_value(self):
    method test_create_required_with_empty (line 440) | def test_create_required_with_empty(self):
    method test_create_size_valid (line 450) | def test_create_size_valid(self):
    method test_create_size_invalid (line 461) | def test_create_size_invalid(self):
    method test_write (line 471) | def test_write(self):
    method test_write_none (line 485) | def test_write_none(self):
    method test_write_size_invalid (line 499) | def test_write_size_invalid(self):
  class FieldTextTranslatedTestCase (line 513) | class FieldTextTranslatedTestCase(unittest.TestCase, CommonTestCaseMixin):
    method Text (line 516) | def Text(self):
  class FieldFullTextTestCase (line 520) | class FieldFullTextTestCase(unittest.TestCase):
    method setUpClass (line 524) | def setUpClass(cls):
    method test_create (line 528) | def test_create(self):
    method test_create_list (line 540) | def test_create_list(self):
    method test_search (line 555) | def test_search(self):
    method test_search_full_text (line 581) | def test_search_full_text(self):
    method test_search_full_text_filter (line 604) | def test_search_full_text_filter(self):
    method test_search_full_text_order (line 630) | def test_search_full_text_order(self):

FILE: trytond/tests/test_field_time.py
  class FieldTimeTestCase (line 19) | class FieldTimeTestCase(unittest.TestCase):
    method setUpClass (line 23) | def setUpClass(cls):
    method test_create (line 27) | def test_create(self):
    method test_create_timestring (line 41) | def test_create_timestring(self):
    method test_create_invalid_timestring (line 52) | def test_create_invalid_timestring(self):
    method test_create_without_default (line 62) | def test_create_without_default(self):
    method test_create_with_default (line 71) | def test_create_with_default(self):
    method test_create_with_sql_value (line 80) | def test_create_with_sql_value(self):
    method test_set_sql_value (line 89) | def test_set_sql_value(self):
    method test_create_non_time (line 99) | def test_create_non_time(self):
    method test_create_integer (line 109) | def test_create_integer(self):
    method test_create_date (line 119) | def test_create_date(self):
    method test_create_microsecond (line 129) | def test_create_microsecond(self):
    method test_create_required_with_value (line 140) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 151) | def test_create_required_without_value(self):
    method test_create_format_valid (line 159) | def test_create_format_valid(self):
    method test_create_format_invalid (line 171) | def test_create_format_invalid(self):
    method test_search_equals (line 181) | def test_search_equals(self):
    method test_search_equals_none (line 199) | def test_search_equals_none(self):
    method test_search_non_equals (line 213) | def test_search_non_equals(self):
    method test_search_non_equals_none (line 231) | def test_search_non_equals_none(self):
    method test_search_in (line 245) | def test_search_in(self):
    method test_search_in_none (line 267) | def test_search_in_none(self):
    method test_search_not_in (line 281) | def test_search_not_in(self):
    method test_search_not_in_none (line 303) | def test_search_not_in_none(self):
    method test_search_in_multi (line 317) | def test_search_in_multi(self):
    method test_search_not_in_multi (line 333) | def test_search_not_in_multi(self):
    method test_search_less (line 349) | def test_search_less(self):
    method test_search_less_equals (line 371) | def test_search_less_equals(self):
    method test_search_greater (line 393) | def test_search_greater(self):
    method test_search_greater_equals (line 415) | def test_search_greater_equals(self):
    method test_write (line 437) | def test_write(self):
    method test_write_non_time (line 451) | def test_write_non_time(self):
    method test_write_integer (line 464) | def test_write_integer(self):
    method test_write_date (line 477) | def test_write_date(self):

FILE: trytond/tests/test_field_timedelta.py
  class FieldTimeDeltaTestCase (line 16) | class FieldTimeDeltaTestCase(unittest.TestCase):
    method setUpClass (line 20) | def setUpClass(cls):
    method test_create (line 24) | def test_create(self):
    method test_create_without_default (line 38) | def test_create_without_default(self):
    method test_create_with_default (line 47) | def test_create_with_default(self):
    method test_create_string (line 56) | def test_create_string(self):
    method test_create_string_simplet (line 69) | def test_create_string_simplet(self):
    method test_create_invalid_string (line 82) | def test_create_invalid_string(self):
    method test_create_integer (line 92) | def test_create_integer(self):
    method test_create_float (line 103) | def test_create_float(self):
    method test_create_required_with_value (line 114) | def test_create_required_with_value(self):
    method test_create_required_without_value (line 125) | def test_create_required_without_value(self):
    method test_search_equals (line 133) | def test_search_equals(self):
    method test_search_equals_none (line 151) | def test_search_equals_none(self):
    method test_search_non_equals (line 165) | def test_search_non_equals(self):
    method test_search_non_equals_none (line 183) | def test_search_non_equals_none(self):
    method test_search_in (line 197) | def test_search_in(self):
    method test_search_in_none (line 219) | def test_search_in_none(self):
    method test_search_not_in (line 233) | def test_search_not_in(self):
    method test_search_not_in_none (line 255) | def test_search_not_in_none(self):
    method test_search_in_multi (line 269) | def test_search_in_multi(self):
    method test_search_not_in_multi (line 285) | def test_search_not_in_multi(self):
    method test_search_less (line 301) | def test_search_less(self):
    method test_search_less_equals (line 323) | def test_search_less_equals(self):
    method test_search_greater (line 345) | def test_search_greater(self):
    method test_search_greater_equals (line 367) | def test_search_greater_equals(self):
    method test_write (line 389) | def test_write(self):
    method test_write_string (line 403) | def test_write_string(self):
    method test_write_string_simple (line 419) | def test_write_string_simple(self):
    method test_write_invalid_string (line 435) | def test_write_invalid_string(self):
    method test_write_interger (line 448) | def test_write_interger(self):
    method test_write_float (line 464) | def test_write_float(self):

FILE: trytond/tests/test_filestore.py
  class FileStoreTestCase (line 13) | class FileStoreTestCase(unittest.TestCase):
    method setUp (line 16) | def setUp(self):
    method data (line 23) | def data(self):
    method test_set (line 26) | def test_set(self):
    method test_setmany (line 32) | def test_setmany(self):
    method test_get (line 39) | def test_get(self):
    method test_getmany (line 45) | def test_getmany(self):
    method test_size (line 51) | def test_size(self):
    method test_sizemany (line 57) | def test_sizemany(self):
    method test_prefix (line 64) | def test_prefix(self):
    method test_bad_prefix (line 71) | def test_bad_prefix(self):
    method test_duplicate (line 76) | def test_duplicate(self):
    method test_collision (line 82) | def test_collision(self):

FILE: trytond/tests/test_history.py
  class HistoryTestCase (line 13) | class HistoryTestCase(unittest.TestCase):
    method setUpClass (line 17) | def setUpClass(cls):
    method tearDown (line 21) | def tearDown(self):
    method test_read (line 35) | def test_read(self):
    method test_read_same_timestamp (line 82) | def test_read_same_timestamp(self):
    method test_history_revisions (line 117) | def test_history_revisions(self):
    method test_restore_history (line 152) | def test_restore_history(self):
    method test_restore_history_before (line 192) | def test_restore_history_before(self):
    method test_restore_history_same_timestamp (line 224) | def test_restore_history_same_timestamp(self):
    method test_ordered_search (line 253) | def test_ordered_search(self):
    method test_ordered_search_same_timestamp (line 320) | def test_ordered_search_same_timestamp(self):
    method test_ordered_search_nested (line 352) | def test_ordered_search_nested(self):
    method test_browse (line 386) | def test_browse(self):
    method test_search_cursor_max (line 445) | def test_search_cursor_max(self):
    method test_search_cursor_max_entries (line 464) | def test_search_cursor_max_entries(self):
    method test_search_cursor_max_histories (line 485) | def test_search_cursor_max_histories(self):

FILE: trytond/tests/test_i18n.py
  class I18nTestCase (line 11) | class I18nTestCase(unittest.TestCase):
    method setUpClass (line 15) | def setUpClass(cls):
    method test_gettext_with_translation (line 19) | def test_gettext_with_translation(self):
    method test_gettext_with_translation_format (line 43) | def test_gettext_with_translation_format(self):
    method test_gettext_no_translation (line 71) | def test_gettext_no_translation(self):
    method test_gettest_wrong_id_format (line 83) | def test_gettest_wrong_id_format(self):
    method test_gettext_wrong_id (line 90) | def test_gettext_wrong_id(self):
    method test_gettext_without_transaction (line 96) | def test_gettext_without_transaction(self):
    method test_lazy_gettext (line 103) | def test_lazy_gettext(self):

FILE: trytond/tests/test_importdata.py
  class ImportDataTestCase (line 13) | class ImportDataTestCase(unittest.TestCase):
    method setUpClass (line 17) | def setUpClass(cls):
    method test_boolean (line 21) | def test_boolean(self):
    method test_boolean_many_rows (line 32) | def test_boolean_many_rows(self):
    method test_boolean_invalid (line 41) | def test_boolean_invalid(self):
    method test_integer (line 50) | def test_integer(self):
    method test_integer_many_rows (line 61) | def test_integer_many_rows(self):
    method test_integer_invalid (line 70) | def test_integer_invalid(self):
    method test_float (line 81) | def test_float(self):
    method test_float_invalid (line 93) | def test_float_invalid(self):
    method test_numeric (line 102) | def test_numeric(self):
    method test_numeric_invalid (line 115) | def test_numeric_invalid(self):
    method test_char (line 123) | def test_char(self):
    method test_char_many_rows (line 134) | def test_char_many_rows(self):
    method test_text (line 143) | def test_text(self):
    method test_text_many_rows (line 154) | def test_text_many_rows(self):
    method test_date (line 163) | def test_date(self):
    method test_date_many_rows (line 174) | def test_date_many_rows(self):
    method test_date_invalid (line 183) | def test_date_invalid(self):
    method test_datetime (line 192) | def test_datetime(self):
    method test_datetime_many_rows (line 204) | def test_datetime_many_rows(self):
    method test_datetime_invalid (line 215) | def test_datetime_invalid(self):
    method test_timedelta (line 224) | def test_timedelta(self):
    method test_timedelta_invalid (line 239) | def test_timedelta_invalid(self):
    method test_selection (line 248) | def test_selection(self):
    method test_selection_many_rows (line 259) | def test_selection_many_rows(self):
    method test_many2one (line 269) | def test_many2one(self):
    method test_many2one_id (line 280) | def test_many2one_id(self):
    method test_many2one_many_rows (line 291) | def test_many2one_many_rows(self):
    method test_many2one_invalid (line 300) | def test_many2one_invalid(self):
    method test_many2one_id_invalid (line 311) | def test_many2one_id_invalid(self):
    method test_many2many (line 322) | def test_many2many(self):
    method test_many2many_id (line 335) | def test_many2many_id(self):
    method test_many2many_many_rows (line 349) | def test_many2many_many_rows(self):
    method test_many2many_invalid (line 358) | def test_many2many_invalid(self):
    method test_one2many (line 369) | def test_one2many(self):
    method test_one2many_many_targets (line 378) | def test_one2many_many_targets(self):
    method test_one2many_many_rows (line 388) | def test_one2many_many_rows(self):
    method test_many_one2many (line 401) | def test_many_one2many(self):
    method test_many_one2many_empty_last (line 417) | def test_many_one2many_empty_last(self):
    method test_many_one2many_multiple_empty (line 433) | def test_many_one2many_multiple_empty(self):
    method test_reference (line 450) | def test_reference(self):
    method test_reference_id (line 462) | def test_reference_id(self):
    method test_reference_empty (line 475) | def test_reference_empty(self):
    method test_reference_many_rows (line 486) | def test_reference_many_rows(self):
    method test_reference_invalid (line 499) | def test_reference_invalid(self):
    method test_reference_id_invalid (line 513) | def test_reference_id_invalid(self):
    method test_binary_bytes (line 524) | def test_binary_bytes(self):
    method test_binary_base64 (line 534) | def test_binary_base64(self):
    method test_update_id (line 544) | def test_update_id(self):
    method test_update_rec_name (line 558) | def test_update_rec_name(self):
    method test_update_one2many (line 572) | def test_update_one2many(self):

FILE: trytond/tests/test_ir.py
  class IrTestCase (line 25) | class IrTestCase(ModuleTestCase):
    method test_model_search_name (line 30) | def test_model_search_name(self):
    method test_model_search_order (line 42) | def test_model_search_order(self):
    method test_model_field_search_description (line 55) | def test_model_field_search_description(self):
    method test_model_field_search_order_description (line 68) | def test_model_field_search_order_description(self):
    method test_model_field_lazy (line 82) | def test_model_field_lazy(self):
    method test_sequence_substitutions (line 95) | def test_sequence_substitutions(self):
    method test_global_search (line 121) | def test_global_search(self):
    method test_lang_currency (line 128) | def test_lang_currency(self):
    method test_lang_format (line 146) | def test_lang_format(self):
    method test_lang_strftime (line 159) | def test_lang_strftime(self):
    method test_lang_format_number (line 181) | def test_lang_format_number(self):
    method test_lang_format_number_symbol (line 196) | def test_lang_format_number_symbol(self):
    method test_model_data_get_id (line 215) | def test_model_data_get_id(self):
    method test_model_data_get_id_dot (line 227) | def test_model_data_get_id_dot(self):
    method test_email_send (line 239) | def test_email_send(self):
    method test_email_template_get (line 295) | def test_email_template_get(self):
    method test_email_template_get_default (line 330) | def test_email_template_get_default(self):
    method test_email_template_get_pyson (line 356) | def test_email_template_get_pyson(self):
  class IrCronTestCase (line 394) | class IrCronTestCase(unittest.TestCase):
    method setUpClass (line 398) | def setUpClass(cls):
    method tearDownClass (line 404) | def tearDownClass(cls):
    method setUp (line 408) | def setUp(self):
    method _get_cron (line 413) | def _get_cron(self):
    method test_scheduling_non_utc (line 425) | def test_scheduling_non_utc(self):
    method test_scheduling_on_dst_change (line 439) | def test_scheduling_on_dst_change(self):
    method test_scheduling_on_standard_time (line 453) | def test_scheduling_on_standard_time(self):

FILE: trytond/tests/test_mixins.py
  class UrlTestCase (line 17) | class UrlTestCase(unittest.TestCase):
    method setUpClass (line 21) | def setUpClass(cls):
    method testModelURL (line 25) | def testModelURL(self):
    method testModelHref (line 40) | def testModelHref(self):
    method testWizardURL (line 55) | def testWizardURL(self):
    method testWizardHref (line 66) | def testWizardHref(self):
  class MixinTestCase (line 77) | class MixinTestCase(unittest.TestCase):
    method setUpClass (line 81) | def setUpClass(cls):
    method test_mixin_on_modelview (line 85) | def test_mixin_on_modelview(self):
    method test_second_mixin_on_modelview (line 93) | def test_second_mixin_on_modelview(self):
    method test_no_mixin (line 101) | def test_no_mixin(self):
    method test_report_mixin (line 107) | def test_report_mixin(self):
  class DeactivableMixinTestCase (line 115) | class DeactivableMixinTestCase(unittest.TestCase):
    method setUpClass (line 119) | def setUpClass(cls):
    method test_deactivable_default_active (line 123) | def test_deactivable_default_active(self):
    method test_search_deactivable (line 133) | def test_search_deactivable(self):

FILE: trytond/tests/test_model.py
  class ModelTestCase (line 12) | class ModelTestCase(unittest.TestCase):
    method setUpClass (line 16) | def setUpClass(cls):
    method test_repr (line 20) | def test_repr(self):
    method test_hash_with_id (line 34) | def test_hash_with_id(self):
    method test_hash_without_id (line 47) | def test_hash_without_id(self):
    method test_init_parent (line 58) | def test_init_parent(self):
    method test_init_parent_parent (line 71) | def test_init_parent_parent(self):
    method test_init_context (line 86) | def test_init_context(self):
    method test_init_parent_context (line 103) | def test_init_parent_context(self):
    method test_init_context_parent (line 118) | def test_init_context_parent(self):
    method test_init_parent_context_parent (line 135) | def test_init_parent_context_parent(self):
    method test_names_model (line 151) | def test_names_model(self):
    method test_names_field (line 161) | def test_names_field(self):
    method test_names_record (line 171) | def test_names_record(self):
    method test_names_unsaved_record (line 183) | def test_names_unsaved_record(self):
    method test_names_value (line 194) | def test_names_value(self):
    method test_names_unset_value (line 208) | def test_names_unset_value(self):
    method test_fields_get_no_write_access (line 222) | def test_fields_get_no_write_access(self):
    method test_copy (line 243) | def test_copy(self):
    method test_copy_values (line 256) | def test_copy_values(self):
  class ModelTranslationTestCase (line 270) | class ModelTranslationTestCase(unittest.TestCase):
    method setUpClass (line 276) | def setUpClass(cls):
    method setup_language (line 282) | def setup_language(cls):
    method test_fields_get (line 302) | def test_fields_get(self):
  class RecordTestCase (line 325) | class RecordTestCase(unittest.TestCase):
    method test_creation (line 328) | def test_creation(self):
    method test_init (line 335) | def test_init(self):
    method test_getitem (line 342) | def test_getitem(self):
    method test_setitem (line 349) | def test_setitem(self):
    method test_contains (line 357) | def test_contains(self):
    method test_clear (line 366) | def test_clear(self):
    method test_copy (line 379) | def test_copy(self):
    method test_get (line 390) | def test_get(self):
    method test_keys (line 402) | def test_keys(self):
    method test_items (line 410) | def test_items(self):
    method test_pop (line 418) | def test_pop(self):
    method test_popitem (line 432) | def test_popitem(self):
    method test_setdefault (line 441) | def test_setdefault(self):
    method test_update (line 452) | def test_update(self):
    method test_values (line 462) | def test_values(self):

FILE: trytond/tests/test_model_index.py
  class ModelIndexTestCase (line 11) | class ModelIndexTestCase(unittest.TestCase):
    method test_index_equality (line 14) | def test_index_equality(self):
    method test_index_inequality_table (line 31) | def test_index_inequality_table(self):
    method test_index_inequality_expression (line 44) | def test_index_inequality_expression(self):
    method test_index_inequality_usage (line 59) | def test_index_inequality_usage(self):
    method test_index_inequality_usage_option (line 74) | def test_index_inequality_usage_option(self):
    method test_index_inequality_option_expression (line 91) | def test_index_inequality_option_expression(self):
    method test_index_inequality_option_param (line 108) | def test_index_inequality_option_param(self):
    method test_index_hash (line 125) | def test_index_hash(self):

FILE: trytond/tests/test_modelsingleton.py
  class ModelSingletonTestCase (line 12) | class ModelSingletonTestCase(unittest.TestCase):
    method setUpClass (line 16) | def setUpClass(cls):
    method test_read (line 20) | def test_read(self):
    method test_create (line 47) | def test_create(self):
    method test_copy (line 65) | def test_copy(self):
    method test_default_get (line 85) | def test_default_get(self):
    method test_search (line 113) | def test_search(self):
    method test_all_cache_cleared (line 134) | def test_all_cache_cleared(self):

FILE: trytond/tests/test_modelsql.py
  class ModelSQLTestCase (line 20) | class ModelSQLTestCase(unittest.TestCase):
    method setUpClass (line 24) | def setUpClass(cls):
    method test_read (line 28) | def test_read(self):
    method test_read_context_id (line 41) | def test_read_context_id(self):
    method test_read_function_field_bigger_than_cache (line 52) | def test_read_function_field_bigger_than_cache(self):
    method test_read_related_2one (line 68) | def test_read_related_2one(self):
    method test_read_related_2one_empty (line 87) | def test_read_related_2one_empty(self):
    method test_read_related_reference (line 101) | def test_read_related_reference(self):
    method test_read_related_invalid_reference (line 120) | def test_read_related_invalid_reference(self):
    method test_read_related_deleted_reference (line 135) | def test_read_related_deleted_reference(self):
    method test_read_related_reference_empty (line 152) | def test_read_related_reference_empty(self):
    method test_read_related_2many (line 166) | def test_read_related_2many(self):
    method test_read_related_2many_empty (line 186) | def test_read_related_2many_empty(self):
    method test_read_related_2many_multiple (line 201) | def test_read_related_2many_multiple(self):
    method test_read_related_mixed (line 226) | def test_read_related_mixed(self):
    method test_read_related_nested (line 279) | def test_read_related_nested(self):
    method test_required_field_missing (line 306) | def test_required_field_missing(self):
    method test_check_timestamp (line 329) | def test_check_timestamp(self):
    method test_create_field_set (line 369) | def test_create_field_set(self):
    method test_integrity_error_with_created_record (line 400) | def test_integrity_error_with_created_record(self):
    method test_foreign_key_cascade (line 418) | def test_foreign_key_cascade(self):
    method test_foreign_key_null (line 434) | def test_foreign_key_null(self):
    method test_foreign_key_null_required (line 450) | def test_foreign_key_null_required(self):
    method test_foreign_key_restrict (line 471) | def test_foreign_key_restrict(self):
    method test_foreign_key_restrict_inactive (line 489) | def test_foreign_key_restrict_inactive(self):
    method test_null_ordering (line 507) | def test_null_ordering(self):
    method test_delete_translations (line 533) | def test_delete_translations(self):
    method test_constraint_check (line 547) | def test_constraint_check(self):
    method test_constraint_check_null (line 557) | def test_constraint_check_null(self):
    method test_constraint_check_invalid (line 567) | def test_constraint_check_invalid(self):
    method test_constraint_unique (line 576) | def test_constraint_unique(self):
    method test_constraint_unique_null (line 586) | def test_constraint_unique_null(self):
    method test_constraint_unique_invalid (line 596) | def test_constraint_unique_invalid(self):
    method test_constraint_exclude (line 605) | def test_constraint_exclude(self):
    method test_constraint_exclude_exclusion (line 615) | def test_constraint_exclude_exclusion(self):
    method test_constraint_exclude_exclusion_mixed (line 625) | def test_constraint_exclude_exclusion_mixed(self):
    method test_constraint_exclude_invalid (line 638) | def test_constraint_exclude_invalid(self):
    method test_record_lock (line 649) | def test_record_lock(self):
    method test_table_lock (line 668) | def test_table_lock(self):
    method test_search_or_to_union (line 681) | def test_search_or_to_union(self):
    method test_search_or_to_union_order_eager_field (line 716) | def test_search_or_to_union_order_eager_field(self):
    method test_search_or_to_union_order_lazy_field (line 757) | def test_search_or_to_union_order_lazy_field(self):
    method test_search_or_to_union_order_dotted_notation (line 798) | def test_search_or_to_union_order_dotted_notation(self):
    method test_search_or_to_union_order_function (line 839) | def test_search_or_to_union_order_function(self):
    method test_search_or_to_union_no_local_clauses (line 883) | def test_search_or_to_union_no_local_clauses(self):
    method test_search_or_to_union_class_order (line 918) | def test_search_or_to_union_class_order(self):
    method test_search_limit (line 952) | def test_search_limit(self):
    method test_search_offset (line 964) | def test_search_offset(self):
    method test_split_subquery_domain_empty (line 975) | def test_split_subquery_domain_empty(self):
    method test_split_subquery_domain_simple (line 983) | def test_split_subquery_domain_simple(self):
    method test_split_subquery_domain_dotter (line 991) | def test_split_subquery_domain_dotter(self):
    method test_split_subquery_domain_mixed (line 999) | def test_split_subquery_domain_mixed(self):
    method test_split_subquery_domain_operator (line 1008) | def test_split_subquery_domain_operator(self):
    method test_split_subquery_domain_nested (line 1017) | def test_split_subquery_domain_nested(self):
  class TranslationTestCase (line 1035) | class TranslationTestCase(unittest.TestCase):
    method setUpClass (line 1040) | def setUpClass(cls):
    method setup_language (line 1046) | def setup_language(cls):
    method tearDownClass (line 1066) | def tearDownClass(cls):
    method restore_language (line 1072) | def restore_language(cls):
  class ModelSQLTranslationTestCase (line 1092) | class ModelSQLTranslationTestCase(TranslationTestCase):
    method setUpClass (line 1096) | def setUpClass(cls):
    method test_create_default_language (line 1101) | def test_create_default_language(self):
    method test_create_other_language (line 1121) | def test_create_other_language(self):
    method test_write_default_language (line 1141) | def test_write_default_language(self):
    method test_write_other_language (line 1162) | def test_write_other_language(self):
    method test_write_default_language_with_other_language (line 1192) | def test_write_default_language_with_other_language(self):
    method test_delete (line 1224) | def test_delete(self):
    method test_read (line 1249) | def test_read(self):
    method test_read_last_translation (line 1264) | def test_read_last_translation(self):
    method test_order_empty_translation (line 1290) | def test_order_empty_translation(self):
    method test_search_unique_result (line 1315) | def test_search_unique_result(self):
    method test_search_fill_transaction_cache (line 1343) | def test_search_fill_transaction_cache(self):

FILE: trytond/tests/test_modelstorage.py
  class ModelStorageTestCase (line 14) | class ModelStorageTestCase(unittest.TestCase):
    method setUpClass (line 18) | def setUpClass(cls):
    method test_search_read_order (line 22) | def test_search_read_order(self):
    method test_copy_order (line 44) | def test_copy_order(self):
    method test_search_count (line 64) | def test_search_count(self):
    method test_browse_deleted (line 77) | def test_browse_deleted(self):
    method test_browse_context (line 92) | def test_browse_context(self):
    method test_save_mixed_context (line 112) | def test_save_mixed_context(self):
    method test_fail_saving_mixed_context1 (line 125) | def test_fail_saving_mixed_context1(self):
    method test_fail_saving_mixed_context2 (line 139) | def test_fail_saving_mixed_context2(self):
    method test_save_one2many_create (line 155) | def test_save_one2many_create(self):
    method test_save_one2many_add (line 169) | def test_save_one2many_add(self):
    method test_save_one2many_delete (line 186) | def test_save_one2many_delete(self):
    method test_save_one2many_remove (line 200) | def test_save_one2many_remove(self):
    method test_save_many2many_add (line 214) | def test_save_many2many_add(self):
    method test_save_many2many_delete (line 231) | def test_save_many2many_delete(self):
    method test_save_many2many_remove (line 245) | def test_save_many2many_remove(self):
    method test_model_translations (line 262) | def test_model_translations(self):
    method test_pyson_domain_same (line 290) | def test_pyson_domain_same(self):
    method test_pyson_domain_unique (line 303) | def test_pyson_domain_unique(self):
    method test_pyson_domain_unique_in_max (line 319) | def test_pyson_domain_unique_in_max(self):
    method test_pyson_domain_single (line 342) | def test_pyson_domain_single(self):
    method test_relation_domain (line 355) | def test_relation_domain(self):
    method test_relation_domain_invalid (line 366) | def test_relation_domain_invalid(self):
    method test_relation_domain_multi (line 380) | def test_relation_domain_multi(self):
    method test_relation_domain_multi_invalid (line 391) | def test_relation_domain_multi_invalid(self):
    method test_relation_pyson_domain (line 415) | def test_relation_pyson_domain(self):
    method test_relation_pyson_domain_invalid (line 427) | def test_relation_pyson_domain_invalid(self):
    method test_relation_domain_context (line 442) | def test_relation_domain_context(self):
    method test_relation_domain_context_invalid (line 454) | def test_relation_domain_context_invalid(self):
    method test_relation_pyson_domain_context (line 467) | def test_relation_pyson_domain_context(self):
    method test_relation_pyson_domain_context_invalid (line 479) | def test_relation_pyson_domain_context_invalid(self):
    method test_relation2_domain_invalid (line 493) | def test_relation2_domain_invalid(self):
    method test_check_xml_record_without_record (line 512) | def test_check_xml_record_without_record(self):
    method test_check_xml_record_with_record_no_matching_values (line 523) | def test_check_xml_record_with_record_no_matching_values(self):
    method test_check_xml_record_with_record_matching_values (line 543) | def test_check_xml_record_with_record_matching_values(self):
    method test_check_xml_record_with_record_matching_values_noupdate (line 563) | def test_check_xml_record_with_record_matching_values_noupdate(self):
    method test_check_xml_record_with_record_matching_values_root (line 583) | def test_check_xml_record_with_record_matching_values_root(self):
    method test_check_xml_record_with_record_no_values (line 603) | def test_check_xml_record_with_record_no_values(self):
    method test_check_xml_record_with_record_no_values_noupdate (line 623) | def test_check_xml_record_with_record_no_values_noupdate(self):
    method test_delete_clear_db_id_model_data_noupdate (line 643) | def test_delete_clear_db_id_model_data_noupdate(self):
    method test_delete_model_data_without_noupdate (line 663) | def test_delete_model_data_without_noupdate(self):
  class EvalEnvironmentTestCase (line 681) | class EvalEnvironmentTestCase(unittest.TestCase):
    method setUpClass (line 685) | def setUpClass(cls):
    method test_char_field (line 689) | def test_char_field(self):
    method test_reference_field (line 700) | def test_reference_field(self):
    method test_many2one_field (line 712) | def test_many2one_field(self):
    method test_one2many_field (line 723) | def test_one2many_field(self):
    method test_multiselection_field (line 734) | def test_multiselection_field(self):
    method test_parent_field (line 745) | def test_parent_field(self):
    method test_model_save_skip_check_access (line 756) | def test_model_save_skip_check_access(self):
    method test_model_getattr_skip_check_access (line 776) | def test_model_getattr_skip_check_access(self):

FILE: trytond/tests/test_modelview.py
  class ModelView (line 15) | class ModelView(unittest.TestCase):
    method setUpClass (line 19) | def setUpClass(cls):
    method test_changed_values (line 23) | def test_changed_values(self):
    method test_changed_values_stored (line 112) | def test_changed_values_stored(self):
    method test_changed_values_removed (line 136) | def test_changed_values_removed(self):
    method test_changed_values_deleted (line 153) | def test_changed_values_deleted(self):
    method test_changed_values_rec_name (line 170) | def test_changed_values_rec_name(self):
    method test_changed_values_reverse_field (line 188) | def test_changed_values_reverse_field(self):
    method test_button_access (line 208) | def test_button_access(self):
    method test_button_no_rule (line 255) | def test_button_no_rule(self):
    method test_button_rule_not_passed (line 272) | def test_button_rule_not_passed(self):
    method test_button_rule_passed (line 300) | def test_button_rule_passed(self):
    method test_button_rule_test_condition (line 328) | def test_button_rule_test_condition(self):
    method test_button_rule_test_group (line 351) | def test_button_rule_test_group(self):
    method test_button_rule_test_number_user (line 376) | def test_button_rule_test_number_user(self):
    method test_button_action (line 408) | def test_button_action(self):
    method test_button_action_return (line 418) | def test_button_action_return(self):
    method test_button_change (line 428) | def test_button_change(self):
    method test_link (line 443) | def test_link(self):
    method test_link_without_read_access (line 457) | def test_link_without_read_access(self):
    method test_link_label_valid_view (line 479) | def test_link_label_valid_view(self):
    method test_link_without_action_access (line 499) | def test_link_without_action_access(self):
    method test_rpc_setup (line 525) | def test_rpc_setup(self):
    method test_remove_empty_page (line 553) | def test_remove_empty_page(self):
    method test_active_field (line 566) | def test_active_field(self):
    method test_circular_depends_removed (line 579) | def test_circular_depends_removed(self):
    method test_depends_depends (line 601) | def test_depends_depends(self):
    method test_button_depends_access (line 611) | def test_button_depends_access(self):
    method test_button_depends_no_access (line 624) | def test_button_depends_no_access(self):
    method test_view_attributes (line 649) | def test_view_attributes(self):
    method test_view_attributes_depends (line 662) | def test_view_attributes_depends(self):
    method test_states_depends_display (line 672) | def test_states_depends_display(self):
    method test_states_depends_edition (line 683) | def test_states_depends_edition(self):

FILE: trytond/tests/test_mptt.py
  class MPTTTestCase (line 15) | class MPTTTestCase(TreeTestCaseMixin, unittest.TestCase):
    method setUpClass (line 20) | def setUpClass(cls):
    method check_tree (line 23) | def check_tree(self, parent_id=None, left=-1, right=sys.maxsize):
    method rebuild (line 57) | def rebuild(self):
    method test_update_only_if_parent_is_modified (line 63) | def test_update_only_if_parent_is_modified(self):
    method test_nested_create (line 87) | def test_nested_create(self):

FILE: trytond/tests/test_multivalue.py
  class MultiValueTestCase (line 9) | class MultiValueTestCase(unittest.TestCase):
    method setUpClass (line 13) | def setUpClass(cls):
    method test_get_multivalue (line 17) | def test_get_multivalue(self):
    method test_get_multivalue_extra_pattern (line 35) | def test_get_multivalue_extra_pattern(self):
    method test_get_multivalue_default (line 52) | def test_get_multivalue_default(self):
    method test_get_multivalue_match_none (line 63) | def test_get_multivalue_match_none(self):
    method test_get_multivalue_many2one (line 79) | def test_get_multivalue_many2one(self):
    method test_get_multivalue_multiselection (line 93) | def test_get_multivalue_multiselection(self):
    method test_get_multivalue_reference (line 105) | def test_get_multivalue_reference(self):
    method test_set_multivalue (line 119) | def test_set_multivalue(self):
    method test_set_multivalue_extra_pattern (line 134) | def test_set_multivalue_extra_pattern(self):
    method test_set_multivalue_match_none (line 150) | def test_set_multivalue_match_none(self):
    method test_set_multivalue_other_default (line 163) | def test_set_multivalue_other_default(self):
    method test_set_multivalue_many2one (line 177) | def test_set_multivalue_many2one(self):
    method test_set_multivalue_multiselection (line 195) | def test_set_multivalue_multiselection(self):
    method test_set_multivalue_reference (line 210) | def test_set_multivalue_reference(self):
    method test_multivalue_setter (line 228) | def test_multivalue_setter(self):
    method test_multivalue_getter (line 240) | def test_multivalue_getter(self):
    method test_multivalue_getter_reference (line 252) | def test_multivalue_getter_reference(self):

FILE: trytond/tests/test_order.py
  class SequenceOrderedMixinTestCase (line 9) | class SequenceOrderedMixinTestCase(unittest.TestCase):
    method setUpClass (line 13) | def setUpClass(cls):
    method test_order (line 17) | def test_order(self):

FILE: trytond/tests/test_path.py
  class PathTestCase (line 11) | class PathTestCase(TreeTestCaseMixin, unittest.TestCase):
    method check_tree (line 15) | def check_tree(self, parent_id=None):
    method rebuild (line 31) | def rebuild(self):

FILE: trytond/tests/test_protocols.py
  class DumpsLoadsMixin (line 14) | class DumpsLoadsMixin:
    method dumps_loads (line 16) | def dumps_loads(self, value):
    method test_datetime (line 19) | def test_datetime(self):
    method test_date (line 23) | def test_date(self):
    method test_time (line 27) | def test_time(self):
    method test_timedelta (line 31) | def test_timedelta(self):
    method test_bytes (line 35) | def test_bytes(self):
    method test_decimal (line 40) | def test_decimal(self):
    method test_biginteger (line 44) | def test_biginteger(self):
    method test_immutable_dict (line 48) | def test_immutable_dict(self):
    method test_none (line 52) | def test_none(self):
  class JSONTestCase (line 57) | class JSONTestCase(DumpsLoadsMixin, unittest.TestCase):
    method test_json_request (line 60) | def test_json_request(self):
    method dumps_loads (line 70) | def dumps_loads(self, value):
  class XMLTestCase (line 76) | class XMLTestCase(DumpsLoadsMixin, unittest.TestCase):
    method test_xml_request (line 79) | def test_xml_request(self):
    method dumps_loads (line 98) | def dumps_loads(self, value):
    method test_decimal_class_load (line 104) | def test_decimal_class_load(self):

FILE: trytond/tests/test_pyson.py
  class PYSONTestCase (line 13) | class PYSONTestCase(unittest.TestCase):
    method test_Decimal (line 16) | def test_Decimal(self):
    method test_Eval (line 20) | def test_Eval(self):
    method test_Not (line 49) | def test_Not(self):
    method test_Bool (line 66) | def test_Bool(self):
    method test_And (line 107) | def test_And(self):
    method test_Or (line 150) | def test_Or(self):
    method test_Equal (line 193) | def test_Equal(self):
    method test_Greater (line 215) | def test_Greater(self):
    method test_Less (line 310) | def test_Less(self):
    method test_If (line 389) | def test_If(self):
    method test_Get (line 413) | def test_Get(self):
    method test_In (line 446) | def test_In(self):
    method test_Date (line 505) | def test_Date(self):
    method test_Date_start (line 562) | def test_Date_start(self):
    method test_Date_start_datetime (line 571) | def test_Date_start_datetime(self):
    method test_Date_start_invalid (line 580) | def test_Date_start_invalid(self):
    method test_DateTime (line 588) | def test_DateTime(self):
    method test_DateTime_start (line 707) | def test_DateTime_start(self):
    method test_DateTime_start_datetime (line 716) | def test_DateTime_start_datetime(self):
    method test_DateTime_start_invalid (line 726) | def test_DateTime_start_invalid(self):
    method test_Len (line 734) | def test_Len(self):
    method test_TimeDelta_pyson (line 757) | def test_TimeDelta_pyson(self):
    method test_TimeDelta_types (line 766) | def test_TimeDelta_types(self):
    method test_TimeDelta_invalid_type (line 772) | def test_TimeDelta_invalid_type(self):
    method test_TimeDelta_eval (line 777) | def test_TimeDelta_eval(self):
    method test_TimeDelta_repr (line 784) | def test_TimeDelta_repr(self):
    method test_Composite (line 789) | def test_Composite(self):
    method test_noeval (line 803) | def test_noeval(self):
    method test_Eval_dot_notation (line 826) | def test_Eval_dot_notation(self):
    method test_Eval_dot_notation_nested (line 839) | def test_Eval_dot_notation_nested(self):
    method test_Eval_dot_notation_in_context (line 852) | def test_Eval_dot_notation_in_context(self):
    method test_eval_true (line 865) | def test_eval_true(self):
    method test_eval_false (line 869) | def test_eval_false(self):

FILE: trytond/tests/test_report.py
  class ReportTestCase (line 10) | class ReportTestCase(unittest.TestCase):
    method setUpClass (line 14) | def setUpClass(cls):
    method test_format_datetime (line 18) | def test_format_datetime(self):
    method test_format_datetime_custom_format (line 25) | def test_format_datetime_custom_format(self):
  function create_test_format_timedelta (line 33) | def create_test_format_timedelta(i, in_, out):

FILE: trytond/tests/test_res.py
  class ResTestCase (line 16) | class ResTestCase(ModuleTestCase):
    method test_user_avatar (line 22) | def test_user_avatar(self):
    method test_user_warning (line 34) | def test_user_warning(self):
    method test_user_warning_ignored (line 42) | def test_user_warning_ignored(self):
    method test_user_warning_always_ignored (line 57) | def test_user_warning_always_ignored(self):
    method test_user_warning_reentrant (line 73) | def test_user_warning_reentrant(self):

FILE: trytond/tests/test_resource.py
  class ResourceTestCase (line 10) | class ResourceTestCase(unittest.TestCase):
    method setUpClass (line 14) | def setUpClass(cls):
    method test_resources_copied (line 18) | def test_resources_copied(self):
    method test_resources_not_copied (line 39) | def test_resources_not_copied(self):
    method test_note_write (line 59) | def test_note_write(self):

FILE: trytond/tests/test_routes.py
  class RoutesTestCase (line 17) | class RoutesTestCase(unittest.TestCase):
    method setUpClass (line 20) | def setUpClass(cls):
    method tearDownClass (line 31) | def tearDownClass(cls):
    method auth_headers (line 36) | def auth_headers(self):
    method data_url (line 41) | def data_url(self, model):
    method test_data_no_field (line 47) | def test_data_no_field(self):
    method test_data_one_field (line 56) | def test_data_one_field(self):
    method test_data_multiple_fields (line 67) | def test_data_multiple_fields(self):
    method test_data_language (line 79) | def test_data_language(self):
    method test_data_size (line 94) | def test_data_size(self):
    method test_data_page (line 108) | def test_data_page(self):
    method test_data_encoding (line 131) | def test_data_encoding(self):
    method test_data_delimiter (line 148) | def test_data_delimiter(self):
    method test_data_quotechar (line 160) | def test_data_quotechar(self):
    method test_data_no_header (line 174) | def test_data_no_header(self):
    method test_data_locale_format (line 185) | def test_data_locale_format(self):

FILE: trytond/tests/test_rpc.py
  class RPCTestCase (line 11) | class RPCTestCase(unittest.TestCase):
    method setUpClass (line 15) | def setUpClass(cls):
    method test_simple (line 19) | def test_simple(self):
    method test_keyword_argument (line 27) | def test_keyword_argument(self):
    method test_wrong_context_type (line 35) | def test_wrong_context_type(self):
    method test_missing_context (line 45) | def test_missing_context(self):
    method test_clean_context (line 55) | def test_clean_context(self):
    method test_timestamp (line 63) | def test_timestamp(self):
    method test_instantiate (line 71) | def test_instantiate(self):
    method test_instantiate_unique (line 107) | def test_instantiate_unique(self):
    method test_instantiate_slice (line 121) | def test_instantiate_slice(self):
    method test_check_access (line 133) | def test_check_access(self):

FILE: trytond/tests/test_rule.py
  class ModelRuleTestCase (line 13) | class ModelRuleTestCase(unittest.TestCase):
    method setUpClass (line 17) | def setUpClass(cls):
    method test_perm_create_without_rule (line 21) | def test_perm_create_without_rule(self):
    method test_perm_create_with_rule (line 29) | def test_perm_create_with_rule(self):
    method test_perm_create_with_rule_fail (line 54) | def test_perm_create_with_rule_fail(self):
    method test_perm_create_with_default_rule_fail (line 80) | def test_perm_create_with_default_rule_fail(self):
    method test_perm_write_without_rule (line 107) | def test_perm_write_without_rule(self):
    method test_perm_write_with_rule (line 117) | def test_perm_write_with_rule(self):
    method test_perm_write_with_rule_fail_before (line 143) | def test_perm_write_with_rule_fail_before(self):
    method test_perm_write_with_rule_fail_after (line 170) | def test_perm_write_with_rule_fail_after(self):
    method test_perm_delete_without_rule (line 197) | def test_perm_delete_without_rule(self):
    method test_perm_delete_with_rule (line 207) | def test_perm_delete_with_rule(self):
    method test_perm_delete_with_rule_fail (line 233) | def test_perm_delete_with_rule_fail(self):
    method test_perm_read_without_rule (line 260) | def test_perm_read_without_rule(self):
    method test_perm_read_with_rule (line 270) | def test_perm_read_with_rule(self):
    method test_perm_read_with_rule_fail (line 296) | def test_perm_read_with_rule_fail(self):
    method test_search_without_rule (line 323) | def test_search_without_rule(self):
    method test_search_with_rule (line 333) | def test_search_with_rule(self):
    method test_search_with_rule_match (line 359) | def test_search_with_rule_match(self):
    method test_write_field_no_rule (line 385) | def test_write_field_no_rule(self):
    method test_write_field_rule_True (line 395) | def test_write_field_rule_True(self):
    method test_write_field_rule_False (line 422) | def test_write_field_rule_False(self):
    method test_write_field_relation_rule_True (line 449) | def test_write_field_relation_rule_True(self):
    method test_write_field_relation_rule_False (line 478) | def test_write_field_relation_rule_False(self):
    method test_delete_field_no_rule (line 507) | def test_delete_field_no_rule(self):
    method test_delete_field_rule_True (line 517) | def test_delete_field_rule_True(self):
    method test_delete_field_rule_False (line 544) | def test_delete_field_rule_False(self):
    method test_delete_field_relation_rule_True (line 571) | def test_delete_field_relation_rule_True(self):
    method test_delete_field_relation_rule_False (line 600) | def test_delete_field_relation_rule_False(self):
    method test_model_with_rule (line 629) | def test_model_with_rule(self):
    method test_model_with_rule_fail (line 657) | def test_model_with_rule_fail(self):

FILE: trytond/tests/test_sendmail.py
  class SendmailTestCase (line 15) | class SendmailTestCase(unittest.TestCase):
    method setUpClass (line 19) | def setUpClass(cls):
    method test_sendmail_transactional (line 23) | def test_sendmail_transactional(self):
    method test_sendmail (line 34) | def test_sendmail(self):
    method test_get_smtp_server (line 44) | def test_get_smtp_server(self):
    method test_get_smtp_server_extra_parameters (line 71) | def test_get_smtp_server_extra_parameters(self):
    method test_SMTPDataManager (line 83) | def test_SMTPDataManager(self, get_smtp_server):

FILE: trytond/tests/test_sequence.py
  class SequenceTestCase (line 13) | class SequenceTestCase(unittest.TestCase):
    method setUpClass (line 17) | def setUpClass(cls):
    method get_model (line 21) | def get_model():
    method test_incremental (line 26) | def test_incremental(self):
    method test_decimal_timestamp (line 59) | def test_decimal_timestamp(self):
    method test_hexadecimal_timestamp (line 88) | def test_hexadecimal_timestamp(self):
    method test_prefix_suffix (line 118) | def test_prefix_suffix(self):
  class SequenceStrictTestCase (line 145) | class SequenceStrictTestCase(SequenceTestCase):
    method get_model (line 149) | def get_model():

FILE: trytond/tests/test_tools.py
  class ToolsTestCase (line 26) | class ToolsTestCase(unittest.TestCase):
    method test_reduce_ids_empty (line 30) | def test_reduce_ids_empty(self):
    method test_reduce_ids_continue (line 34) | def test_reduce_ids_continue(self):
    method test_reduce_ids_one_hole (line 39) | def test_reduce_ids_one_hole(self):
    method test_reduce_ids_short_continue (line 46) | def test_reduce_ids_short_continue(self):
    method test_reduce_ids_complex (line 51) | def test_reduce_ids_complex(self):
    method test_reduce_ids_complex_small_continue (line 58) | def test_reduce_ids_complex_small_continue(self):
    method test_reduce_ids_float (line 66) | def test_reduce_ids_float(self):
    method test_reduce_domain (line 75) | def test_reduce_domain(self):
    method test_grouped_slice (line 103) | def test_grouped_slice(self):
    method test_grouped_slice_generator (line 114) | def test_grouped_slice_generator(self):
    method test_is_instance_method (line 120) | def test_is_instance_method(self):
    method test_file_open (line 140) | def test_file_open(self):
    method test_file_open_suffix (line 161) | def test_file_open_suffix(self):
    method test_strip_wildcard (line 166) | def test_strip_wildcard(self):
    method test_strip_wildcard_different_wildcard (line 180) | def test_strip_wildcard_different_wildcard(self):
    method test_lstrip_wildcard (line 184) | def test_lstrip_wildcard(self):
    method test_lstrip_wildcard_different_wildcard (line 198) | def test_lstrip_wildcard_different_wildcard(self):
    method test_rstrip_wildcard (line 202) | def test_rstrip_wildcard(self):
    method test_rstrip_wildcard_different_wildcard (line 216) | def test_rstrip_wildcard_different_wildcard(self):
    method test_escape_wildcard (line 219) | def test_escape_wildcard(self):
    method test_unescape_wildcard (line 224) | def test_unescape_wildcard(self):
    method test_is_full_text (line 230) | def test_is_full_text(self):
    method test_slugify (line 244) | def test_slugify(self):
    method test_slugify_hyphenate (line 248) | def test_slugify_hyphenate(self):
    method test_sortable_values (line 252) | def test_sortable_values(self):
    method test_firstline (line 271) | def test_firstline(self):
    method test_remove_forbidden_chars (line 283) | def test_remove_forbidden_chars(self):
    method test_get_tzinfo_valid (line 294) | def test_get_tzinfo_valid(self):
    method test_get_tzinfo_invalid (line 300) | def test_get_tzinfo_invalid(self):
    method test_availabe_timezones (line 306) | def test_availabe_timezones(self):
  class StringPartitionedTestCase (line 313) | class StringPartitionedTestCase(unittest.TestCase):
    method test_init (line 316) | def test_init(self):
    method test_init_partitioned (line 322) | def test_init_partitioned(self):
    method test_iter (line 329) | def test_iter(self):
    method test_len (line 334) | def test_len(self):
    method test_str (line 339) | def test_str(self):
    method test_add (line 348) | def test_add(self):
    method test_radd (line 356) | def test_radd(self):
  class LazyStringTestCase (line 365) | class LazyStringTestCase(unittest.TestCase):
    method test_init (line 368) | def test_init(self):
    method test_init_args (line 374) | def test_init_args(self):
    method test_add (line 380) | def test_add(self):
    method test_radd (line 387) | def test_radd(self):
  class ImmutableDictTestCase (line 395) | class ImmutableDictTestCase(unittest.TestCase):
    method test_setitem (line 398) | def test_setitem(self):
    method test_delitem (line 405) | def test_delitem(self):
    method test_ior (line 412) | def test_ior(self):
    method test_clear (line 419) | def test_clear(self):
    method test_pop (line 426) | def test_pop(self):
    method test_popitem (line 433) | def test_popitem(self):
    method test_setdefault (line 440) | def test_setdefault(self):
    method test_update (line 447) | def test_update(self):
  class DomainInversionTestCase (line 455) | class DomainInversionTestCase(unittest.TestCase):
    method test_simple_inversion (line 458) | def test_simple_inversion(self):
    method test_and_inversion (line 470) | def test_and_inversion(self):
    method test_or_inversion (line 489) | def test_or_inversion(self):
    method test_orand_inversion (line 520) | def test_orand_inversion(self):
    method test_andor_inversion (line 530) | def test_andor_inversion(self):
    method test_andand_inversion (line 540) | def test_andand_inversion(self):
    method test_oror_inversion (line 555) | def test_oror_inversion(self):
    method test_parse (line 576) | def test_parse(self):
    method test_simplify (line 589) | def test_simplify(self):
    method test_simplify_deduplicate (line 636) | def test_simplify_deduplicate(self):
    method test_merge (line 665) | def test_merge(self):
    method test_concat (line 704) | def test_concat(self):
    method test_unique_value (line 716) | def test_unique_value(self):
    method test_evaldomain (line 735) | def test_evaldomain(self):
    method test_localize (line 885) | def test_localize(self):
    method test_prepare_reference_domain (line 932) | def test_prepare_reference_domain(self):
    method test_extract_models (line 998) | def test_extract_models(self):
  function load_tests (line 1015) | def load_tests(loader, tests, pattern):

FILE: trytond/tests/test_transaction.py
  function empty_transaction (line 10) | def empty_transaction(*args, **kwargs):
  class TransactionTestCase (line 21) | class TransactionTestCase(unittest.TestCase):
    method setUpClass (line 25) | def setUpClass(cls):
    method test_nonexistdb (line 28) | def test_nonexistdb(self):
    method test_set_user (line 37) | def test_set_user(self):
    method test_stacked_transactions (line 70) | def test_stacked_transactions(self):
    method test_two_phase_commit (line 80) | def test_two_phase_commit(self):

FILE: trytond/tests/test_tree.py
  class TreeTestCaseMixin (line 11) | class TreeTestCaseMixin:
    method setUpClass (line 15) | def setUpClass(cls):
    method create (line 18) | def create(self):
    method check_tree (line 37) | def check_tree(self):
    method change_parent (line 40) | def change_parent(self, parent=None, restore=False):
    method test_create (line 60) | def test_create(self):
    method test_reparent (line 66) | def test_reparent(self):
    method test_move (line 73) | def test_move(self):
    method test_active (line 80) | def test_active(self):
    method test_delete (line 122) | def test_delete(self):
    method test_write_multiple_parents (line 144) | def test_write_multiple_parents(self):
    method rebuild (line 160) | def rebuild(self):
    method test_rebuild (line 164) | def test_rebuild(self):
  class TreeMixinTestCase (line 173) | class TreeMixinTestCase(unittest.TestCase):
    method setUpClass (line 177) | def setUpClass(cls):
    method test_name_domain (line 181) | def test_name_domain(self):
    method test_name_domain_wildcard (line 192) | def test_name_domain_wildcard(self):
    method test_rec_name (line 201) | def test_rec_name(self):
    method test_on_change_with_rec_name (line 214) | def test_on_change_with_rec_name(self):
    method test_search_rec_name_equals (line 227) | def test_search_rec_name_equals(self):
    method test_search_rec_name_equals_toplevel (line 242) | def test_search_rec_name_equals_toplevel(self):
    method test_search_rec_name_equals_none (line 257) | def test_search_rec_name_equals_none(self):
    method test_search_rec_name_non_equals (line 272) | def test_search_rec_name_non_equals(self):
    method test_search_rec_name_non_equals_toplevel (line 287) | def test_search_rec_name_non_equals_toplevel(self):
    method test_search_rec_name_non_equals_none (line 302) | def test_search_rec_name_non_equals_none(self):
    method test_search_rec_name_in (line 317) | def test_search_rec_name_in(self):
    method test_search_rec_name_in_toplevel (line 332) | def test_search_rec_name_in_toplevel(self):
    method test_search_rec_name_like (line 347) | def test_search_rec_name_like(self):
    method test_search_rec_name_like_toplevel (line 364) | def test_search_rec_name_like_toplevel(self):
    method test_search_rec_name_like_lowlevel (line 381) | def test_search_rec_name_like_lowlevel(self):
    method test_check_recursion (line 398) | def test_check_recursion(self):
    method test_check_recursion_polytree (line 415) | def test_check_recursion_polytree(self):

FILE: trytond/tests/test_trigger.py
  class TriggerTestCase (line 17) | class TriggerTestCase(unittest.TestCase):
    method setUpClass (line 21) | def setUpClass(cls):
    method setUp (line 24) | def setUp(self):
    method run_tasks (line 27) | def run_tasks(self):
    method test_constraints (line 36) | def test_constraints(self):
    method test_on_create (line 80) | def test_on_create(self):
    method test_on_write (line 157) | def test_on_write(self):
    method test_on_delete (line 289) | def test_on_delete(self):
    method test_on_time (line 380) | def test_on_time(self):

FILE: trytond/tests/test_tryton.py
  function activate_module (line 57) | def activate_module(modules, lang='en'):
  function restore_db_cache (line 97) | def restore_db_cache(name):
  function backup_db_cache (line 111) | def backup_db_cache(name):
  function _db_cache_file (line 123) | def _db_cache_file(path, name):
  function _sqlite_copy (line 127) | def _sqlite_copy(file_, restore=False):
  function _pg_options (line 146) | def _pg_options():
  function _pg_restore (line 161) | def _pg_restore(cache_file):
  function _pg_dump (line 182) | def _pg_dump(cache_file):
  function with_transaction (line 202) | def with_transaction(user=1, context=None):
  class ModuleTestCase (line 219) | class ModuleTestCase(unittest.TestCase):
    method setUpClass (line 226) | def setUpClass(cls):
    method tearDownClass (line 235) | def tearDownClass(cls):
    method test_rec_name (line 240) | def test_rec_name(self):
    method test_model__access__ (line 258) | def test_model__access__(self):
    method test_view (line 277) | def test_view(self):
    method test_icon (line 335) | def test_icon(self):
    method test_rpc_callable (line 352) | def test_rpc_callable(self):
    method test_missing_depends (line 363) | def test_missing_depends(self):
    method test_depends (line 385) | def test_depends(self):
    method test_field_methods (line 447) | def test_field_methods(self):
    method test_field_relation_target (line 500) | def test_field_relation_target(self):
    method test_field_relation_domain (line 548) | def test_field_relation_domain(self):
    method test_menu_action (line 569) | def test_menu_action(self):
    method test_model_access (line 599) | def test_model_access(self):
    method test_workflow_transitions (line 628) | def test_workflow_transitions(self):
    method test_wizards (line 654) | def test_wizards(self):
    method test_selection_fields (line 696) | def test_selection_fields(self):
    method test_function_fields (line 723) | def test_function_fields(self):
    method test_ir_action_window (line 745) | def test_ir_action_window(self):
    method test_modelsingleton_inherit_order (line 793) | def test_modelsingleton_inherit_order(self):
    method test_pool_slots (line 810) | def test_pool_slots(self):
    method test_buttons_registered (line 827) | def test_buttons_registered(self):
    method test_buttons_states (line 849) | def test_buttons_states(self):
    method test_xml_files (line 869) | def test_xml_files(self):
  function db_exist (line 888) | def db_exist(name=DB_NAME):
  function create_db (line 893) | def create_db(name=DB_NAME, lang='en'):
  class ExtensionTestCase (line 934) | class ExtensionTestCase(unittest.TestCase):
    method setUpClass (line 938) | def setUpClass(cls):
    method tearDownClass (line 943) | def tearDownClass(cls):
    method _activate_extension (line 949) | def _activate_extension(cls):
    method _deactivate_extension (line 958) | def _deactivate_extension(cls):
    method _clear_cache (line 966) | def _clear_cache(cls):
  function drop_db (line 970) | def drop_db(name=DB_NAME):
  function drop_create (line 982) | def drop_create(name=DB_NAME, lang='en'):
  function doctest_setup (line 988) | def doctest_setup(test):
  function doctest_teardown (line 992) | def doctest_teardown(test):
  function load_doc_tests (line 1000) | def load_doc_tests(name, path, loader, tests, pattern):
  class TestSuite (line 1024) | class TestSuite(unittest.TestSuite):
    method run (line 1025) | def run(self, *args, **kwargs):
  function load_tests (line 1040) | def load_tests(loader, tests, pattern):

FILE: trytond/tests/test_union.py
  class UnionMixinTestCase (line 9) | class UnionMixinTestCase(unittest.TestCase):
    method setUpClass (line 13) | def setUpClass(cls):
    method test_union (line 17) | def test_union(self):
    method test_union_union (line 43) | def test_union_union(self):
    method test_union_tree (line 65) | def test_union_tree(self):

FILE: trytond/tests/test_user.py
  function set_authentications (line 20) | def set_authentications(methods):
  class UserTestCase (line 29) | class UserTestCase(unittest.TestCase):
    method setUpClass (line 33) | def setUpClass(cls):
    method setUp (line 36) | def setUp(self):
    method create_user (line 55) | def create_user(self, login, password, email=None):
    method check_user (line 67) | def check_user(self, login, password):
    method test_test_hash (line 83) | def test_test_hash(self):
    method test_read_password_hash (line 89) | def test_read_password_hash(self):
    method test_validate_password_length (line 95) | def test_validate_password_length(self):
    method test_validate_password_forbidden (line 105) | def test_validate_password_forbidden(self):
    method test_validate_password_name (line 114) | def test_validate_password_name(self):
    method test_validate_password_login (line 124) | def test_validate_password_login(self):
    method test_validate_password_email (line 134) | def test_validate_password_email(self):
    method test_reset_password (line 144) | def test_reset_password(self):
    method test_reset_password_expired (line 169) | def test_reset_password_expired(self):
    method test_reset_password_with_password (line 188) | def test_reset_password_with_password(self):
    method test_authentications (line 207) | def test_authentications(self):
    method test_bad_authentication_logging (line 237) | def test_bad_authentication_logging(self):
    method test_bad_authentication_valid_cookie (line 247) | def test_bad_authentication_valid_cookie(self):
    method test_bad_authentication_invalid_cookie (line 263) | def test_bad_authentication_invalid_cookie(self):
    method test_authentication_option_ip_address (line 282) | def test_authentication_option_ip_address(self):
    method test_authentication_option_device_cookie (line 317) | def test_authentication_option_device_cookie(self):

FILE: trytond/tests/test_wizard.py
  class WizardTestCase (line 11) | class WizardTestCase(unittest.TestCase):
    method setUpClass (line 14) | def setUpClass(cls):
    method test_create (line 18) | def test_create(self):
    method test_delete (line 29) | def test_delete(self):
    method test_session (line 38) | def test_session(self):
    method test_execute (line 76) | def test_execute(self):
    method test_execute_without_access (line 112) | def test_execute_without_access(self):
    method test_execute_without_read_access (line 131) | def test_execute_without_read_access(self):
    method test_execute_wrong_model (line 144) | def test_execute_wrong_model(self):

FILE: trytond/tests/test_workflow.py
  class WorkflowTestCase (line 10) | class WorkflowTestCase(unittest.TestCase):
    method setUpClass (line 13) | def setUpClass(cls):
    method test_transition (line 18) | def test_transition(self):

FILE: trytond/tests/test_wsgi.py
  class WSGIAppTestCase (line 14) | class WSGIAppTestCase(unittest.TestCase):
    class TestException (line 17) | class TestException(TrytonException):
    method test_one_error_handler_called (line 20) | def test_one_error_handler_called(self):
    method test_many_error_handlers_called (line 42) | def test_many_error_handlers_called(self):
    method test_class_error_handler_called (line 69) | def test_class_error_handler_called(self):
    method test_error_handlers_last_response (line 92) | def test_error_handlers_last_response(self):

FILE: trytond/tests/tools.py
  function activate_modules (line 11) | def activate_modules(modules):
  function _get_config (line 32) | def _get_config():
  function set_user (line 38) | def set_user(user, config=None):

FILE: trytond/tests/tree.py
  class Tree (line 8) | class Tree(tree(separator=' / '), ModelSQL):
  class TreeWildcard (line 15) | class TreeWildcard(tree(separator='\\'), ModelSQL):
  class Polytree (line 22) | class Polytree(tree(parent='parents'), ModelSQL):
  class PolytreeEdge (line 30) | class PolytreeEdge(ModelSQL):
  function register (line 37) | def register(module):

FILE: trytond/tests/trigger.py
  class Trigger (line 9) | class Trigger(metaclass=PoolMeta):
    method __setup__ (line 13) | def __setup__(cls):
  class Triggered (line 19) | class Triggered(ModelSQL):
  class TriggerAction (line 25) | class TriggerAction(ModelSQL):
    method trigger (line 30) | def trigger(records, trigger):
  function register (line 37) | def register(module):

FILE: trytond/tests/wizard.py
  class TestWizardStart (line 10) | class TestWizardStart(ModelSQL, ModelView):
    method default_user (line 18) | def default_user():
  class TestWizard (line 22) | class TestWizard(Wizard):
    method default_start (line 34) | def default_start(fields):
    method transition_next_ (line 40) | def transition_next_():
    method do_action (line 44) | def do_action(action):
    method transition_action (line 48) | def transition_action():
  function register (line 52) | def register(module):

FILE: trytond/tests/workflow.py
  class WorkflowedModel (line 8) | class WorkflowedModel(Workflow, ModelSQL):
    method __setup__ (line 18) | def __setup__(cls):
    method default_state (line 25) | def default_state():
    method run (line 30) | def run(cls, records):
  function register (line 34) | def register(module):

FILE: trytond/tools/__init__.py
  class ClassProperty (line 17) | class ClassProperty(property):
    method __get__ (line 18) | def __get__(self, cls, owner):
  function cursor_dict (line 22) | def cursor_dict(cursor, size=None):

FILE: trytond/tools/decimal_.py
  function decistmt (line 9) | def decistmt(s):

FILE: trytond/tools/domain_inversion.py
  function sql_like (line 11) | def sql_like(value, pattern, ignore_case=True):
  function in_ (line 40) | def in_(a, b):
  function locale_part (line 67) | def locale_part(expression, field_name, locale_name='id'):
  function is_leaf (line 76) | def is_leaf(expression):
  function constrained_leaf (line 82) | def constrained_leaf(part, boolop=operator.and_):
  function eval_leaf (line 91) | def eval_leaf(part, context, boolop=operator.and_):
  function inverse_leaf (line 145) | def inverse_leaf(domain):
  function filter_leaf (line 159) | def filter_leaf(domain, field, model):
  function prepare_reference_domain (line 171) | def prepare_reference_domain(domain, reference):
  function extract_reference_models (line 232) | def extract_reference_models(domain, field_name):
  function eval_domain (line 246) | def eval_domain(domain, context, boolop=operator.and_):
  function localize_domain (line 263) | def localize_domain(domain, field_name=None, strip_target=False):
  function bool_operator (line 287) | def bool_operator(domain):
  function simplify_nested (line 295) | def simplify_nested(domain):
  function simplify_duplicate (line 323) | def simplify_duplicate(domain):
  function simplify (line 343) | def simplify(domain):
  function merge (line 353) | def merge(domain, domoperator=None):
  function concat (line 369) | def concat(*domains, **kwargs):
  function unique_value (line 380) | def unique_value(domain):
  function parse (line 397) | def parse(domain):
  function domain_inversion (line 408) | def domain_inversion(domain, symbol, context=None):
  class And (line 419) | class And(object):
    method __init__ (line 421) | def __init__(self, expressions):
    method base (line 430) | def base(self, expression):
    method inverse (line 436) | def inverse(self, symbol, context):
  class Or (line 469) | class Or(And):
    method inverse (line 471) | def inverse(self, symbol, context):

FILE: trytond/tools/email_.py
  function _domainaddr (line 6) | def _domainaddr(address):
  function set_from_header (line 12) | def set_from_header(message, sender, from_):

FILE: trytond/tools/gevent.py
  function is_gevent_monkey_patched (line 5) | def is_gevent_monkey_patched():

FILE: trytond/tools/immutabledict.py
  class ImmutableDict (line 4) | class ImmutableDict(dict):
    method _not_allowed (line 8) | def _not_allowed(cls, *args, **kwargs):

FILE: trytond/tools/misc.py
  function file_open (line 27) | def file_open(name, mode="r", subdir='modules', encoding=None):
  function find_path (line 33) | def find_path(name, subdir='modules', _test=os.path.isfile):
  function find_dir (line 88) | def find_dir(name, subdir='modules'):
  function get_smtp_server (line 93) | def get_smtp_server():
  function reduce_ids (line 107) | def reduce_ids(field, ids):
  function reduce_domain (line 149) | def reduce_domain(domain):
  function grouped_slice (line 180) | def grouped_slice(records, count=None):
  function is_instance_method (line 192) | def is_instance_method(cls, method):
  function resolve (line 199) | def resolve(name):
  function strip_wildcard (line 213) | def strip_wildcard(string, wildcard='%', escape='\\'):
  function lstrip_wildcard (line 219) | def lstrip_wildcard(string, wildcard='%'):
  function rstrip_wildcard (line 226) | def rstrip_wildcard(string, wildcard='%', escape='\\'):
  function escape_wildcard (line 235) | def escape_wildcard(string, wildcards='%_', escape='\\'):
  function unescape_wildcard (line 241) | def unescape_wildcard(string, wildcards='%_', escape='\\'):
  function is_full_text (line 247) | def is_full_text(value, escape='\\'):
  function slugify (line 259) | def slugify(value, hyphenate='-'):
  function sortable_values (line 267) | def sortable_values(func):
  function sql_pairing (line 278) | def sql_pairing(x, y):
  function firstline (line 286) | def firstline(text):
  function remove_forbidden_chars (line 294) | def remove_forbidden_chars(value):

FILE: trytond/tools/multivalue.py
  function migrate_property (line 13) | def migrate_property(

FILE: trytond/tools/singleton.py
  class Singleton (line 5) | class Singleton(type):
    method __init__ (line 9) | def __init__(cls, name, bases, dict):
    method __call__ (line 13) | def __call__(cls, *args, **kwargs):

FILE: trytond/tools/string_.py
  class StringMatcher (line 13) | class StringMatcher:
    method _reset_cache (line 16) | def _reset_cache(self):
    method __init__ (line 20) | def __init__(self, isjunk=None, seq1='', seq2=''):
    method set_seqs (line 26) | def set_seqs(self, seq1, seq2):
    method set_seq1 (line 30) | def set_seq1(self, seq1):
    method set_seq2 (line 34) | def set_seq2(self, seq2):
    method get_opcodes (line 38) | def get_opcodes(self):
    method get_editops (line 47) | def get_editops(self):
    method get_matching_blocks (line 56) | def get_matching_blocks(self):
    method ratio (line 62) | def ratio(self):
    method quick_ratio (line 67) | def quick_ratio(self):
    method real_quick_ratio (line 73) | def real_quick_ratio(self):
    method distance (line 77) | def distance(self):
  class StringPartitioned (line 85) | class StringPartitioned(str):
    method __init__ (line 89) | def __init__(self, base):
    method __iter__ (line 96) | def __iter__(self):
    method __add__ (line 99) | def __add__(self, other):
    method __radd__ (line 104) | def __radd__(self, other):
  class LazyString (line 110) | class LazyString():
    method __init__ (line 111) | def __init__(self, func, *args, **kwargs):
    method __str__ (line 116) | def __str__(self):
    method __add__ (line 119) | def __add__(self, other):
    method __radd__ (line 122) | def __radd__(self, other):

FILE: trytond/tools/timezone.py
  class ZoneInfoNotFoundError (line 15) | class ZoneInfoNotFoundError(KeyError):
  function available_timezones (line 23) | def available_timezones():
  function get_tzinfo (line 34) | def get_tzinfo(zoneid):

FILE: trytond/transaction.py
  function record_cache_size (line 19) | def record_cache_size(transaction):
  class _AttributeManager (line 23) | class _AttributeManager(object):
    method __init__ (line 28) | def __init__(self, **kwargs):
    method __enter__ (line 31) | def __enter__(self):
    method __exit__ (line 34) | def __exit__(self, type, value, traceback):
  class _Local (line 39) | class _Local(local):
    method __init__ (line 41) | def __init__(self):
  class Transaction (line 47) | class Transaction(object):
    method __new__ (line 69) | def __new__(cls, new=False):
    method monotonic_time (line 90) | def monotonic_time():
    method tasks (line 97) | def tasks(self):
    method get_cache (line 100) | def get_cache(self):
    method start (line 106) | def start(self, database_name, user, readonly=False, context=None,
    method __enter__ (line 148) | def __enter__(self):
    method __exit__ (line 151) | def __exit__(self, type, value, traceback):
    method stop (line 154) | def stop(self, commit=False):
    method set_context (line 191) | def set_context(self, context=None, **kwargs):
    method reset_context (line 202) | def reset_context(self):
    method set_user (line 207) | def set_user(self, user, set_context=False):
    method set_current_transaction (line 222) | def set_current_transaction(self, transaction):
    method new_transaction (line 226) | def new_transaction(self, autocommit=False, readonly=False):
    method commit (line 232) | def commit(self):
    method rollback (line 259) | def rollback(self):
    method join (line 268) | def join(self, datamanager):
    method atexit (line 276) | def atexit(self, func, *args, **kwargs):
    method language (line 280) | def language(self):

FILE: trytond/url.py
  class URLAccessor (line 19) | class URLAccessor(object):
    method __init__ (line 22) | def __init__(self, protocol='tryton'):
    method is_secure (line 26) | def is_secure(cls):
    method host (line 37) | def host(cls):
    method http_host (line 46) | def http_host(cls):
    method protocol (line 52) | def protocol(self):
    method separator (line 58) | def separator(self):
    method __get__ (line 63) | def __get__(self, inst, cls):
  class URLMixin (line 94) | class URLMixin:

FILE: trytond/wizard/wizard.py
  class Button (line 24) | class Button(object):
    method __init__ (line 29) | def __init__(self, string, state,
    method states (line 40) | def states(self):
    method states (line 44) | def states(self, value):
  class State (line 49) | class State(object):
  class StateView (line 56) | class StateView(State):
    method __init__ (line 61) | def __init__(self, model_name, view, buttons):
    method get_view (line 73) | def get_view(self, wizard, state_name):
    method get_defaults (line 86) | def get_defaults(self, wizard, state_name, fields):
    method get_values (line 99) | def get_values(self, wizard, state_name, fields):
    method _complete_values (line 108) | def _complete_values(self, values):
    method get_buttons (line 122) | def get_buttons(self, wizard, state_name):
  class StateTransition (line 151) | class StateTransition(State):
  class StateAction (line 157) | class StateAction(StateTransition):
    method __init__ (line 162) | def __init__(self, action_id):
    method get_action (line 169) | def get_action(self):
  class StateReport (line 181) | class StateReport(StateAction):
    method __init__ (line 184) | def __init__(self, report_name):
    method get_action (line 188) | def get_action(self):
  class Wizard (line 201) | class Wizard(URLMixin, PoolBase):
    method __setup__ (line 207) | def __setup__(cls):
    method __post_setup__ (line 221) | def __post_setup__(cls):
    method __register__ (line 232) | def __register__(cls, module_name):
    method check_access (line 239) | def check_access(cls):
    method create (line 284) | def create(cls):
    method delete (line 291) | def delete(cls, session_id):
    method execute (line 304) | def execute(cls, session_id, data, state_name):
    method _execute (line 330) | def _execute(self, state_name):
    method __init__ (line 367) | def __init__(self, session_id):
    method _save (line 379) | def _save(self):
    method model (line 394) | def model(self):
    method record (line 401) | def record(self):
    method records (line 407) | def records(self):

FILE: trytond/worker.py
  class Queue (line 25) | class Queue(object):
    method __init__ (line 26) | def __init__(self, database_name, mpool):
    method pull (line 31) | def pull(self, name=None):
    method run (line 40) | def run(self, task_id):
  class TaskList (line 44) | class TaskList(list):
    method filter (line 45) | def filter(self):
  function work (line 52) | def work(options):
  function initializer (line 94) | def initializer(database_names, worker=True):
  function run_task (line 108) | def run_task(pool, task_id):

FILE: trytond/wsgi.py
  function NumProxyFix (line 24) | def NumProxyFix(app, num_proxies):
  class Base64Converter (line 53) | class Base64Converter(BaseConverter):
    method to_python (line 55) | def to_python(self, value):
    method to_url (line 58) | def to_url(self, value):
  class TrytondWSGI (line 62) | class TrytondWSGI(object):
    method __init__ (line 64) | def __init__(self):
    method route (line 71) | def route(self, string, methods=None, defaults=None):
    method error_handler (line 78) | def error_handler(self, handler):
    method auth_required (line 83) | def auth_required(self, wrapped, instance, args, kwargs):
    method check_request_size (line 94) | def check_request_size(self, request, size=None):
    method dispatch_request (line 113) | def dispatch_request(self, request):
    method make_response (line 138) | def make_response(self, request, data):
    method wsgi_app (line 162) | def wsgi_app(self, environ, start_response):
    method __call__ (line 209) | def __call__(self, environ, start_response):
  class SharedDataMiddlewareIndex (line 213) | class SharedDataMiddlewareIndex(SharedDataMiddleware):
    method __call__ (line 214) | def __call__(self, environ, start_response):
    method get_directory_loader (line 220) | def get_directory_loader(self, directory):