Gets all the mentions of a channel.
161631
def channels_get_all_user_mentions_by_channel(self, room_id, **kwargs):
        """"""
        return self.__call_api_get('channels.getAllUserMentionsByChannel', roomId=room_id, kwargs=kwargs)
1019882
def GetNeighboringChannels(channel):
    '''
    

    '''

    x = divmod(channel - 1, 4)[1]
    return channel + np.array(range(-x, -x + 4), dtype=int)
1314913
def get_channel(self, name):
        
        name = quote(name, '')
        path = Client.urls['channels_by_name'] % name
        chan = self._call(path, 'GET')
        return chan
1304319
public static Collection<String> getTagNames(Channel channel) {
		Collection<String> tagNames = new HashSet<String>();
		for (Tag tag : channel.getTags()) {
			tagNames.add(tag.getName());
		}
		return tagNames;
	}
1226347
def get_channel(self, name):
        
        r = self.kraken_request('GET', 'channels/' + name)
        return models.Channel.wrap_get_channel(r)
1190518
def highlight_channels(self, l, selected_chan):
        
        for row in range(l.count()):
            item = l.item(row)
            if item.text() in selected_chan:
                item.setSelected(True)
            else:
                item.setSelected(False)
504930
def display_channel(soup):
    
    display_channel = []

    tags = raw_parser.display_channel(soup)
    for tag in tags:
        display_channel.append(node_text(tag))

    return display_channel
905112
def channels(self, pattern=None):
        '''
        '''
        if pattern:
            return self.store.execute('PUBSUB', 'CHANNELS', pattern)
        else:
            return self.store.execute('PUBSUB', 'CHANNELS')
556532
public List<ChannelInformation> listChannels() {
        LinkedList<ChannelInformation> entries = new LinkedList<ChannelInformation>();
        Collection<Broadcaster> broadcasters = BroadcasterFactory.getDefault().lookupAll();
        String name;
        for (Broadcaster broadcaster : broadcasters) {
            if (broadcaster instanceof BounceProxyBroadcaster) {
                name = ((BounceProxyBroadcaster) broadcaster).getName();
            } else {
                name = broadcaster.getClass().getSimpleName();
            }

            Integer cachedSize = null;
            entries.add(new ChannelInformation(name, broadcaster.getAtmosphereResources().size(), cachedSize));
        }

        return entries;
    }
561602
def show_channel(self, channel, owner):
        '''
        '''
        url = '%s/channels/%s/%s' % (self.domain, owner, channel)

        res = self.session.get(url)
        self._check_response(res, [200])
        return res.json()
907782
def _get_initialized_channels_for_service(self, org_id, service_id):
        ''''''
        channels_dict = self._get_initialized_channels_dict_for_service(org_id, service_id)
        return list(channels_dict.values())
532724
public RelationMention getMentions(int i) {
    if (Relation_Type.featOkTst && ((Relation_Type)jcasType).casFeat_mentions == null)
      jcasType.jcas.throwFeatMissing("mentions", "de.julielab.jules.types.ace.Relation");
    jcasType.jcas.checkArrayBounds(jcasType.ll_cas.ll_getRefValue(addr, ((Relation_Type)jcasType).casFeatCode_mentions), i);
    return (RelationMention)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefArrayValue(jcasType.ll_cas.ll_getRefValue(addr, ((Relation_Type)jcasType).casFeatCode_mentions), i)));}
1145891
def get_channels(self):
        
        path = Client.urls['all_channels']
        chans = self._call(path, 'GET')
        return chans
864329
def Channel(channel)
      return channel if channel.is_a?(Channel)
      bot.channel_list.find_ensured(channel)
    end
661917
def get_digital_channels(channel_list):
    """"""
    dig_ids = digital_channel_ids()
    dig_channels = []
    for ln in dig_ids:
        for ch in channel_list:
            if ch.dct['id'] == ln:
                dig_channels.append(ch)
                break
    return dig_channels
1266693
def text_channels(self):
        """"""
        ret = [c for c in self.guild.channels
            if c.category_id == self.id
            and isinstance(c, TextChannel)]
        ret.sort(key=lambda c: (c.position, c.id))
        return ret
103261
def get_channel_info(self):
        
        csv_filename = get_metadata_file_path(channeldir=self.channeldir, filename=self.channelinfo)
        csv_lines = _read_csv_lines(csv_filename)
        dict_reader = csv.DictReader(csv_lines)
        channel_csvs_list =  list(dict_reader)
        channel_csv = channel_csvs_list[0]
        if len(channel_csvs_list) > 1:
            raise ValueError('Found multiple channel rows in ' + self.channelinfo)
        channel_cleaned = _clean_dict(channel_csv)
        channel_info = self._map_channel_row_to_dict(channel_cleaned)
        return channel_info