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