Remove the optional member data for a given member in the named leaderboard.

        @param leaderboard_name [String] Name of the leaderboard.
        @param member [String] Member name.
169253
def remove_member_from(self, leaderboard_name, member):
        '''
        
        '''
        member_score = None or self.redis_connection.zscore(
            leaderboard_name, member)
        can_delete_score = member_score and len(
            self.members_from_score_range_in(leaderboard_name, member_score, member_score)) == 1

        pipeline = self.redis_connection.pipeline()
        pipeline.zrem(leaderboard_name, member)
        if can_delete_score:
            pipeline.zrem(self._ties_leaderboard_key(leaderboard_name),
                          str(float(member_score)))
        pipeline.hdel(self._member_data_key(leaderboard_name), member)
        pipeline.execute()
442980
def update_member_data(self, member, member_data):
        '''
        
        '''
        self.update_member_data_in(self.leaderboard_name, member, member_data)
1136982
def remove_list_members(self, screen_name=None, user_id=None, slug=None,
                            list_id=None, owner_id=None, owner_screen_name=None):
        
        return self._remove_list_members(list_to_csv(screen_name),
                                         list_to_csv(user_id),
                                         slug, list_id, owner_id,
                                         owner_screen_name)
418364
public void removeIndividual(Member member, String studyId) {
        // Sanity check
        if (member == null) {
            logger.error("Individual is null.");
            return;
        }
        removeIndividual(member.getName(), studyId);
    }
609862
public void removeMember (FormationMember<T> member) {
		// Find the member's slot
		int slot = findMemberSlot(member);

		// Make sure we've found a valid result
		if (slot >= 0) {
			// Remove the slot
			// slotAssignments.removeIndex(slot);
			slotAssignmentStrategy.removeSlotAssignment(slotAssignments, slot);

			// Update the assignments
			updateSlotAssignments();
		}
	}
448480
def delete(options = {})
      options = options.merge(role_name: @name)
      resp = @client.delete_role(options)
      resp.data
    end
138943
private void removeRRInstance(PackingPlanBuilder packingPlanBuilder,
                                String componentName) throws RuntimeException {
    List<Scorer<Container>> scorers = new ArrayList<>();
    scorers.add(new HomogeneityScorer(componentName, true));  // all-same-component containers first
    scorers.add(new InstanceCountScorer());                   // then fewest instances
    scorers.add(new HomogeneityScorer(componentName, false)); // then most homogeneous
    scorers.add(new ContainerIdScorer(false));                // then highest container id

    this.containerId = nextContainerId(packingPlanBuilder.removeInstance(scorers, componentName));
  }
1314366
def remove_member(mem)
      raise InvalidDataError, "Smart group members can't be changed." if @is_smart
      raise InvalidDataError, "Can't remove nil" if mem.nil?
      removed = @members.reject! { |mm| [mm[:id], mm[:name], mm[:username]].include? mem }
      @need_to_update = true if removed
    end
809039
def _member_data_key(self, leaderboard_name):
        '''
        
        '''
        if self.global_member_data is False:
            return '%s:%s' % (leaderboard_name, self.member_data_namespace)
        else:
            return self.member_data_namespace
310275
def filter_trainers(self, trainers):
		""""""
		return [LeaderboardInstance(x) for x in self._leaderboard if x['id'] in trainers]
187772
private void fireMemberRemoved(MemberId exMember) {
        GL.debug(GL.CLUSTER_LOGGER_NAME, "Firing member removed for: {}", exMember);
        for (MembershipEventListener listener : membershipEventListeners) {
            try {
                listener.memberRemoved(exMember);
            } catch (Throwable e) {
                GL.error(GL.CLUSTER_LOGGER_NAME, "Error in member removed event {}", e);
            }
        }
    }
18730
def org_remove_member(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/removeMember' % object_id, input_params, always_retry=always_retry, **kwargs)
860515
def rank_member_in(
            self, leaderboard_name, member, score, member_data=None):
        '''
        
        '''
        pipeline = self.redis_connection.pipeline()
        if isinstance(self.redis_connection, Redis):
            pipeline.zadd(leaderboard_name, member, score)
        else:
            pipeline.zadd(leaderboard_name, score, member)
        if member_data:
            pipeline.hset(
                self._member_data_key(leaderboard_name),
                member,
                member_data)
        pipeline.execute()
1046162
def remove_upvote
      begin
        client.delete("/cards/#{id}/membersVoted/#{me.id}")
      rescue Trello::Error => e
        fail e unless e.message =~ /has not voted/i
      end

      self
    end
1164355
def remove(self, cls, originalMemberNameList, classNamingConvention):
        
        self._memberDelegate.remove(cls = cls,
                                    originalMemberNameList = originalMemberNameList,
                                    memberName = self._memberName,
                                    classNamingConvention = classNamingConvention)
828437
def change_score_for(self, member, delta, member_data=None):
        '''
        
        '''
        self.change_score_for_member_in(self.leaderboard_name, member, delta, member_data)
1268603
public void removeExistingBody(/* @Nullable */ JvmMember member) {
		if (member != null) {
			// We have to be careful how to remove existing adapters due to an EMF bug:
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=462451
			Object[] adapters = member.eAdapters().toArray();
			for (int i = 0, j = 0; i < adapters.length; i++) {
				if (adapters[i] instanceof CompilationStrategyAdapter
						|| adapters[i] instanceof CompilationTemplateAdapter) {
					member.eAdapters().remove(j);
				} else {
					j++;
				}
			}
			associator.removeLogicalChildAssociation(member);
		}
	}