docs: def upsert(self, key, value, cas=0, ttl=0, format=None,
                 persist_to=0, replicate_to=0):
          """Unconditionally store the object in Couchbase.
  
          :param key:
              The key to set the value with. By default, the key must be
              either a :class:`bytes` or :class:`str` object encodable as
              UTF-8. If a custom `transcoder` class is used (see
              :meth:`~__init__`), then the key object is passed directly
              to the transcoder, which may serialize it how it wishes.
          :type key: string or bytes
  
          :param value: The value to set for the key.
              This should be a native Python value which will be transparently
              serialized to JSON by the library. Do not pass already-serialized
              JSON as the value or it will be serialized again.
  
              If you are using a different `format` setting (see `format`
              parameter), and/or a custom transcoder then value for this
              argument may need to conform to different criteria.
  
          :param int cas: The _CAS_ value to use. If supplied, the value
              will only be stored if it already exists with the supplied
              CAS
  
          :param int ttl: If specified, the key will expire after this
              many seconds
  
          :param int format: If specified, indicates the `format` to use
              when encoding the value. If none is specified, it will use
              the `default_format` For more info see
              :attr:`~.default_format`
  
          :param int persist_to:
              Perform durability checking on this many nodes nodes for
              persistence to disk. See :meth:`endure` for more information
  
          :param int replicate_to: Perform durability checking on this
              many replicas for presence in memory. See :meth:`endure` for
              more information.
  
          :raise: :exc:`.ArgumentError` if an argument is supplied that is
              not applicable in this context. For example setting the CAS
              as a string.
          :raise: :exc`.CouchbaseNetworkError`
          :raise: :exc:`.KeyExistsError` if the key already exists on the
              server with a different CAS value.
          :raise: :exc:`.ValueFormatError` if the value cannot be
              serialized with chosen encoder, e.g. if you try to store a
              dictionary in plain mode.
          :return: :class:`~.Result`.
  
          Simple set::
  
              cb.upsert('key', 'value')
  
          Force JSON document format for value::
  
              cb.upsert('foo', {'bar': 'baz'}, format=couchbase.FMT_JSON)
  
          Insert JSON from a string::
  
              JSONstr = '{"key1": "value1", "key2": 123}'
              JSONobj = json.loads(JSONstr)
              cb.upsert("documentID", JSONobj, format=couchbase.FMT_JSON)
  
          Force UTF8 document format for value::
  
              cb.upsert('foo', "<xml></xml>", format=couchbase.FMT_UTF8)
  
          Perform optimistic locking by specifying last known CAS version::
  
              cb.upsert('foo', 'bar', cas=8835713818674332672)
  
          Several sets at the same time (mutli-set)::
  
              cb.upsert_multi({'foo': 'bar', 'baz': 'value'})
  
          .. seealso:: :meth:`upsert_multi`
          """
          return _Base.upsert(self, key, value, cas=cas, ttl=ttl,
                              format=format, persist_to=persist_to,
                              replicate_to=replicate_to)