docs: def get(self, key, ttl=0, quiet=None, replica=False, no_format=False):
          """Obtain an object stored in Couchbase by given key.
  
          :param string key: The key to fetch. The type of key is the same
              as mentioned in :meth:`upsert`
  
          :param int ttl: If specified, indicates that the key's expiration
              time should be *modified* when retrieving the value.
  
          :param boolean quiet: causes `get` to return None instead of
              raising an exception when the key is not found. It defaults
              to the value set by :attr:`~quiet` on the instance. In
              `quiet` mode, the error may still be obtained by inspecting
              the :attr:`~.Result.rc` attribute of the :class:`.Result`
              object, or checking :attr:`.Result.success`.
  
              Note that the default value is `None`, which means to use
              the :attr:`quiet`. If it is a boolean (i.e. `True` or
              `False`) it will override the `couchbase.bucket.Bucket`-level
              :attr:`quiet` attribute.
  
          :param bool replica: Whether to fetch this key from a replica
              rather than querying the master server. This is primarily
              useful when operations with the master fail (possibly due to
              a configuration change). It should normally be used in an
              exception handler like so
  
              Using the ``replica`` option::
  
                  try:
                      res = c.get("key", quiet=True) # suppress not-found errors
                  catch CouchbaseError:
                      res = c.get("key", replica=True, quiet=True)
  
          :param bool no_format: If set to ``True``, then the value will
              always be delivered in the :class:`~couchbase.result.Result`
              object as being of :data:`~couchbase.FMT_BYTES`. This is a
              item-local equivalent of using the :attr:`data_passthrough`
              option
  
          :raise: :exc:`.NotFoundError` if the key does not exist
          :raise: :exc:`.CouchbaseNetworkError`
          :raise: :exc:`.ValueFormatError` if the value cannot be
              deserialized with chosen decoder, e.g. if you try to
              retreive an object stored with an unrecognized format
          :return: A :class:`~.Result` object
  
          Simple get::
  
              value = cb.get('key').value
  
          Get multiple values::
  
              cb.get_multi(['foo', 'bar'])
              # { 'foo' : <Result(...)>, 'bar' : <Result(...)> }
  
          Inspect the flags::
  
              rv = cb.get("key")
              value, flags, cas = rv.value, rv.flags, rv.cas
  
          Update the expiration time::
  
              rv = cb.get("key", ttl=10)
              # Expires in ten seconds
  
          .. seealso:: :meth:`get_multi`
          """
  
          return _Base.get(self, key, ttl=ttl, quiet=quiet,
                           replica=replica, no_format=no_format)