TransactWrite Commit Does Not Flush After `_commit` Method

[jaeyoung0509]

• First of all thanks to you I have been using it extensively in our production environment, and it has proven to be a very valuable tool

• I frequently utilize the TransactWrite class for handling transactions.

• However, I recently encountered an issue where, after invoking the _commit method, the transaction does not appear to flush the last items as expected. This behavior seems to cause problems when sharing the Connection object across different operations

• Could you please clarify whether this is the intended behavior or if it might be a bug?

cf

• pynamodb Transaction

  class Transaction:
  
  """
  Base class for a type of transaction operation
  """
  
  def __init__(self, connection: Connection, return_consumed_capacity: Optional[str] = None) -> None:
      self._connection = connection
      self._return_consumed_capacity = return_consumed_capacity
  
  def _commit(self):
      raise NotImplementedError()
  
  def __enter__(self: _TTransaction) -> _TTransaction:
      return self
  
  def __exit__(self, exc_type, exc_val, exc_tb):
      if exc_type is None and exc_val is None and exc_tb is None:
          self._commit()
          # i think if the _commit is succeded  the transcation item should be flushed

• pynamodb TransactWrite code

  class TransactWrite(Transaction):
  
  def __init__(
      self,
      client_request_token: Optional[str] = None,
      return_item_collection_metrics: Optional[str] = None,
      **kwargs: Any,
  ) -> None:
      super(TransactWrite, self).__init__(**kwargs)
      self._client_request_token: Optional[str] = client_request_token
      self._return_item_collection_metrics = return_item_collection_metrics
      self._condition_check_items: List[Dict] = []
      self._delete_items: List[Dict] = []
      self._put_items: List[Dict] = []
      self._update_items: List[Dict] = []
      self._models_for_version_attribute_update: List[Any] = []
  
  def _commit(self) -> Any:
      response = self._connection.transact_write_items(
          condition_check_items=self._condition_check_items,
          delete_items=self._delete_items,
          put_items=self._put_items,
          update_items=self._update_items,
          client_request_token=self._client_request_token,
          return_consumed_capacity=self._return_consumed_capacity,
          return_item_collection_metrics=self._return_item_collection_metrics,
      )
      for model in self._models_for_version_attribute_update:
          model.update_local_version_attribute()
      return response

• example code

  
  global_dyn_connection = Connection()
  transaction = TransactWrite(connection=global_dyn_connection)
  def a():
  with transaction as tx:
      # do something

def b(): with transaction as tx:

do something