Update viewers.

        DEPRECATED:  use ``policy["roles/viewers"] = value`` instead.
422237
def viewers(self, value):
        
        warnings.warn(
            _ASSIGNMENT_DEPRECATED_MSG.format("viewers", VIEWER_ROLE),
            DeprecationWarning,
        )
        self[VIEWER_ROLE] = value
1339305
def notifyObservers(self, arg=None):
        ''''''

        self.mutex.acquire()
        try:
            if not self.changed:
                    return
            # Make a local copy in case of synchronous
            # additions of observers:
            localArray = self.obs[:]
            self.clearChanged()
        finally:
            self.mutex.release()
        # Update observers
        for observer in localArray:
            observer.update(self, arg)
201294
def update(self):
        
        if self._owner_changed:
            self.update_owner(self.owner)

        self._resources = [res.name for res in self.resources]
        return self.parent.update(self)
985210
def role_update(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    if 'new_name' in kwargs:
        kwargs['name'] = kwargs.pop('new_name')
    return cloud.update_role(**kwargs)
460706
def update_scan_report(self, role):
        
        state = self.report["state"]

        # ensure the missing meta state is colored up and the ok count is good
        if self.gendoc:
            if self.report["roles"][role]["state"] == "missing_meta":
                return

        if os.path.exists(self.paths["readme"]):
            state["ok_role"] += 1
            self.report["roles"][role]["state"] = "ok"
        else:
            state["missing_readme_role"] += 1
            self.report["roles"][role]["state"] = "missing_readme"
504747
def update(self, label=None, name=None, disabled=None, metadata=None,
            monitoring_zones_poll=None, timeout=None, period=None,
            target_alias=None, target_hostname=None, target_receiver=None):
        
        self.manager.update(self, label=label, name=name,
                disabled=disabled, metadata=metadata,
                monitoring_zones_poll=monitoring_zones_poll, timeout=timeout,
                period=period, target_alias=target_alias,
                target_hostname=target_hostname,
                target_receiver=target_receiver)
169600
def update(self, status=values.unset):
        
        return self._proxy.update(status=status, )
852236
def role_update(self, role_id, data, **kwargs):
        ""
        api_path = "/api/v2/roles/{role_id}"
        api_path = api_path.format(role_id=role_id)
        return self.call(api_path, method="PUT", data=data, **kwargs)
715632
def _re_establish_use_watch(self):
        
        if self.current_tube != self.desired_tube:
            self.use(self.desired_tube)
        if self._watchlist != self.desired_watchlist:
            self.watchlist = self.desired_watchlist
626185
def update_value(self, name, value):
        
        if name not in {'id', self.SERVICE_ENDPOINT, self.CONSUME_ENDPOINT, 'type'}:
            self._values[name] = value
514852
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqi1*con.tind)
1124604
def update_policy(self,defaultHeaders):
		
		if self.inputs is not None:
			for k,v in defaultHeaders.items():
				if k not in self.inputs:
					self.inputs[k] = v
			return self.inputs
		else:
			return self.inputs
1127379
public Policy replaceSubscriptionPolicy(String subscriptionId) throws Exception {
    // [START pubsub_set_subscription_policy]
    try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {
      ProjectSubscriptionName subscriptionName =
          ProjectSubscriptionName.of(projectId, subscriptionId);
      Policy policy = subscriptionAdminClient.getIamPolicy(subscriptionName.toString());
      // Create a role => members binding
      Binding binding =
          Binding.newBuilder()
              .setRole(Role.viewer().toString())
              .addMembers(Identity.allAuthenticatedUsers().toString())
              .build();
      // Update policy
      Policy updatedPolicy = policy.toBuilder().addBindings(binding).build();

      updatedPolicy =
          subscriptionAdminClient.setIamPolicy(subscriptionName.toString(), updatedPolicy);
      return updatedPolicy;
    }
    // [END pubsub_set_subscription_policy]
  }
570927
def reset(db, aid, episode):
    """"""
    params = {
        'aid': aid,
        'type': get_eptype(db, 'regular').id,
        'watched': 1,
        'number': episode,
    }
    with db:
        cur = db.cursor()
        cur.execute(
            """UPDATE episode SET user_watched=:watched
            WHERE aid=:aid AND type=:type AND number<=:number""",
            params)
        params['watched'] = 0
        cur.execute(
            """UPDATE episode SET user_watched=:watched
            WHERE aid=:aid AND type=:type AND number>:number""",
            params)
        cache_status(db, aid, force=True)
1224686
def participant_policy(self, value):
        
        old_policy = self.participant_policy
        new_policy = value
        self._participant_policy = new_policy
        notify(ParticipationPolicyChangedEvent(self, old_policy, new_policy))
1173336
def update_role_positions(role_positions)
      response = JSON.parse(API::Server.update_role_positions(@bot.token, @id, role_positions))
      response.each do |data|
        updated_role = Role.new(data, @bot, self)
        role(updated_role.id).update_from(updated_role)
      end
    end
459927
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqd1*con.tind)