https://developers.coinbase.com/api/v2#commit-a-deposit
167034
def commit_deposit(self, deposit_id, **params):
        """"""
        return self.api_client.commit_deposit(self.id, deposit_id, **params)
255234
@Override
  public void commit() throws IOException {
    try {
      LOG.info("Flushing pending insert.");
      this.commands.flush();
      LOG.info("Commiting transaction.");
      this.conn.commit();
    } catch (Exception e) {
      this.failed = true;
      throw new RuntimeException(e);
    }
  }
1157547
def commit(self):
        '''
        

        '''
        url = self.api_endpoints['send']
        payload = {
            'actions': self._bulk_query,
        }
        payload.update(self._payload)
        self._bulk_query = []

        return self._make_request(
            url,
            json.dumps(payload),
            headers={'content-type': 'application/json'},
        )
346709
def get_commit_req(self):
        """"""
        if not self.commit_req:
            self.commit_req = datastore.CommitRequest()
            self.commit_req.transaction = self.tx
        return self.commit_req
1207949
def commit(self):
        

        try:
            self.check_connection()
        except NullDatabaseConnectionError:
            return

        logger.debug("commit: path='{}'".format(self.database_path))

        try:
            self.connection.commit()
        except sqlite3.ProgrammingError:
            pass
327385
def commit(self, snapshot: Tuple[Hash32, UUID]) -> None:
        
        _, account_snapshot = snapshot
        self._account_db.commit(account_snapshot)
1037653
def get_deposit(self, account_id, deposit_id, **params):
        """"""
        response = self._get(
            'v2', 'accounts', account_id, 'deposits', deposit_id, params=params)
        return self._make_api_object(response, Deposit)
578196
function commitCardTransaction(cardId, transactionId, _ref, otp, options) {
  let message = _ref.message,
      securityCode = _ref.securityCode;

  options = (0, _lodash2.default)({
    body: {
      message: message,
      securityCode: securityCode
    },
    method: 'post'
  }, options);

  if (otp) {
    options.headers = _extends({
      'otp-token': otp
    }, options.headers);
  }

  return this.api(`/me/cards/${cardId}/transactions/${transactionId}/commit`, options);
}
105258
function composeCoinbaseJoint(from_address, coinbase_address, round_index, coinbase_amount, signer, callbacks){
	var coinbase_foundation_amount = Math.floor(coinbase_amount*constants.FOUNDATION_RATIO);
	composeJoint({
		paying_addresses: [from_address],
		outputs: [{address: coinbase_address, amount: 0}, {address: constants.FOUNDATION_ADDRESS, amount: coinbase_foundation_amount}],
		//inputs: [{type: "coinbase", amount: coinbase_amount, address: from_address}],
		inputs: [{type: "coinbase", amount: coinbase_amount}],
		round_index: round_index,
		input_amount: coinbase_amount,
		pow_type: constants.POW_TYPE_COIN_BASE,
		signer: signer,
		callbacks: callbacks
	});
}
594093
def commit(self):
        """"""
        if (not self._add_cache and
                not self._remove_cache and
                not self._undefined_cache):
            return

        for store_key, hash_values in self._add_cache.items():
            for hash_value in hash_values:
                super(TransactionalIndex, self).add_hashed_value(
                    hash_value, store_key)
        for store_key in self._remove_cache:
            super(TransactionalIndex, self).remove_key(store_key)
        for store_key in self._undefined_cache:
            super(TransactionalIndex, self).add_undefined(store_key)
        if not self.ephemeral:
            self.save_to_store()

        self._init_cache()
        self._in_transaction = True
1148399
def committed!(should_run_callbacks: true) #:nodoc:
      if should_run_callbacks && trigger_transactional_callbacks?
        @_committed_already_called = true
        _run_commit_without_transaction_enrollment_callbacks
        _run_commit_callbacks
      end
    ensure
      @_committed_already_called = false
      force_clear_transaction_record_state
    end
257861
public void setDeposit(String name, boolean deposit) {
        String newName = name.toLowerCase();
        if (aclList.containsKey(newName)) {
            AccountACLValue value = aclList.get(newName);
            set(newName, deposit, value.canWithdraw(), value.canAcl(), value.canBalance(), value.isOwner());
        } else {
            set(newName, deposit, false, false, false, false);
        }
    }
1282279
def commit(self):
        """"""
        self._transaction = False
        try:
            self._con.commit()
        except self._failures as error:  # cannot commit
            try:  # try to reopen the connection
                con = self._create()
            except Exception:
                pass
            else:
                self._close()
                self._store(con)
            raise error
1116678
def commit_sell(self, sell_id, **params):
        """"""
        return self.api_client.commit_sell(self.id, sell_id, **params)
556119
def commit(self):
        """"""
        if self._transaction_nesting_level == 0:
            raise DBALConnectionError.no_active_transaction()
        if self._is_rollback_only:
            raise DBALConnectionError.commit_failed_rollback_only()

        self.ensure_connected()
        if self._transaction_nesting_level == 1:
            self._driver.commit()
        elif self._nest_transactions_with_savepoints:
            self.release_savepoint(self._get_nested_transaction_savepoint_name())

        self._transaction_nesting_level -= 1

        if not self._auto_commit and self._transaction_nesting_level == 0:
            self.begin_transaction()
632667
def commit(self) -> ResponseCommit:
        """"""
        hash = struct.pack('>Q', self.txCount)
        return ResponseCommit(data=hash)
535567
def commit_when_no_transaction(f):
    ''''''
    def _(self, *args, **kwargs):
        r = f(self, *args, **kwargs)
        return self.session.add(self) if self.session is not None else r
    _.__name__ = f.__name__
    _.__doc__ = f.__doc__
    return _