Get the available channels from the header information
327659
def get_available_channels(header):
    """"""

    chlist_str = header['15_SECONDARY_PRODUCT_HEADER'][
        'SelectedBandIDs']['Value']
    retv = {}

    for idx, char in zip(range(12), chlist_str):
        retv[CHANNEL_NAMES[idx + 1]] = (char == 'X')

    return retv
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
790254
def available_streams():
    """"""
    sds = kp.db.StreamDS()
    print("Available streams: ")
    print(', '.join(sorted(sds.streams)))
1354072
def update_channel(self, channel):
        

        data = {'channels': channel}
        return super(ApiInterfaceRequest, self).put('api/v3/channel/', data)
239014
def get_clients(self):
        
        public = self.channels['public']
        private = self.channels['private']
        return dict(public.items() + private.items())
990787
def channel_parameters(parameter_prefix, channel_names, configuration_entry):
    

    if configuration_entry in (True, False):
        return ([], [parameter_prefix])[configuration_entry]

    parameters = []
    if isinstance(configuration_entry, dict):
        for name in set(channel_names).intersection(configuration_entry):
            if configuration_entry[name] is True:
                parameters.append(parameter_prefix + "_" + name)
    else:
        raise TypeError("incorrect type")

    return parameters
32094
def output_channels(self):
    """"""
    if callable(self._output_channels):
      self._output_channels = self._output_channels()
    # Channel must be integer.
    self._output_channels = int(self._output_channels)
    return self._output_channels
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
693801
def get_ebuio_headers(request):
    """"""

    retour = {}

    for (key, value) in request.headers:
        if key.startswith('X-Plugit-'):
            key = key[9:]

            retour[key] = value

    return retour
1004269
def select_channel(self, channel):
        
        for i in str(channel):
            key = int(i) + 0xe300
            self.send_key(key)
1216327
def channel(self):
        
        guild = self.guild
        return guild and guild.get_channel(self.channel_id)
379289
def channel(self):
        """"""
        if not self._channel:
            self._channel_ref = weakref.ref(self.connection.get_channel())
        return self._channel
309216
def channels_history(self, room_id, **kwargs):
        """"""
        return self.__call_api_get('channels.history', roomId=room_id, kwargs=kwargs)
1122929
def channels(self):
        """"""
        if hasattr(self.mgfile.info, 'channels'):
            return self.mgfile.info.channels
        return 0
1043775
def channels(self):
        
        resp = self._rtm_client.get('v1/current_team.channels')
        if resp.is_fail():
            raise RTMServiceError(
                'Failed to get channels of current team',
                resp
            )
        return resp.data['result']
982331
def cmd_lsch(self):
        
        names = list(self.fv.get_channel_names())
        names.sort()

        if len(names) == 0:
            self.log("No channels")
            return

        res = []
        cur_ch = self.fv.get_channel_info()
        for name in names:
            if (cur_ch is not None) and (cur_ch.name == name):
                res.append("=>%s" % (name))
            else:
                res.append("  %s" % (name))

        self.log("\n".join(res))
1226347
def get_channel(self, name):
        
        r = self.kraken_request('GET', 'channels/' + name)
        return models.Channel.wrap_get_channel(r)