Return the list of data items.

        :return: The list of :py:class:`nion.swift.Facade.DataItem` objects.

        .. versionadded:: 1.0

        Scriptable: Yes
322602
def data_items(self) -> typing.List[DataItem]:
        
        return [DataItem(data_item) for data_item in self.__document_model.data_items]
1077559
def get_return_list(self, data):
        
        return_list = []
        lst = self.get_list_key(data, 'return')
        for l in lst:
            name, desc, rtype = l
            if l[2] is None:
                rtype = l[0]
                name = None
                desc = desc.strip()
            return_list.append((name, desc, rtype))

        return return_list
704969
function () {
                    var results = new Array(this.length);
                    for (var i = 0, len = this.length; i < len; i++) {
                        var item = this.getItem(i);
                        if (item) {
                            results[i] = item.data;
                        }
                    }
                    return results;
                }
137365
def get_items(self):
        
        from .layers import Layer

        # no expansion support, just URLs
        results = []
        for url in self.items:
            if '/layers/' in url:
                r = self._client.request('GET', url)
                results.append(self._client.get_manager(Layer).create_from_result(r.json()))
            else:
                raise NotImplementedError("No support for %s" % url)
        return results
989850
def get_traffic_items(self):
        

        traffic = self.get_child_static('traffic')
        return {o.obj_name(): o for o in traffic.get_objects_or_children_by_type('trafficItem')}
826183
def data_item(self) -> DataItem:
        
        display_panel = self.__display_panel
        if not display_panel:
            return None
        data_item = display_panel.data_item
        return DataItem(data_item) if data_item else None
1105139
def items(self):
        ''' 
        '''
        if type(self.transaction['items']['item']) == list:
            return self.transaction['items']['item']
        else:
            return [self.transaction['items']['item'],]
763258
def items(self):
        ''''''
        return [(self.keys[x], self.values[x]) for x in range(len(self.keys))]
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
414912
def list_data(self):
        
        fn = (lambda v: json.loads(decode(v))) if self._use_json else decode
        return map(fn, self._data.values())
182257
def items(self):
        
        temp = self.clone()
        return [(f, getattr(temp, f)) for f in iter(self)]
1346298
def data_object(self):
        
        data_obj = []

        for i in range(0, len(self.data)):
            obj = {
                'value': self.data[i],
                'label': self.labels[i],
                'color': self.colors[i],
            }
            data_obj.append(obj)
        return data_obj
742937
def items(self):
        
        if not self.cursor.rowcount:
            return []

        self.cursor.scroll(0, 'absolute')
        return self.cursor.fetchall()
292817
def list(self, request, *args, **kwargs):
        
        return super(PriceListItemViewSet, self).list(request, *args, **kwargs)
1108009
def folderitems(self):
        
        items = super(AddAnalysesView, self).folderitems(classic=False)
        return items
1090010
def listen_now_items(self):
		

		response = self._call(
			mc_calls.ListenNowGetListenNowItems
		)
		listen_now_item_list = response.body.get('listennow_items', [])

		listen_now_items = defaultdict(list)
		for item in listen_now_item_list:
			type_ = f"{ListenNowItemType(item['type']).name}s"
			listen_now_items[type_].append(item)

		return dict(listen_now_items)
1060498
def viewitems(obj, **kwargs):
    
    func = getattr(obj, "viewitems", None)
    if not func:
        func = obj.items
    return func(**kwargs)