Get a list of participants in this room
 This is all people currently in the room
173606
def participants(options = {})
      response = self.class.get(@api.participant_config[:url],
        :query => { :auth_token => @token }.merge(options),
        :headers => @api.headers)

      ErrorHandler.response_code_to_exception_for :room, room_id, response
      wrap_users(response)
    end
553721
def list(self, limit=None, marker=None, name=None, visibility=None,
            member_status=None, owner=None, tag=None, status=None,
            size_min=None, size_max=None, sort_key=None, sort_dir=None):
        
        return self._manager.list(limit=limit, marker=marker, name=name,
                visibility=visibility, member_status=member_status,
                owner=owner, tag=tag, status=status, size_min=size_min,
                size_max=size_max, sort_key=sort_key, sort_dir=sort_dir)
477669
def entries(self):
        
        layout = self._entryWidget.layout()
        output = []
        for i in range(layout.count() - 1):
            widget = layout.itemAt(i).widget()
            if not isinstance(widget, XOrbQueryEntryWidget):
                continue
            output.append(widget)
        return output
73605
def rooms
      response = self.class.get(@api.user_joined_rooms_config[:url],
                                :query => { :auth_token => @token }.merge(@api.user_joined_rooms_config[:query_params]),
                                :headers => @api.headers
      )
      ErrorHandler.response_code_to_exception_for :user, user_id, response
      User.new(@token, response.merge(:api_version => @api.version))
    end
291582
def members(self):
        

        if self._this_occupant is not None:
            items = [self._this_occupant]
        else:
            items = []
        items += list(self._occupant_info.values())
        return items
227888
def refresh_rooms(self):
        """"""
        for room_id in self.user_api.get_joined_rooms()["joined_rooms"]:
            self._rooms[room_id] = MatrixRoom(room_id, self.user_api)
20313
def process_member_event(room, event)
      return if Events.processed? event
      id = event['state_key'] || event['sender']
      get_user(id).process_member_event room, event
    end
1144049
function(user, stage, method){
		switch (method) {
			case 'withinRooms':
			
				var room = user.getRoom();
				if(stageCount(stage, room) == room.size) {
					console.log("Finished syncronising in " + room.name + ". Enough members in stage " + stage);
					
					// Once all members are present start experiment
					for(var key in room.getMembers(true)) {
						user = cloak.getUser(room.getMembers(true)[key].id);
						nextStage(user);
					}
				}
				break;
				
			case 'acrossRooms':
			default:
				if(stageCount(stage) == members.length) {
					console.log("Finished syncronising. Enough members in stage " + stage);

					// Once all members are present start experiment
					for(var key in members) {
						user = cloak.getUser(members[key]);
						nextStage(user);
					}
				}
				break;
		}
	}
91993
def get_participants_for_section(section, person=None):
    
    section_label = encode_section_label(section.section_label())
    url = "/rest/gradebook/v1/section/{}/participants".format(section_label)
    headers = {}

    if person is not None:
        headers["X-UW-Act-as"] = person.uwnetid

    data = get_resource(url, headers)

    participants = []
    for pt in data["participants"]:
        participants.append(_participant_from_json(pt))

    return participants
205998
def publishToOther(self, roomId, name, data):
        
        tmpList = self.getRoom(roomId)
        # Select everybody except me
        userList = [x for x in tmpList if x is not self]
        self.publishToRoom(roomId, name, data, userList)
959385
def members(options = {})
      response = self.class.get(@api.member_config[:url],
        :query => { :auth_token => @token }.merge(options),
        :headers => @api.headers)

      ErrorHandler.response_code_to_exception_for :room, room_id, response
      wrap_users(response)
    end
459769
def get_rooms(self, sid, namespace):
        """"""
        r = []
        try:
            for room_name, room in six.iteritems(self.rooms[namespace]):
                if room_name is not None and sid in room and room[sid]:
                    r.append(room_name)
        except KeyError:
            pass
        return r
37010
def invitelist(self, channel):
        
        with self.lock:
            self.is_in_channel(channel)

            self.send('MODE %s i' % channel)
            invites = []

            while self.readable():
                msg = self._recv(expected_replies=('346', '347'))

                if msg[0] == '346':
                    invitemask, who, timestamp = msg[2].split()[1:]
                    invites.append((self._from_(invitemask), who, \
                                    self._m_time.localtime(int(timestamp))))
                elif msg[0] == '347':
                    break

            return invites
474109
def list_rooms(self, message):
        """"""
        context = {"rooms": self.available_rooms.values(), }
        self.say(rendered_template("rooms.html", context), message=message, html=True)
366370
def list_user_participants(self, id, registration_status=None):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - id
        """ID"""
        path["id"] = id

        # OPTIONAL - registration_status
        """Limits results to the a given participation status, defaults to "all""""
        if registration_status is not None:
            self._validate_enum(registration_status, ["all", "registered", "registered"])
            params["registration_status"] = registration_status

        self.logger.debug("GET /api/v1/appointment_groups/{id}/users with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("GET", "/api/v1/appointment_groups/{id}/users".format(**path), data=data, params=params, no_data=True)
390619
public ParticipantEntities getChatRoomParticipants(String roomName) {
		return restClient.get("chatrooms/" + roomName + "/participants", ParticipantEntities.class,
				new HashMap<String, String>());
	}
1260003
def close_room(self, room, namespace):
        """"""
        try:
            for sid in self.get_participants(namespace, room):
                self.leave_room(sid, namespace, room)
        except KeyError:
            pass