Start the threaded retrieval of items. Populates the 
        ``items`` list with :class:`Item <boto.sdb.item.Item>` objects.
7973
def run(self):
        
        for item_name in self.item_names:
            item = self.conn.get_attributes(self.domain_name, item_name)
            self.items.append(item)
200191
def _put_many(self, items):
        ''' 
        '''
        for item in items:
            if not isinstance(item, self._item_class):
                raise RuntimeError('Items mismatch for %s and %s' % (self._item_class, type(item)))
            self._put_one(item)
486636
def load(self, items):
        

        for k, vals in items:
            self[k] = "".join(vals)
1094972
def get_items(start_num, num_items):
    
    result = []
    for i in range(start_num, start_num+num_items):
        result.append({'pk': {'S': 'item{0}'.format(i)}})
    return result
376964
def start(self):
        """"""
        LOG.info('Listing options...')
        with indicator.Spinner(**self.indicator_options):
            objects_list = self._list_contents()
            if not objects_list:
                return

        # Index items
        self._index_objects(objects_list=objects_list)
        # Create the underlying structure
        self._make_directory_structure()

        # Download everything
        LOG.debug('Download Items: %s', self.download_items)
        self._multi_processor(
            self._get,
            items=[i for i in self.download_items.values() for i in i]
        )
367581
def sync_list_items(self):
        
        if self._sync_list_items is None:
            self._sync_list_items = SyncListItemList(
                self._version,
                service_sid=self._solution['service_sid'],
                list_sid=self._solution['sid'],
            )
        return self._sync_list_items
1040998
def addRecordsFromThread(self, records):
        
        label_mapper    = self.labelMapper()
        icon_mapper     = self.iconMapper()
        
        tree = None
        if self.showTreePopup():
            tree = self.treePopupWidget()
        
        # add the items to the list
        start = self.count()
        
        # update the item information
        blocked = self.signalsBlocked()
        self.blockSignals(True)
        for i, record in enumerate(records):
            index = start + i
            self.addItem(label_mapper(record))
            self.setItemData(index, wrapVariant(record), Qt.UserRole)
            
            if icon_mapper:
                self.setItemIcon(index, icon_mapper(record))
            
            if record == self._currentRecord:
                self.setCurrentIndex(self.count() - 1)
            
            if tree:
                XOrbRecordItem(tree, record)
        self.blockSignals(blocked)
1221231
def start(self, nb_threads: int) -> None:
        
        if self._active_threads:
            raise Exception('Threads already started.')

        # Create thread pool
        for _ in range(nb_threads):
            worker = threading.Thread(
                target=_work_function,
                args=(self._job_q, self._result_q, self._error_q))
            worker.start()
            self._thread_list.append(worker)
            self._active_threads += 1

        # Put sentinels to let the threads know when there's no more jobs
        for _ in self._thread_list:
            self._job_q.put(_ThreadPoolSentinel())
994105
private function startList()
    {
        $list = new ArrayObject();

        if (null === ($key = $this->tokens->getKey())) {
            $this->current[] = $list;
        } else {
            $this->current[$key] = $list;
        }

        $this->stack[] = $this->current;
        $this->current = $list;
    }
196440
def zip(self, *items):
        
        return self.__class__(list(zip(self.items, *items)))
274520
async def items(self):
        

        accumulator = Accumulator()
        for graft in load_grafts():
            accumulator.spawn(graft())
        response = await accumulator.join()
        return response.items()
567019
def new(self, item_lists, processor:PreProcessor=None, **kwargs)->'ItemList':
        ""
        processor = ifnone(processor, self.processor)
        copy_d = {o:getattr(self,o) for o in self.copy_new}
        kwargs = {**copy_d, **kwargs}
        return self.__class__(item_lists, processor=processor, **kwargs)
778310
def list_items(queue):
    '''
    
    '''
    itemstuple = _list_items(queue)
    items = [item[0] for item in itemstuple]
    return items
1183990
def popitemlist(self):
        """"""
        try:
            return dict.popitem(self)
        except KeyError, e:
            raise BadRequestKeyError(str(e))
473254
def store_many(self, items):
        
        with self.walrus.atomic():
            for item in items:
                self.store(*item)
111147
def add(self, *items):
        
        for item in items:
            self.unsorted.append(item)
            key = item[0]
            self.index[key] = item
        return self
1125230
def items(self):
        
        if self.matcher:
            for item in self._fetch_items():
                if self.matcher.match(item):
                    yield item
        else:
            for item in self._fetch_items():
                yield item