Get the the consequence.

        :return: the consequence, list of Item objects
        :rtype: list
345385
def consequence(self):
        
        items = javabridge.get_collection_wrapper(
            javabridge.call(self.jobject, "getConsequence", "()Ljava/util/Collection;"))
        result = []
        for item in items:
            result.append(Item(item))
        return result
581009
def fetch(self):
        
        returnResults = []

        results = self._query.run()
        for result in results:
            if self._join:
                # Because we can tell the models to ignore certian fields,
                # through the protectedItems blacklist, we can nest models by
                # name and have each one act normal and not accidentally store
                # extra data from other models
                item = self._model.fromRawEntry(**result["left"])
                joined = self._join.fromRawEntry(**result["right"])
                item.protectedItems = self._joinedField
                item[self._joinedField] = joined

            else:
                item = self._model.fromRawEntry(**result)

            returnResults.append(item)

        self._documents = returnResults
        return self._documents
1013505
def items(self):
        
        if ver == (2, 7):
            return self.viewitems()
        elif ver == (2, 6):
            return self.iteritems()
        elif ver >= (3, 0):
            return self.items()
454859
def result(self):
        
        self._reactor_check()
        self._event.wait()
        if self._exception:
            six.reraise(self._exception.__class__, self._exception, self._traceback)
        if self._result == NONE_RESULT:
            return None
        else:
            return self._result
111919
def get_item(self):
        """"""
        if self.was_list:
            result = ResultList()
            for item in self:
                if isinstance(item, WorkflowItem):
                    if item.done and not item.error:
                        result.append(item.result)
                    else:
                        # When there's an error or the workflow isn't done yet,
                        # just return the original WorkflowItem so the caller
                        # can inspect its entire state.
                        result.append(item)
                else:
                    result.append(item)
            return result
        else:
            return self[0]
1072734
def get_all_items(self):
        
        return [self._widget.itemText(k) for k in range(self._widget.count())]
223695
def items(self):
		

		L = []
		def aux(node, s):
			s = s + node.char
			if node.output is not nil:
				L.append((s, node.output))

			for child in node.children.values():
				if child is not node:
					aux(child, s)

		aux(self.root, '')
		return iter(L)
660034
def items(self, *args, **kwargs):
        
        if not self.key:
            raise BadRequest('Key is not defined for this tag: %s' % self.tag)
        return self.fetchItems(self.key)
1277620
def answer(self):
        
        if isinstance(self.validator, list):
            return self.validator[0].choice()
        return self.validator.choice()
101818
def items(self, *args, **kwargs):
        
        return self.get_stream()(self.get_object(*args, **kwargs))
637066
def get(self, item):
        
        if item in self:  # noqa
            item = getattr(self, item)
            return item()
1208636
def errors(self):
        
        ret_errs = list()
        errors = self.get('error').get('errors', None) or list()
        assert isinstance(errors, list)
        for err in errors:
            when = parse_datetime(err.get('when', None))
            msg = err.get('message', '')
            e = ErrorEvent(when, msg)
            ret_errs.append(e)
        return ret_errs
12612
def _obj(self):
        
        class Objectives(object):
            def __getitem__(_self, name):
                return self.getObjective(name)

            def __iter__(_self):
                return self.getObjectives()

        return Objectives()
872571
def get_feature_penalty(self):
        
        if self.feature_penalty is None:
            self.feature_penalty = self.get_field('feature_penalty')
        return self.feature_penalty
677835
def constraints(self):
        
        try:
            return self._constraints
        except AttributeError:
            self._constraints = ConstraintDict()
            return self._constraints
792351
def get_bounds(self):
        
        bounds = self._get_self_bounds()

        for child in self._children.values():
            child_bounds = child.get_bounds()
            bounds = [
                [
                    none_min(bounds[0][0], child_bounds[0][0]),
                    none_min(bounds[0][1], child_bounds[0][1]),
                    ],
                [
                    none_max(bounds[1][0], child_bounds[1][0]),
                    none_max(bounds[1][1], child_bounds[1][1]),
                    ],
                ]
        return bounds
383503
def result(self):
        
        ret = self.get('result')
        if ret is not None:
            ret = u(ret)
        return ret