Access the worker_channels

        :returns: twilio.rest.taskrouter.v1.workspace.worker.worker_channel.WorkerChannelList
        :rtype: twilio.rest.taskrouter.v1.workspace.worker.worker_channel.WorkerChannelList
348007
def worker_channels(self):
        
        if self._worker_channels is None:
            self._worker_channels = WorkerChannelList(
                self._version,
                workspace_sid=self._solution['workspace_sid'],
                worker_sid=self._solution['sid'],
            )
        return self._worker_channels
887596
def tasks(self):
        
        if self._tasks is None:
            self._tasks = TaskList(self._version, assistant_sid=self._solution['sid'], )
        return self._tasks
147505
def workspaces(self):
        
        if self._workspaces is None:
            self._workspaces = WorkspaceList(self)
        return self._workspaces
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
428073
def to_dict(self):
        
        return {
            'name': self.name,
            'id': self.id,
            'type': self.type,
            'workflow_id': self.workflow_id,
            'queue': self.queue,
            'start_time': self.start_time,
            'arguments': self.arguments,
            'acknowledged': self.acknowledged,
            'func_name': self.func_name,
            'hostname': self.hostname,
            'worker_name': self.worker_name,
            'worker_pid': self.worker_pid,
            'routing_key': self.routing_key
        }
1326897
def get_worker(*queue_names, **kwargs):
    
    job_class = get_job_class(kwargs.pop('job_class', None))
    queue_class = kwargs.pop('queue_class', None)
    queues = get_queues(*queue_names, **{'job_class': job_class,
                                         'queue_class': queue_class})
    # normalize queue_class to what get_queues returns
    queue_class = queues[0].__class__
    worker_class = get_worker_class(kwargs.pop('worker_class', None))
    return worker_class(queues,
                        connection=queues[0].connection,
                        exception_handlers=get_exception_handlers() or None,
                        job_class=job_class,
                        queue_class=queue_class,
                        **kwargs)
239014
def get_clients(self):
        
        public = self.channels['public']
        private = self.channels['private']
        return dict(public.items() + private.items())
1045523
def get_my_choices_tasks(current_proj):
    

    task_list = []
    tasks = Task.objects.all()
    for task in tasks:
        if task.project == current_proj:
            task_list.append(task)

    task_tuple = []
    counter = 1
    for task in task_list:
        task_tuple.append((counter, task))
        counter = counter + 1
    return task_tuple
1191348
def channels(self):
        
        if self._channels is None:
            self._channels = ChannelList(self._version, service_sid=self._solution['sid'], )
        return self._channels
393130
def _getWorkerCommandList(self):
        """"""
        c = []
        c.extend(self._WorkerCommand_environment())
        c.extend(self._WorkerCommand_launcher())
        c.extend(self._WorkerCommand_options())
        c.extend(self._WorkerCommand_executable())

        return c
222455
def get_channel_listing(self):
        
        teams = self.get('/teams')
        for team in teams:
            if team['name'].lower() == self.team:
                channel_listing = self.get('/teams/' + team['id'] + '/channels')
                return channel_listing
1230948
def messages(self):
        
        if self._messages is None:
            self._messages = MessageList(
                self._version,
                service_sid=self._solution['service_sid'],
                channel_sid=self._solution['sid'],
            )
        return self._messages
357450
def get_task_workers(self, task_name=None, json_obj=None):
        
        if task_name is None and json_obj is None:
            raise ValueError('Either task_name or json_obj should be provided')

        if json_obj is None:
            json_obj = self.get_task_detail2(task_name)
        return WorkerDetail2.extract_from_json(json_obj, client=self._client, parent=self)
930660
def _get_worker_pools_names(worker_pools: list):
        """"""
        return FormattedText().join(
            [
                FormattedText().newline().normal(" - {name}").start_format().bold(name=worker.name).end_format()
                for worker in worker_pools
            ]
        )
493091
def channel_list(self):
        

        if self.current.task_data.get('msg', False):
            if self.current.task_data.get('target_channel_key', False):
                self.current.output['msgbox'] = {'type': 'info',
                                                 "title": _(u"Successful Operation"),
                                                 "msg": self.current.task_data['msg']}
                del self.current.task_data['msg']
            else:
                self.show_warning_messages()

        self.current.task_data['new_channel'] = False
        _form = ChannelListForm(title=_(u'Public Channel List'), help_text=CHANNEL_CHOICE_TEXT)

        for channel in Channel.objects.filter(typ=15):
            owner_name = channel.owner.username
            _form.ChannelList(choice=False, name=channel.name, owner=owner_name, key=channel.key)

        _form.new_channel = fields.Button(_(u"Merge At New Channel"), cmd="create_new_channel")
        _form.existing_channel = fields.Button(_(u"Merge With An Existing Channel"),
                                               cmd="choose_existing_channel")
        _form.find_chosen_channel = fields.Button(_(u"Split Channel"), cmd="find_chosen_channel")
        self.form_out(_form)
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;
}
973501
def get_channel(device, ch_name, channel_dict, loader, resource_dict):
    
    channel_dict = get_bases(channel_dict, loader)

    r_ids = resource_dict.get('channel_ids', {}).get(ch_name, [])
    ids = r_ids if r_ids else channel_dict.get('ids', {})

    can_select = False if channel_dict.get('can_select') == 'False' else True
    channels = Channels(device, ids, can_select)

    update_component(ch_name, channels, channel_dict)

    return channels