Get the channel exceptlist.
        Required arguments:
        * channel - Channel of which to get the exceptlist for.
481603
def exceptlist(self, channel):
        
        with self.lock:
            self.is_in_channel(channel)

            self.send('MODE %s e' % channel)
            excepts = []

            while self.readable():
                msg = self._recv(expected_replies=('348', '349'))

                if msg[0] == '348':
                    exceptmask, who, timestamp = msg[2].split()[1:]
                    excepts.append((self._from_(exceptmask), who, \
                                    self._m_time.localtime(int(timestamp))))
                elif msg[0] == '349':
                    break

            return excepts
555290
def channels(self):
        """"""

        # from ProgramConfigElement()
        if hasattr(self, "pce_channels"):
            return self.pce_channels

        conf = getattr(
            self, "extensionChannelConfiguration", self.channelConfiguration)

        if conf == 1:
            if self.psPresentFlag == -1:
                return 0
            elif self.psPresentFlag == 1:
                return 2
            else:
                return 1
        elif conf == 7:
            return 8
        elif conf > 7:
            return 0
        else:
            return conf
1191348
def channels(self):
        
        if self._channels is None:
            self._channels = ChannelList(self._version, service_sid=self._solution['sid'], )
        return self._channels
1013056
function getChannelList(channels) {
  var i
    , channel
    , list = [];
  for(i = 0;i < channels.length;i++) {
    channel = channels[i];
    list.push(channel,
      this._channels[channel] ? this._channels[channel].length : 0);
  }
  return list;
}
1013870
def user_channels(self):
        
        if self._user_channels is None:
            self._user_channels = UserChannelList(
                self._version,
                service_sid=self._solution['service_sid'],
                user_sid=self._solution['sid'],
            )
        return self._user_channels
379289
def channel(self):
        """"""
        if not self._channel:
            self._channel_ref = weakref.ref(self.connection.get_channel())
        return self._channel
890632
def construct_channel(self, *args, **kwargs):
        
        channel = self.get_channel(*args, **kwargs)   # creates ChannelNode from data in self.channel_info
        _build_tree(channel, SAMPLE_TREE)
        raise_for_invalid_channel(channel)

        return channel
1103330
def getChannelColRowList(self, ra, dec, wantZeroOffset=False,
                         allowIllegalReturnValues=True):
        """"""
        try:
            ch = self.pickAChannelList(ra, dec)
        except ValueError:
            logger.warning("WARN: %.7f %.7f not on any channel" % (ra, dec))
            return (0, 0, 0)

        col = np.zeros(len(ch))
        row = np.zeros(len(ch))
        for channel in set(ch):
            mask = (ch == channel)
            col[mask], row[mask] = self.getColRowWithinChannelList(ra[mask], dec[mask], channel, 
                                                        wantZeroOffset, allowIllegalReturnValues)
        return (ch, col, row)
506787
def get_arguments(self, name: str, strip: bool = True) -> List[str]:
        

        # Make sure `get_arguments` isn't accidentally being called with a
        # positional argument that's assumed to be a default (like in
        # `get_argument`.)
        assert isinstance(strip, bool)

        return self._get_arguments(name, self.request.arguments, strip)
905112
def channels(self, pattern=None):
        '''
        '''
        if pattern:
            return self.store.execute('PUBSUB', 'CHANNELS', pattern)
        else:
            return self.store.execute('PUBSUB', 'CHANNELS')
199756
def list_(channel=None):
    '''
    
    '''
    pecl_channel_pat = re.compile('^([^ ]+)[ ]+([^ ]+)[ ]+([^ ]+)')
    pecls = {}
    command = 'list'
    if channel:
        command = '{0} -c {1}'.format(command, _cmd_quote(channel))
    lines = _pecl(command).splitlines()
    lines = (l for l in lines if pecl_channel_pat.match(l))

    for line in lines:
        match = pecl_channel_pat.match(line)
        if match:
            pecls[match.group(1)] = [match.group(2), match.group(3)]

    return pecls
1242594
def __ChannelMaskListToStr(self, channelList):
        
        chan_mask_range = ''
        if isinstance(channelList, list):
            if len(channelList):
                chan_mask_range = ",".join(str(chan) for chan in channelList)
            else:
                print 'empty list'
        else:
            print 'not a valid channel list:', channelList

        return chan_mask_range
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
207499
def _fetch_channels(self):
        """"""
        json = requests.get(self._channels_url).json()
        self._channels = {c['channel']['code']: c['channel']['name']
                          for c in json['channels']}
384013
def _get_next_available_channel_id(self):
        
        for index in compatibility.RANGE(self._last_channel_id or 1,
                                         self.max_allowed_channels + 1):
            if index in self._channels:
                continue
            self._last_channel_id = index
            return index

        if self._last_channel_id:
            self._last_channel_id = None
            return self._get_next_available_channel_id()

        raise AMQPConnectionError(
            'reached the maximum number of channels %d' %
            self.max_allowed_channels)
811776
def get_current(self, channel):
        
        ret = self.ask("I%dO?" % channel)
        if ret[-1] != "A":
            print("ttiQl355tp.get_current() format error", ret)
            return None
        return float(ret[:-1])
209584
def group_channels(self, group):
        

        path = self._path(group)
        return [
            self.objects[p]
            for p in self.objects
            if p.startswith(path + '/')]