code: def send_simple(self, address, timestamp, value):
          
          if self.marquise_ctx is None:
              raise ValueError("Attempted to write to a closed Marquise handle.")
  
          self.__debug("Supplied address: %s" % address)
  
          if value is None:
              raise TypeError("Can't store None as a value.")
  
          if timestamp is None:
              timestamp = self.current_timestamp()
  
          # Wrap/convert our arguments to C datatypes before dispatching.
          # FFI will take care of converting them to the right endianness. I think.
          c_address =   FFI.cast("uint64_t", address)
          c_timestamp = FFI.cast("uint64_t", timestamp)
          c_value =     FFI.cast("uint64_t", value)
  
          success = MARQUISE_SEND_SIMPLE(self.marquise_ctx, c_address, c_timestamp, c_value)
          if success != 0:
              self.__debug("send_simple returned %d, raising exception" % success)
              raise RuntimeError("send_simple was unsuccessful, errno is %d" % FFI.errno)
          self.__debug("send_simple returned %d" % success)
  
          return True
docs: Queue a simple datapoint (ie. a 64-bit word), return True/False for success.
  
          Arguments:
          address -- uint64_t representing a unique metric.
          timestamp -- uint64_t representing number of nanoseconds (10^-9) since epoch.
          value -- uint64_t value being stored.
  
          There are no formal restrictions on how `address` is chosen,
          but it must be unique to the metric you are inserting. If you
          don't have one, you may generate one by calling
          `hash_identifier` with a string; the recommended input is the
          source identifier.
  
          If you don't have a `timestamp` you may pass in None to have
          Pymarquise generate one for you.