# Transaction

exception trytond.transaction.TransactionError

  The base class for transaction error that need to retry the transaction.

TransactionError.fix(extras)

  Update the extras argument of `start()` to restart the transaction without the error.

class trytond.transaction.Transaction

  Represents a Tryton transaction that contains thread-local parameters of a database connection. The Transaction instances are context manager that commits or rollbacks the database transaction. In the event of an exception the transaction is rolled back, otherwise it is commited.

Transaction.database

  The database.

Transaction.readonly

Transaction.connection

  The database connection as defined by the PEP-0249.

Transaction.user

  The id of the user.

Transaction.context

Transaction.create_records

Transaction.delete_records

Transaction.trigger_records

Transaction.check_warnings

  The set of warnings already checked.

Transaction.timestamp

Transaction.started_at

  The monotonic timestamp when the transaction started.

Transaction.language

  The language code defines in the context.

Transaction.counter

  Count the number of modification made in this transaction.

Transaction.check_access

  If the access must be enforced.

Transaction.active_records

  If the active test is enabled for `DeactivableMixin`.

static Transaction.monotonic_time()

  Return a monotonic time used to populate `started_at`.

Transaction.start(database_name, user[, readonly[, context[, close[, autocommit, \**extras]]]])

  Start a new transaction and return a context manager. The non-readonly transaction will be committed when exiting the `with` statement without exception. The other cases will be rollbacked.

Transaction.stop([commit])

  Stop the transaction. If commit is `True`, the transaction will be committed otherwise it will be rollbacked. The context manager returned by `start()` should be used instead of calling this method.

Transaction.set_context(context, \**kwargs)

  Update the transaction context and return a context manager. The context is restored when exiting the `with` statement.

Transaction.reset_context()

  Clear the transaction context and return a context manager. The context is restored when exiting the `with` statement.

Transaction.set_user(user[, set_context])

  Modify the user of the transaction and return a context manager. `set_context` will put the previous user id in the context to simulate the record rules. The user will be restored when exiting the `with` statement.

Transaction.lock_table(table)

  Raise a `TransactionError` to retry the transaction if the table has not been locked at the start.

Transaction.set_current_transaction(transaction)

  Add a specific `transaction` on the top of the transaction stack. A transaction is commited or rollbacked only when its last reference is popped from the stack.

Transaction.new_transaction([autocommit[, readonly, \**extras]])

  Create a new transaction with the same database, user and context as the original transaction and adds it to the stack of transactions.

Transaction.commit()

  Commit the transaction and all data managers associated.

Transaction.rollback()

  Rollback the transaction and all data managers associated.

Transaction.join(datamanager)

  Register in the transaction a data manager conforming to the Two-Phase Commit protocol.

  This method returns the registered datamanager. It could be a different yet equivalent (in term of python equality) datamanager than the one passed to the method.

Transaction.atexit(func, \*args, \*\*kwargs)

  Register a function to be executed upon normal transaction termination. The function can not use the current transaction because it will be already committed or rollbacked.

trytond.transaction.check_access([func])

  When called with a function, it decorates the function to be executed with check of access rights. Otherwise it returns a context manager that check access rights until exiting.

trytond.transaction.without_check_access([func])

  When called with a function, it decorates the function to be executed without check of access rights. Otherwise it returns a context manager that disable check access rights until exiting.

trytond.transaction.active_records([func])

  When called with a function, it decorates the function to be executed with active test enabled. Otherwise it returns a context manager that enable active test.

trytond.transaction.inactive_records(func)

  When called with a function, it decorates the function to be executed with active test disabled. Otherwise it returns a context manager that disables active test.