python.channel_mapping Namespace Reference

Functions
	convert_channel (name, want_id=True, channel_mapping=channel_mapping)
	list_to_channelselection (list_, convert_channel=convert_channel, as_list=False)
	make_channelselection (cs, mapping=None)
	get_channel_ids_names (folder)

Variables
dict	channel_mapping = {}
list	channel_names = []
dict	cm_reversed = {value: key for key, value in channel_mapping.items()}

Function Documentation

convert_channel()

python.channel_mapping.convert_channel	(		name,
			want_id = True,
			channel_mapping = channel_mapping )

Given a channel, return a name detector or an integer (depending on want_id)

Definition at line 21 of file channel_mapping.py.

def convert_channel(name, want_id=True, channel_mapping=channel_mapping):
    """
    Given a channel, return a name detector or an integer (depending on want_id)
    """
    from builtins import int
    if isinstance(name, int):
        if name not in channel_mapping:
            raise RuntimeError("ChannelID %r is not in channel_mapping" % name)
        return name if want_id else channel_mapping[name]
        
    elif isinstance(name, str):
        if name not in channel_mapping:
            raise RuntimeError("ChannelID %r is not in channel_mapping" % name)
        return name if not want_id else channel_mapping[name]
        
    raise RuntimeError("I don't know how to convert %r into "
                         "a ChannelSelection" % name)
 

get_channel_ids_names()

python.channel_mapping.get_channel_ids_names

(

folder

)

Given a `folder` name, retrieve a list of channel ids, names and return a
dictionary which will translate in either direction.

Definition at line 99 of file channel_mapping.py.

def get_channel_ids_names(folder):
    """
    Given a `folder` name, retrieve a list of channel ids, names and return a
    dictionary which will translate in either direction.
    """
    channel_ids = list(folder.listChannels())
    channel_names = folder.listChannelsWithNames()
    channel_names = list(map(channel_names.__getitem__, channel_ids))
    channel_dict = dict(list(zip(channel_ids,   channel_names))
                       +list(zip(channel_names, channel_ids)))
    return channel_ids, channel_names, channel_dict
 

list_to_channelselection()

python.channel_mapping.list_to_channelselection	(		list_,
			convert_channel = convert_channel,
			as_list = False )

Given a list, return a channelselection.

Does the hard work of merging together adjacent channel numbers. Will also
convert channel names to numbers (if the folder is using DQ channels,
otherwise will give an incorrect result or fail to convert the strings to
channelids.)

Definition at line 39 of file channel_mapping.py.

                             as_list=False):
    """
    Given a list, return a channelselection.
    
    Does the hard work of merging together adjacent channel numbers. Will also
    convert channel names to numbers (if the folder is using DQ channels,
    otherwise will give an incorrect result or fail to convert the strings to
    channelids.)
    """
    from PyCool import cool
    if not list_ and as_list: return []
    if not list_: return cool.ChannelSelection()
    if set(map(type, list_)) != set([int]) and convert_channel:
        list_ = map(convert_channel, list_)
    
    list_.sort()
    
    start = None
    ranges = []
    for this, next in zip(list_, list_[1:] + [-1]):
        if start is None:
            start = this
        if next - this != 1:
            ranges.append((start, this))
            start = None
    
    if as_list:
        return ranges
    
    assert len(ranges) < 50, (
        "Cool has a 50 channel selection limit (%s selected)" % ranges)
    
    selection = cool.ChannelSelection(*ranges.pop(0))
    for start, end in ranges:
        selection.addRange(start, end)
        
    return selection
    

make_channelselection()

python.channel_mapping.make_channelselection	(		cs,
			mapping = None )

Helper function which can convert a channel id, name, or list of either into
a cool.ChannelSelection. Includes protections for invalid channels.

Definition at line 78 of file channel_mapping.py.

def make_channelselection(cs, mapping=None):
    """
    Helper function which can convert a channel id, name, or list of either into
    a cool.ChannelSelection. Includes protections for invalid channels.
    """
    from PyCool import cool
    if mapping is None:
        mapping = channel_mapping
    if cs is None or cs == []:
        return cool.ChannelSelection()
    elif isinstance(cs, (int, str)):
        channel_id = convert_channel(cs, channel_mapping=mapping)
        return cool.ChannelSelection(channel_id, channel_id)
    elif hasattr(cs, "__iter__"):
        cc = lambda cs: convert_channel(cs, channel_mapping=mapping)
        return list_to_channelselection(cs, convert_channel=cc)
    elif isinstance(cs, cool.ChannelSelection):
        return cs
    raise RuntimeError("I don't know how to convert %r into a "
                         "ChannelSelection" % cs)
 

Variable Documentation

channel_mapping

python.channel_mapping.channel_mapping = {}

Definition at line 11 of file channel_mapping.py.

channel_names

dict python.channel_mapping.channel_names = []

Definition at line 12 of file channel_mapping.py.

cm_reversed

dict python.channel_mapping.cm_reversed = {value: key for key, value in channel_mapping.items()}

Definition at line 18 of file channel_mapping.py.