Get a listing of all private rooms with their names and IDs
960056
def get_private_rooms(self, **kwargs):
        
        return GetPrivateRooms(settings=self.settings, **kwargs).call(**kwargs)
1259999
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_raw=False):
        
        uri = "/%s" % self.uri_base
        qs = utils.dict_to_qs(dict(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))
        if qs:
            uri = "%s?%s" % (uri, qs)
        return self._list(uri, return_raw=return_raw)
262524
def get_private_room_history(self, room_id, oldest=None, **kwargs):
        
        return GetPrivateRoomHistory(settings=self.settings, **kwargs).call(
            room_id=room_id,
            oldest=oldest,
            **kwargs
        )
1171818
def get_tenants(tenant_id=None):
    """"""
    if tenant_id == '':
        return []
    session = db.get_reader_session()
    project_ids = set()
    with session.begin():
        for m in [models_v2.Network, models_v2.Port]:
            q = session.query(m.project_id).filter(m.project_id != '')
            if tenant_id:
                q = q.filter(m.project_id == tenant_id)
            project_ids.update(pid[0] for pid in q.distinct())
    return [{'project_id': project_id} for project_id in project_ids]
353412
def list_only():
    """"""
    (cred, providers) = config_read()
    conn_objs = cld.get_conns(cred, providers)
    nodes = cld.get_data(conn_objs, providers)
    node_dict = make_node_dict(nodes, "name")
    table.indx_table(node_dict)
412060
def all(self):
        
        return list(v for id, v in sorted(self._settings.items()))
681299
def get_public_rooms(self, **kwargs):
        
        return GetPublicRooms(settings=self.settings, **kwargs).call(**kwargs)
1010291
def private_names_for(cls, names):
    """"""
    if not isinstance(names, Iterable):
        raise TypeError('names must be an interable')
    return (private_name_for(item, cls) for item in names)
309216
def channels_history(self, room_id, **kwargs):
        """"""
        return self.__call_api_get('channels.history', roomId=room_id, kwargs=kwargs)
1041041
def list(cls,
             l,
             order=None,
             header=None,
             output="table",
             sort_keys=True,
             show_none=""
             ):
        
        d = {}
        count = 0
        for entry in l:
            name = str(count)
            d[name] = entry
            count += 1
        return cls.dict(d,
                        order=order,
                        header=header,
                        sort_keys=sort_keys,
                        output=output,
                        show_none=show_none)
1337360
def marvcli_user_list():
    """"""
    app = create_app()
    for name in db.session.query(User.name).order_by(User.name):
        click.echo(name[0])
560290
def listaccounts(ctx):
    
    t = PrettyTable(["Name", "Key", "Owner", "Active", "Memo"])
    for key in ctx.blockchain.wallet.getPublicKeys(True):
        for account in ctx.blockchain.wallet.getAccountsFromPublicKey(key):
            account = Account(account)
            is_owner = key in [x[0] for x in account["owner"]["key_auths"]]
            is_active = key in [x[0] for x in account["active"]["key_auths"]]
            is_memo = key == account["options"]["memo_key"]
            t.add_row(
                [
                    account["name"],
                    key,
                    "x" if is_owner else "",
                    "x" if is_active else "",
                    "x" if is_memo else "",
                ]
            )
    click.echo(t)
74830
@SuppressWarnings("unchecked")
    @Override
	public <T extends ApiRoom> List<T> getRoomList() {
	    List<Room> sfsRooms = getZone().getRoomList();
        List<T> answer = new ArrayList<>();
        for(Room sfsRoom : sfsRooms) {
            if(sfsRoom.containsProperty(APIKey.ROOM))
                answer.add((T) sfsRoom.getProperty(APIKey.ROOM));
        }
        return answer;
	}
835498
function getAllRooms(robot) {
  // With the IRC adapter, rooms are located
  // in robot.adapter.bot.opt.channels
  var adapter = robot.adapter;
  if (adapter && adapter.bot && adapter.bot.opt
      && adapter.bot.opt.channels) {
    return adapter.bot.opt.channels;
  }
  // Search in env vars
  for (var i in process.env) {
    if (/^HUBOT_.+_ROOMS/i.exec(i) !== null) {
      return process.env[i].split(',');
    }
  }
}
1065437
def get_private_and_public(ctx, username, password, private, preset):
    """"""
    session = SRPClientSession(
        SRPContext(username, password, prime=preset[0], generator=preset[1]),
        private=private)

    click.secho('Client private: %s' % session.private_b64)
    click.secho('Client public: %s' % session.public_b64)
1052139
def entries(self):
        """"""
        passwords = []
        for store in self.stores:
            passwords.extend(store.entries)
        return natsort(passwords, key=lambda e: e.name)
107142
def chat_search(self, room_id, search_text, **kwargs):
        """"""
        return self.__call_api_get('chat.search', roomId=room_id, searchText=search_text, kwargs=kwargs)