Remove any specified role variable
500175
private RolePlayerFragmentSet removeRoleVar() {
        Preconditions.checkNotNull(role());
        return new AutoValue_RolePlayerFragmentSet(
                varProperty(), relation(), edge(), rolePlayer(), null, roleLabels(), relationTypeLabels()
        );
    }
606974
def remove_tenant_user_role(request, project=None, user=None, role=None,
                            group=None, domain=None):
    """"""
    manager = keystoneclient(request, admin=True).roles
    if VERSIONS.active < 3:
        return manager.remove_user_role(user, role, project)
    else:
        return manager.revoke(role, user=user, project=project,
                              group=group, domain=domain)
1231620
def remove_role(role, reason = nil)
      role_ids = role_id_array(role)

      if role_ids.count == 1
        API::Server.remove_member_role(@bot.token, @server.id, @user.id, role_ids[0], reason)
      else
        old_role_ids = @roles.map(&:id)
        new_role_ids = old_role_ids.reject { |i| role_ids.include?(i) }
        API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
      end
    end
172376
public function removeRole($role)
    {
        $key = array_search(strtoupper($role), $this->roles, true);
        if (false !== $key) {
            /** @var string $key */
            unset($this->roles[$key]);
            $this->roles = array_values($this->roles);
        }

        return $this;
    }
402561
def delete_local_variable(self, onnx_name):
        '''
        
        '''
        if onnx_name not in self.onnx_variable_names or onnx_name not in self.variables:
            raise RuntimeError('The variable to be removed not found')
        self.onnx_variable_names.discard(onnx_name)
        raw_name = self.variables[onnx_name].raw_name
        self.variable_name_mapping[raw_name].remove(onnx_name)
        del self.variables[onnx_name]
1328818
def remove_roles(self, databaseName, roleNames, collectionName=None):
        
        for roleName in roleNames:
            self.remove_role(databaseName, roleName, collectionName)
549209
def _remove_rule(self, group, role, value=None):
        """"""
        if role not in group:
            return

        if value is None:
            group.pop(role, None)
        else:
            group[role].remove(value)

        self.invalidate()
1360585
def delete_role(name, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    if not role_exists(name, region, key, keyid, profile):
        return True
    try:
        conn.delete_role(name)
        log.info('Deleted %s IAM role.', name)
        return True
    except boto.exception.BotoServerError as e:
        log.debug(e)
        log.error('Failed to delete %s IAM role.', name)
        return False
1170421
public function removeUnusedRoles()
    {
        $removeRoles = array(
            'contributor'
        );

        foreach ($removeRoles as $role) {
            if (!get_role($role)) {
                continue;
            }

            update_option('_' . $role . '_role_bkp', get_role('author'));
            remove_role($role);
        }
    }
105219
def unset_variable(var, override=false)

      fexp, v = locate_set_var(var, override) || locate_var(var)

      fexp.un_set_variable(:unset, v, nil, (fexp.h.fei != h.fei)) if fexp
    end
885238
def remove_role_from_user(self, user, role):
        
        user.remove_role(role)
        self.save(user)
        events.user_lost_role_event.send(user, role=role)
664914
def clear_roles(user):
    """"""
    roles = get_user_roles(user)

    for role in roles:
        role.remove_role_from_user(user)

    return roles
402226
def delete_role(resource_root, service_name, name, cluster_name="default"):
  
  return call(resource_root.delete,
      _get_role_path(cluster_name, service_name, name), ApiRole)
438626
def role_delete(self, role_id, **kwargs):
        ""
        api_path = "/api/v2/roles/{role_id}"
        api_path = api_path.format(role_id=role_id)
        return self.call(api_path, method="DELETE", **kwargs)
536611
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
                 password=None, runas=None):
    '''
    
    '''

    # check if user exists
    if not user_exists(name, user, host, port, maintenance_db,
                       password=password, runas=runas):
        log.info('User \'%s\' does not exist', name)
        return False

    # user exists, proceed
    sub_cmd = 'DROP ROLE "{0}"'.format(name)
    _psql_prepare_and_run(
        ['-c', sub_cmd],
        runas=runas, host=host, user=user, port=port,
        maintenance_db=maintenance_db, password=password)

    if not user_exists(name, user, host, port, maintenance_db,
                       password=password, runas=runas):
        return True
    else:
        log.info('Failed to delete user \'%s\'.', name)
        return False
409582
def deleteRole(self, roleID):
        
        url = self._url + "/%s/delete" % roleID
        params = {
            "f" : "json"
        }
        return self._post(url=url,
                             param_dict=params,
                             proxy_url=self._proxy_url,
                             proxy_port=self._proxy_port)
719652
def remove_role(project_root)
      # Choose a role from the availables
      roles = Bebox::Role.list(project_root)
      # Get a role if exist.
      if roles.count > 0
        role_name = choose_option(roles, _('wizard.role.choose_deletion_role'))
      else
        return error _('wizard.role.no_deletion_roles')
      end
      # Ask for deletion confirmation
      return warn(_('wizard.no_changes')) unless confirm_action?(_('wizard.role.confirm_deletion'))
      # Role deletion
      role = Bebox::Role.new(role_name, project_root)
      output = role.remove
      ok _('wizard.role.deletion_success')
      return output
    end