Returns the status of all changes for the current tailored audience instance.

 @example
   audience.status

 @since 0.3.0

 @return [Hash] Returns a hash object representing the tailored audience status.
504516
def status
      return nil unless id
      resource = RESOURCE_UPDATE % { account_id: account.id }
      request = Request.new(account.client, :get, resource, params: to_params)
      Cursor.new(nil, request).to_a.select { |change| change[:tailored_audience_id] == id }
    end
1140573
def changed_attributes_clear!
      return if changed_attributes.nil?

      # changed_attributes is frozen starting with ActiveModel 5.2.0
      # Not a good long term solution
      if changed_attributes.frozen?
        @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
      else
        changed_attributes && changed_attributes.clear
      end
    end
502195
def status(registration_ids)
      registration_ids = [registration_ids].flatten
      url = base_url + 'status'
      body = { registration_ids: registration_ids }
      Http::Client.post(@jpush, url, body: body)
    end
882887
public com.google.api.ads.adwords.axis.v201809.ch.ChangeStatus getFeedChangeStatus() {
        return feedChangeStatus;
    }
1126427
def get_current_block_hash(self, is_full: bool = False) -> str:
        
        payload = self.generate_json_rpc_payload(RpcMethod.GET_CURRENT_BLOCK_HASH)
        response = self.__post(self.__url, payload)
        if is_full:
            return response
        return response['result']
1099272
def get_prev_status_from_history(instance, status=None):
    
    target = status or api.get_workflow_status_of(instance)
    history = getReviewHistory(instance, reverse=True)
    history = map(lambda event: event["review_state"], history)
    if target not in history or history.index(target) == len(history)-1:
        return None
    return history[history.index(target)+1]
779733
def preempt_get
      hash = {}
      hash[:preempt] = default_preempt
      hash[:minimum] = default_preempt_delay_minimum
      hash[:reload] = default_preempt_delay_reload
      hash[:sync] = default_preempt_delay_sync
      arr = config_get('interface_hsrp_group', 'preempt', @get_args)
      if arr
        hash[:preempt] = true
        hash[:minimum] = arr[0]
        hash[:reload] = arr[1]
        hash[:sync] = arr[2]
      end
      hash
    end
206147
def get_status(id)
			
			if id == nil || id == ""
				return nil
			end			
			
			result = get(@protocol + WebServicesBaseURLGet + "getstatus.ashx?id=" + GrabzIt::Utility.nil_check(id))

			doc = REXML::Document.new(result)

			processing = doc.root.elements["Processing"].text()
			cached = doc.root.elements["Cached"].text()
			expired = doc.root.elements["Expired"].text()
			message = doc.root.elements["Message"].text()

			return ScreenShotStatus.new((processing == TrueString), (cached == TrueString), (expired == TrueString), message)
		end
1132227
def version
      values = {}
      ring.servers.each do |server|
        values["#{server.name}"] = server.alive? ? server.request(:version) : nil
      end
      values
    end
918422
@Override
    public Map<String, Number> status() {
        Map<String, Number> ret = new HashMap<>();
        ret.put("workers", workers);
        ret.put("accumulatedUpdates", numUpdates());
        return ret;
    }
508144
def status(reason = false)
      case @status_code
      when SUCCESS      then 'success'
      when ERROR        then 'error' + (reason ? " (#{truncated_error})" : "")
      when CONTINUE     then 'continue'
      when RETRY        then 'retry' + (reason ? " (#{@content})" : "")
      when NON_DELIVERY then 'non-delivery' + (reason ? " (#{@content})" : "")
      when MULTICAST    then 'multicast'
      when CANCEL       then 'cancel' + (reason ? " (#{@content})" : "")
      end
    end
885842
def status(self):
        
        message = self.end_message if self.end_message else self.start_message
        if message:
            return message.contents[ACTION_STATUS_FIELD]
        else:
            return None
1141405
def to_h
      hash                        = {:churn => {:changes => @changes}}
      hash[:churn][:class_churn]  = @class_changes
      hash[:churn][:method_churn] = @method_changes
      #detail the most recent changes made this revision
      first_revision         = @revisions.first
      first_revision_changes = @revision_changes[first_revision]
      if first_revision_changes
        changes = first_revision_changes
        hash[:churn][:changed_files]   = changes[:files]
        hash[:churn][:changed_classes] = changes[:classes]
        hash[:churn][:changed_methods] = changes[:methods]
      end
      # TODO crappy place to do this but save hash to revision file but
      # while entirely under metric_fu only choice
      ChurnHistory.store_revision_history(first_revision, hash, @churn_options.data_directory)
      hash
    end
520866
def get_status(self, instance):
        
        status_key, status = self._get_status(instance)
        if status['state'] in ['complete', 'error']:
            cache.delete(status_key)
        return status
131905
def status_for_all_orders(self):
        
        url_fragment = 'venues/{venue}/accounts/{account}/orders'.format(
            venue=self.venue,
            account=self.account,
        )
        url = urljoin(self.base_url, url_fragment)
        return self.session.get(url).json()
958494
def get_combined_status(self):
        
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.url + "/status"
        )
        return github.CommitCombinedStatus.CommitCombinedStatus(self._requester, headers, data, completed=True)
1107447
def status(self):
        
        config = self._get_config()
        is_hex = lambda name: (len(name) == 4 and
                               all(c in string.hexdigits for c in name))
        out = SimpleNamespace()
        for sect in config:
            for itm in config[sect].values():
                if (itm.readonly or sect == 'status') and not is_hex(itm.name):
                    setattr(out, itm.name, itm.value)
        return out