GetShelvesetWorkItems.
        Get work items associated with a shelveset.
        :param str shelveset_id: Shelveset's unique ID
        :rtype: [AssociatedWorkItem]
505871
def get_shelveset_work_items(self, shelveset_id):
        
        query_parameters = {}
        if shelveset_id is not None:
            query_parameters['shelvesetId'] = self._serialize.query('shelveset_id', shelveset_id, 'str')
        response = self._send(http_method='GET',
                              location_id='a7a0c1c1-373e-425a-b031-a519474d743d',
                              version='5.0',
                              query_parameters=query_parameters)
        return self._deserialize('[AssociatedWorkItem]', self._unwrap_collection(response))
395513
def add_work_item(self, work_item):
        
        with self._conn:
            self._conn.execute(
                '''
                INSERT INTO work_items
                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                ''', _work_item_to_row(work_item))
40147
def get_catalogs_by_ids(self, *args, **kwargs):
        """"""
        # Implemented from kitosid template for -
        # osid.resource.BinLookupSession.get_bins_by_ids
        catalogs = self._get_provider_session('catalog_lookup_session').get_catalogs_by_ids(*args, **kwargs)
        cat_list = []
        for cat in catalogs:
            cat_list.append(Catalog(self._provider_manager, cat, self._runtime, self._proxy))
        return CatalogList(cat_list)
134825
function collectDependenciesIds(ast) {
	var ids = [];

	visitRequireArgument(ast, function(argument) {
		ids.push(argument.value);
	});

	return ids;
}
410242
def GetItems(self):
        """"""
        url = 'http://min.us/api/GetItems/' + 'm' + self.reader_id
        response = _doget(url)

        self.name = response["GALLERY_TITLE"]

        # To get the item id, we have to take the file name from the URL
        # We also need to get rid of any file extension if there is any
        self.items = [a[16:].split('.')[0] for a in response["ITEMS_GALLERY"]]

        return (self.name, self.items)
1368396
def fetch(workitem_or_fei)

      hfei = Ruote::FlowExpressionId.extract_h(workitem_or_fei)

      @context.storage.get('workitems', to_id(hfei))
    end
200428
def get_all_items_of_invoice(self, invoice_id):
        
        return self._iterate_through_pages(
            get_function=self.get_items_of_invoice_per_page,
            resource=INVOICE_ITEMS,
            **{'invoice_id': invoice_id}
        )
427075
public BoxRequestsCollections.GetCollectionItems getItemsRequest(String id) {
        BoxRequestsCollections.GetCollectionItems request = new BoxRequestsCollections.GetCollectionItems(id, getCollectionItemsUrl(id), mSession);
        return request;
    }
346664
def related(self, collection_id):
        
        url = "/collections/%s/related" % collection_id
        result = self._get(url)
        return CollectionModel.parse_list(result)
207480
def _get_by_id(collection, id):
    '''
    
    '''
    matches = [item for item in collection if item.id == id]
    if not matches:
        raise ValueError('Could not find a matching item')
    elif len(matches) > 1:
        raise ValueError('The id matched {0} items, not 1'.format(len(matches)))
    return matches[0]
25752
def extract_library_properties_from_selected_row(self):
        
        (model, row) = self.view.get_selection().get_selected()
        tree_item_key = model[row][self.ID_STORAGE_ID]
        library_item = model[row][self.ITEM_STORAGE_ID]
        library_path = model[row][self.LIB_PATH_STORAGE_ID]
        if isinstance(library_item, dict):  # sub-tree
            os_path = model[row][self.OS_PATH_STORAGE_ID]
            return os_path, None, None, tree_item_key  # relevant elements of sub-tree
        assert isinstance(library_item, string_types)
        library_os_path = library_item

        library_name = library_os_path.split(os.path.sep)[-1]

        return library_os_path, library_path, library_name, tree_item_key
406908
def get_items(self):
        """"""
        ils = get_item_lookup_session(runtime=self._runtime, proxy=self._proxy)
        ils.use_federated_bank_view()
        items = []
        if self.has_items():
            for idstr in self._my_map['itemIds']:
                items.append(ils.get_item(Id(idstr)))
        return ItemList(items, runtime=self._runtime, proxy=self._proxy)
416156
def get_item(self, item_id):
        
        if self.object_id:
            # reference the current drive_id
            url = self.build_url(
                self._endpoints.get('get_item').format(id=self.object_id,
                                                       item_id=item_id))
        else:
            # we don't know the drive_id so go to the default drive
            url = self.build_url(
                self._endpoints.get('get_item_default').format(item_id=item_id))

        response = self.con.get(url)
        if not response:
            return None

        data = response.json()

        # Everything received from cloud must be passed as self._cloud_data_key
        return self._classifier(data)(parent=self,
                                      **{self._cloud_data_key: data})
988473
def get_item_ids(self):
        """"""
        item_ids = []
        if self.has_items():
            for idstr in self._my_map['itemIds']:
                item_ids.append(idstr)
        return IdList(item_ids)
1043741
def _item_list(profile=None, **connection_args):
    '''
    
    '''
    kstone = auth(profile, **connection_args)
    ret = []
    for item in kstone.items.list():
        ret.append(item.__dict__)
        # ret[item.name] = {
        #         'id': item.id,
        #         'name': item.name,
        #         }
    return ret
396846
def _get_row(self, id):
        """"""
        return {name: d['func'](id) for (name, d) in self._columns.items()}
679039
def get_tasks(self, list_id, completed=False):
        '''  '''
        return tasks_endpoint.get_tasks(self, list_id, completed=completed)