Class AttemptContext

acouchbase/transactions/transactions.py:159–447

class AttemptContext(AttemptContextLogic):

    def __init__(self,
                 ctx,         # type: TransactionsCapsuleType
                 loop,        # type: AbstractEventLoop
                 transcoder,  # type: Transcoder
                 opts         # type: Optional[transaction_options]
                 ):
        super().__init__(ctx, transcoder, loop, opts)

    @AsyncWrapper.inject_callbacks(None)
    def _new_attempt(self,
                     **kwargs  # type: Dict[str, Any]
                     ) -> Awaitable[None]:
        return super()._new_attempt_async(**kwargs)

    @AsyncWrapper.inject_callbacks(None)
    def _rollback(self,
                  **kwargs  # type: Dict[str, Any]
                  ) -> Awaitable[None]:
        return super()._rollback_async(**kwargs)

    @AsyncWrapper.inject_callbacks(TransactionResult)
    def _commit(self,
                **kwargs  # type: Dict[str, Any]
                ) -> Awaitable[TransactionResult]:
        return super()._commit_async(**kwargs)

    @AsyncWrapper.inject_callbacks(TransactionGetResult)
    def _get(self,
             coll,     # type: AsyncCollection
             key,      # type: str
             **kwargs  # type: Dict[str, Any]
             ) -> Awaitable[TransactionGetResult]:
        return super().get(coll, key, **kwargs)

    def get(self,
            coll,          # type: AsyncCollection
            key,           # type: str
            options=None,  # type: Optional[TransactionGetOptions]
            **kwargs       # type: Dict[str, Any]
            ) -> Awaitable[TransactionGetResult]:
        """
        Get a document within this transaction.

        Args:
            coll (:class:`couchbase.collection.Collection`): Collection to use to find the document.
            key (str): document key.
            options (:class:`~couchbase.options.TransactionGetOptions`): Optional parameters for this operation.
            **kwargs (Dict[str, Any]): keyword arguments that can be used in place or to
                override provided :class:`~couchbase.options.TransactionGetOptions`

        Returns:
            Awaitable[:class:`couchbase.transactions.TransactionGetResult`]: Document in collection, in a form useful
            for passing to other transaction operations. Or `None` if the document was not found.
        Raises:
            :class:`couchbase.exceptions.TransactionOperationFailed`: If the operation failed.  In practice, there is
            no need to handle the exception, as the transaction will rollback regardless.