docs: def endure(self, key, persist_to=-1, replicate_to=-1, cas=0,
                 check_removed=False, timeout=5.0, interval=0.010):
          """Wait until a key has been distributed to one or more nodes
  
          By default, when items are stored to Couchbase, the operation is
          considered successful if the vBucket master (i.e. the "primary"
          node) for the key has successfully stored the item in its
          memory.
  
          In most situations, this is sufficient to assume that the item
          has successfully been stored. However the possibility remains
          that the "master" server will go offline as soon as it sends
          back the successful response and the data is lost.
  
          The ``endure`` function allows you to provide stricter criteria
          for success. The criteria may be expressed in terms of number of
          nodes for which the item must exist in that node's RAM and/or on
          that node's disk. Ensuring that an item exists in more than one
          place is a safer way to guarantee against possible data loss.
  
          We call these requirements `Durability Constraints`, and thus
          the method is called `endure`.
  
          :param string key: The key to endure.
          :param int persist_to: The minimum number of nodes which must
              contain this item on their disk before this function
              returns. Ensure that you do not specify too many nodes;
              otherwise this function will fail. Use the
              :attr:`server_nodes` to determine how many nodes exist in
              the cluster.
  
              The maximum number of nodes an item can reside on is
              currently fixed to 4 (i.e. the "master" node, and up to
              three "replica" nodes). This limitation is current as of
              Couchbase Server version 2.1.0.
  
              If this parameter is set to a negative value, the maximum
              number of possible nodes the key can reside on will be used.
  
          :param int replicate_to: The minimum number of replicas which
              must contain this item in their memory for this method to
              succeed. As with ``persist_to``, you may specify a negative
              value in which case the requirement will be set to the
              maximum number possible.
  
          :param float timeout: A timeout value in seconds before this
              function fails with an exception. Typically it should take
              no longer than several milliseconds on a functioning cluster
              for durability requirements to be satisfied (unless
              something has gone wrong).
  
          :param float interval: The polling interval in seconds to use
              for checking the key status on the respective nodes.
              Internally, ``endure`` is implemented by polling each server
              individually to see if the key exists on that server's disk
              and memory. Once the status request is sent to all servers,
              the client will check if their replies are satisfactory; if
              they are then this function succeeds, otherwise the client
              will wait a short amount of time and try again. This
              parameter sets this "wait time".
  
          :param bool check_removed: This flag inverts the check. Instead
              of checking that a given key *exists* on the nodes, this
              changes the behavior to check that the key is *removed* from
              the nodes.
  
          :param long cas: The CAS value to check against. It is possible
              for an item to exist on a node but have a CAS value from a
              prior operation. Passing the CAS ensures that only replies
              from servers with a CAS matching this parameter are accepted.
  
          :return: A :class:`~.OperationResult`
          :raise: see :meth:`upsert` and :meth:`get` for possible errors
  
          .. seealso:: :meth:`upsert`, :meth:`endure_multi`
          """
          # We really just wrap 'endure_multi'
          kv = {key: cas}
          rvs = self.endure_multi(keys=kv, persist_to=persist_to,
                                  replicate_to=replicate_to,
                                  check_removed=check_removed, timeout=timeout,
                                  interval=interval)
          return rvs[key]