Remove the provided attendees from the event

        :param attendees: list of attendees to add
        :type attendees: str or tuple(str, str) or Attendee or list[str] or
         list[tuple(str,str)] or list[Attendee]
765841
def remove(self, attendees):
        
        if isinstance(attendees, (list, tuple)):
            attendees = {
                attendee.address if isinstance(attendee, Attendee) else attendee
                for
                attendee in attendees}
        elif isinstance(attendees, str):
            attendees = {attendees}
        elif isinstance(attendees, Attendee):
            attendees = {attendees.address}
        else:
            raise ValueError('Incorrect parameter type for attendees')

        new_attendees = []
        for attendee in self.__attendees:
            if attendee.address not in attendees:
                new_attendees.append(attendee)
        self.__attendees = new_attendees
        self._track_changes()
406570
public function removeEvents ($event_name_list) {
		foreach ($event_name_list as $event_name) {
			if (isset($this->_events[$event_name])) {
				unset($this->_events[$event_name]);
			}
		}
	}
1147468
def remove_from_group(self, group, user):
        
        data = {'group': group, 'user': user}
        return self.post('removeUserFromGroup', data)
1033122
def add(self, attendees):
        
        if attendees:
            if isinstance(attendees, str):
                self.__attendees.append(
                    Attendee(address=attendees, event=self._event))
                self._track_changes()
            elif isinstance(attendees, Attendee):
                self.__attendees.append(attendees)
                self._track_changes()
            elif isinstance(attendees, tuple):
                name, address = attendees
                if address:
                    self.__attendees.append(
                        Attendee(address=address, name=name, event=self._event))
                    self._track_changes()
            elif isinstance(attendees, list):
                for attendee in attendees:
                    self.add(attendee)
            elif isinstance(attendees,
                            dict) and self._cloud_data_key in attendees:
                attendees = attendees.get(self._cloud_data_key)
                for attendee in attendees:
                    email = attendee.get(self._cc('emailAddress'), {})
                    address = email.get(self._cc('address'), None)
                    if address:
                        name = email.get(self._cc('name'), None)
                        # default value
                        attendee_type = attendee.get(self._cc('type'),
                                                     'required')
                        self.__attendees.append(
                            Attendee(address=address, name=name,
                                     attendee_type=attendee_type,
                                     event=self._event,
                                     response_status=
                                     ResponseStatus(parent=self,
                                                    response_status=
                                                    attendee.get(
                                                        self._cc('status'),
                                                        {}))))
            else:
                raise ValueError('Attendees must be an address string, an '
                                 'Attendee instance, a (name, address) '
                                 'tuple or a list')
849044
def remove_listener(self, event_name, listener):
        """"""
        self.listeners[event_name].remove(listener)
        return self
1012966
def remove(self, what, call):
        
        type = observerTypeEnum.typeOf(what)
        self._observers.remove({
                                    "observing": what,
                                    "type": type,
                                    "call": call
                                 })
772961
def _RemoveUsers(self, remove_users):
    
    for username in remove_users:
      self.utils.RemoveUser(username)
      self.user_ssh_keys.pop(username, None)
    self.invalid_users -= set(remove_users)
244028
async def remove_participant(self, p: Participant):
        
        await self.connection('DELETE', 'tournaments/{}/participants/{}'.format(self._id, p._id))
        if p in self.participants:
            self.participants.remove(p)
750548
def discard_observer(self, observer):
        
        discarded = False
        key = self.make_key(observer)
        if key in self.observers:
            del self.observers[key]
            discarded = True
        return discarded
1164355
def remove(self, cls, originalMemberNameList, classNamingConvention):
        
        self._memberDelegate.remove(cls = cls,
                                    originalMemberNameList = originalMemberNameList,
                                    memberName = self._memberName,
                                    classNamingConvention = classNamingConvention)
1098478
def multizone_member_removed(self, member_uuid):
        """"""
        casts = self._casts
        if member_uuid not in casts:
            casts[member_uuid] = {'listeners': [], 'groups': set()}
        casts[member_uuid]['groups'].discard(self._group_uuid)
        for listener in list(casts[member_uuid]['listeners']):
            listener.removed_from_multizone(self._group_uuid)
272720
def removeByIndex(self, index):
        """"""
        if index < len(self._invites) -1 and \
           index >=0:
            self._invites.remove(index)
59033
def remove(self, event=None):
        
        observers = self._pool.get(event)
        if observers:
            self._pool[event] = []
82291
def delete_tickets(tickets)
      # TODO: Take Ticket objects, too, and pull out IDs.
      xml = make_xml('TicketDeleteRequest')
      tickets.each do |id|
        xml.add_element('Ticket', { 'id' => id })
      end

      (execute xml, '1.2').success
    end
1091880
def remove(self, member):
        
        if not self.client.srem(self.name, member):
            raise KeyError(member)
709192
def remove(self, address):
        
        recipients = []
        if isinstance(address, str):
            address = {address}  # set
        elif isinstance(address, (list, tuple)):
            address = set(address)

        for recipient in self._recipients:
            if recipient.address not in address:
                recipients.append(recipient)
        if len(recipients) != len(self._recipients):
            self._track_changes()
        self._recipients = recipients
322714
def get_event_attendee(self, id, attendee_id, **data):
        
        
        return self.get("/events/{0}/attendees/{0}/".format(id,attendee_id), data=data)