List[:class:`TextChannel`]: A list of text channels that belongs to this guild.

        This is sorted by the position and are in UI order from top to bottom.
556052
def text_channels(self):
        
        r = [ch for ch in self._channels.values() if isinstance(ch, TextChannel)]
        r.sort(key=lambda c: (c.position, c.id))
        return r
964909
public List<ChannelInfo> getChannels() {
    final URI uri = uriWithPath("./channels/");
    return Arrays.asList(this.rt.getForObject(uri, ChannelInfo[].class));
  }
129746
def SearchList(items, message="Select an item:", title='FontParts'):
    
    return dispatcher["SearchList"](items=items, message=message, title=title)
1324284
def channels(self):
        
        def comparator(channel):
            return (not isinstance(channel, TextChannel), channel.position)

        ret = [c for c in self.guild.channels if c.category_id == self.id]
        ret.sort(key=comparator)
        return ret
529194
def get_subscriptions_channel(self, search_channel):
        
        data = self.get_clients()
        clients = []
        for client in data:
            if 'subscriptions' in client:
                if isinstance(client['subscriptions'], list):
                    if search_channel in client['subscriptions']:
                        clients.append(client['name'])
                else:
                    if search_channel == client['subscriptions']:
                        clients.append(client['name'])
        return clients
1191348
def channels(self):
        
        if self._channels is None:
            self._channels = ChannelList(self._version, service_sid=self._solution['sid'], )
        return self._channels
269598
def list_all(self, 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_all(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)
276544
def get_channels(self):
        
        selectedItems = self.idx_chan.selectedItems()
        selected_chan = [x.text().split('—')[0] for x in selectedItems]
        chan_in_order = []
        for chan in self.one_grp['chan_to_plot']:
            if chan in selected_chan:
                chan_in_order.append(chan)

        return chan_in_order
362536
def cli_guilds(world, tibiadata, json):
    """"""
    world = " ".join(world)
    guilds = _fetch_and_parse(ListedGuild.get_world_list_url, ListedGuild.list_from_content,
                              ListedGuild.get_world_list_url_tibiadata, ListedGuild.list_from_tibiadata,
                              tibiadata, world)
    if json and guilds:
        import json as _json
        print(_json.dumps(guilds, default=dict, indent=2))
        return
    print(get_guilds_string(guilds))
1071730
def raw_channel_mentions(self):
        
        return [int(x) for x in re.findall(r'<#([0-9]+)>', self.content)]
905112
def channels(self, pattern=None):
        '''
        '''
        if pattern:
            return self.store.execute('PUBSUB', 'CHANNELS', pattern)
        else:
            return self.store.execute('PUBSUB', 'CHANNELS')
64757
def _parse_guild_members(self, parsed_content):
        
        member_rows = parsed_content.find_all("tr", {'bgcolor': ["#D4C0A1", "#F1E0C6"]})
        previous_rank = {}
        for row in member_rows:
            columns = row.find_all('td')
            values = tuple(c.text.replace("\u00a0", " ") for c in columns)
            if len(columns) == COLS_GUILD_MEMBER:
                self._parse_current_member(previous_rank, values)
            if len(columns) == COLS_INVITED_MEMBER:
                self._parse_invited_member(values)
718261
def list_fonts():
    
    vals = _list_fonts()
    for font in _vispy_fonts:
        vals += [font] if font not in vals else []
    vals = sorted(vals, key=lambda s: s.lower())
    return vals
526519
def buffer_list(editor):
    
    def handler():
        wa = editor.window_arrangement
        for info in wa.list_open_buffers():
            char = '%' if info.is_active else ''
            eb = info.editor_buffer
            print(' %3i %-2s %-20s  line %i' % (
                  info.index, char, eb.location, (eb.buffer.document.cursor_position_row + 1)))
        six.moves.input('\nPress ENTER to continue...')
    run_in_terminal(handler)
310339
def ordered_list(text_array):
    
    text_list = []
    for number, item in enumerate(text_array):
        text_list.append(
            (esc_format(number + 1) + ".").ljust(3) + " " + esc_format(item)
        )
    return "\n".join(text_list)
209584
def group_channels(self, group):
        

        path = self._path(group)
        return [
            self.objects[p]
            for p in self.objects
            if p.startswith(path + '/')]
772873
def voice_channels(self):
        
        r = [ch for ch in self._channels.values() if isinstance(ch, VoiceChannel)]
        r.sort(key=lambda c: (c.position, c.id))
        return r