:class:`Feed <pypump.models.feed.Feed>` of collection members.
490541
def members(self):
        
        if self._members is None:
            self._members = Feed(self.links["members"], pypump=self._pump)
        return self._members
45316
def feed(self, data):
        
        """
        self.rawdata = self.rawdata + data
        self.goahead(0)
1206957
def get_data_feed(self, train_mode=True, qname_in='input', qname_out='output', input_mapping=None):
    """"""
    return TFNode.DataFeed(self.mgr, train_mode, qname_in, qname_out, input_mapping)
569065
def get_instances(self):
        
        if self._update_members: self.update()
        return iter(sorted(self.members.iteritems()))
833668
def feed(self, from_date=None, from_offset=None, category=None,
             latest_items=None, arthur_items=None, filter_classified=None):
        

        if self.fetch_archive:
            items = self.perceval_backend.fetch_from_archive()
            self.feed_items(items)
            return
        elif arthur_items:
            items = arthur_items
            self.feed_items(items)
            return

        if from_date and from_offset:
            raise RuntimeError("Can't not feed using from_date and from_offset.")

        # We need to filter by repository to support several repositories
        # in the same raw index
        filters_ = [get_repository_filter(self.perceval_backend,
                    self.get_connector_name())]

        # Check if backend supports from_date
        signature = inspect.signature(self.perceval_backend.fetch)

        last_update = None
        if 'from_date' in signature.parameters:
            if from_date:
                last_update = from_date
            else:
                self.last_update = self.get_last_update_from_es(filters_=filters_)
                last_update = self.last_update

            logger.info("Incremental from: %s", last_update)

        offset = None
        if 'offset' in signature.parameters:
            if from_offset:
                offset = from_offset
            else:
                offset = self.elastic.get_last_offset("offset", filters_=filters_)

            if offset is not None:
                logger.info("Incremental from: %i offset", offset)
            else:
                logger.info("Not incremental")

        params = {}
        # category and filter_classified params are shared
        # by all Perceval backends
        if category is not None:
            params['category'] = category
        if filter_classified is not None:
            params['filter_classified'] = filter_classified

        # latest items, from_date and offset cannot be used together,
        # thus, the params dictionary is filled with the param available
        # and Perceval is executed
        if latest_items:
            params['latest_items'] = latest_items
            items = self.perceval_backend.fetch(**params)
        elif last_update:
            last_update = last_update.replace(tzinfo=None)
            params['from_date'] = last_update
            items = self.perceval_backend.fetch(**params)
        elif offset is not None:
            params['offset'] = offset
            items = self.perceval_backend.fetch(**params)
        else:
            items = self.perceval_backend.fetch(**params)

        self.feed_items(items)
        self.update_items()
1259960
def groups_with_resources(cls, instance):
        
        return instance.groups_dynamic.options(
            sa.orm.eagerload(cls.models_proxy.Group.resources)
        )
537481
def list(showgroups):
    

    ecode = 0
    try:
        result = {}
        subscribed = {}
        available = {}
        unavailable = {}
        current_user_data = contexts['anchore_auth']['user_info']
        feedmeta = anchore_feeds.load_anchore_feedmeta()

        for feed in feedmeta.keys():
            if feedmeta[feed]['subscribed']:
                subscribed[feed] = {}
                subscribed[feed]['description'] = feedmeta[feed]['description']
                if showgroups:
                    subscribed[feed]['groups'] = feedmeta[feed]['groups'].keys()

            else:
                if current_user_data:
                    tier = int(current_user_data['tier'])
                else:
                    tier = 0

                if int(feedmeta[feed]['access_tier']) > tier:
                    collection = unavailable
                else:
                    collection = available

                collection[feed] = {}

                collection[feed]['description'] = feedmeta[feed]['description']
                if showgroups and collection == available:
                    collection[feed]['groups'] = feedmeta[feed]['groups'].keys()

        if available:
            result['Available'] = available
        if subscribed:
            result['Subscribed'] = subscribed
        if unavailable:
            result['Unavailable/Insufficient Access Tier'] = unavailable

        anchore_print(result, do_formatting=True)
    except Exception as err:
        anchore_print_err('operation failed')
        ecode = 1

    sys.exit(ecode)
605646
def feed(self, count, total=1):
        
        self._tot += total
        self._cnt += count
133686
def get_sibling(self, feed_id, sibling_type):
        
        if sibling_type == 'previous':
            query = self.session.query(self.feed_model).filter(self.feed_model.id < feed_id)
            order_clause = desc(self.feed_model.id)
        elif sibling_type == 'next':
            query = self.session.query(self.feed_model).filter(self.feed_model.id > feed_id)
            order_clause = self.feed_model.id
        else:
            raise Exception('Unhandled sibling relation type')  # pragma no cover
        if query.count() > 0:
            return query.order_by(order_clause).first()
        else:
            return None
875308
def info(args):
    
    session = c.Session(args)
    if "all" in args["names"]:
        feeds = session.list_feeds()
    else:
        feeds = args["names"]
    for feed in feeds:
        aux.pretty_print(session, feed)
286420
def host_members(self):
        '''
        '''
        host = self.host()
        if host is None:
            return
        for member, full_member in host.members_objects:
            yield full_member
631262
def members(self):
        
        if self._members is None:
            self.assert_bind_client()
            self._members = self.bind_client.get_club_members(self.id)
        return self._members
196440
def zip(self, *items):
        
        return self.__class__(list(zip(self.items, *items)))
603446
def members(self):
        
        res = [self]
        for c in list(self.children.values()):
            res.extend(c.members)
        return res
771464
def get_filtered_feed(self, feed_filter):
        
        assert isinstance(feed_filter, (UnreadFilter, FollowingFilter,
                                        FolderFilter))
        return self._rpc.filter_feed(**feed_filter.to_kwargs())
301955
def get_all_chatter_feeds_without_attachments(object_id, object_type, binding, directory_name, limit=100)
      return get_all_chatter_feeds_with_attachments(object_id, object_type, binding, directory_name, limit, false, nil)
    end
262310
def parents(self) -> List["Collection"]:
        
        p = self.parent
        parents = []
        while p is not None:
            parents.append(p)
            p = p.parent
        return parents