python类get_multi()的实例源码

def get_count(name):
    """Retrieve the value for a given sharded counter.

    Args:
        name: The name of the counter.

    Returns:
        Integer; the cumulative count of all sharded counters for the given
            counter name.
    """
    total = memcache.get(name)
    if total is None:
        total = 0
        all_keys = GeneralCounterShardConfig.all_keys(name)
        for counter in ndb.get_multi(all_keys):
            if counter is not None:
                total += counter.count
        memcache.add(name, total, 60)
    return total

def list(self, d):
        days = self.request.get_range('days', default=4)
        before_date = datetime.today()
        _before_date = self.request.get('before_date')
        if _before_date:
            before_date = tools.fromISODate(_before_date)
        cursor = before_date
        journal_keys = []
        for i in range(days):
            iso_date = tools.iso_date(cursor)
            journal_keys.append(ndb.Key('MiniJournal', iso_date, parent=self.user.key))
            cursor -= timedelta(days=1)
        journals = ndb.get_multi(journal_keys)
        self.set_response({
            'journals': [j.json() for j in journals if j]
            }, success=True)

def Search(cls, user, term, limit=20):
        kind = cls._get_kind()
        index = User.get_search_index(user.key, kind)
        message = None
        success = False
        items = []
        try:
            query_options = search.QueryOptions(limit=limit)
            query = search.Query(query_string=term, options=query_options)
            search_results = index.search(query)
        except Exception, e:
            logging.debug("Error in search api: %s" % e)
            message = str(e)
        else:
            keys = [ndb.Key(kind, sd.doc_id, parent=user.key) for sd in search_results.results if sd]
            items = ndb.get_multi(keys)
            success = True
        return (success, message, items)

def Range(user, habits, since_date, until_date=None):
        '''
        Fetch habit days for specified habits in date range

        Args:
            habits (list of Habit() objects)
            ...

        Returns:
            list: HabitDay() ordered sequentially

        '''
        today = datetime.today()
        if not until_date:
            until_date = today
        cursor = since_date
        ids = []
        while cursor <= until_date:
            for h in habits:
                ids.append(ndb.Key('HabitDay', HabitDay.ID(h, cursor), parent=user.key))
            cursor += timedelta(days=1)
        if ids:
            return [hd for hd in ndb.get_multi(ids) if hd]
        return []

def fetchEntities(self):
        return dict(zip(self.to_fetch, ndb.get_multi(self.to_fetch)))

def get(self):
    crash_keys = util.param('crash_keys', list)
    if crash_keys:
      crash_db_keys = [ndb.Key(urlsafe=k) for k in crash_keys]
      crash_dbs = ndb.get_multi(crash_db_keys)
      return helpers.make_response(crash_dbs, model.crash.FIELDS)

    crash_dbs, crash_cursor = model.Crash.get_dbs()
    return helpers.make_response(crash_dbs, model.Crash.FIELDS, crash_cursor)

def get(self):
    project_keys = util.param('project_keys', list)
    if project_keys:
      project_db_keys = [ndb.Key(urlsafe=k) for k in project_keys]
      project_dbs = ndb.get_multi(project_db_keys)
      return helpers.make_response(project_dbs, model.project.FIELDS)

    project_dbs, project_cursor = model.Project.get_dbs()
    return helpers.make_response(project_dbs, model.Project.FIELDS, project_cursor)

def get(self):
    user_keys = util.param('user_keys', list)
    if user_keys:
      user_db_keys = [ndb.Key(urlsafe=k) for k in user_keys]
      user_dbs = ndb.get_multi(user_db_keys)
      return helpers.make_response(user_dbs, model.User.FIELDS)

    user_dbs, cursors = model.User.get_dbs(prev_cursor=True)
    return helpers.make_response(user_dbs, model.User.FIELDS, cursors)

def merge_user_dbs(user_db, deprecated_keys):
  # TODO: Merge possible user data before handling deprecated users
  deprecated_dbs = ndb.get_multi(deprecated_keys)
  for deprecated_db in deprecated_dbs:
    deprecated_db.auth_ids = []
    deprecated_db.active = False
    deprecated_db.verified = False
    if not deprecated_db.username.startswith('_'):
      deprecated_db.username = '_%s' % deprecated_db.username
  ndb.put_multi(deprecated_dbs)

def get(self):
    person_keys = util.param('person_keys', list)
    if person_keys:
      person_db_keys = [ndb.Key(urlsafe=k) for k in person_keys]
      person_dbs = ndb.get_multi(person_db_keys)
      return helpers.make_response(person_dbs, model.person.FIELDS)

    person_dbs, person_cursor = model.Person.get_dbs()
    return helpers.make_response(person_dbs, model.Person.FIELDS, person_cursor)

def get(self):
    user_keys = util.param('user_keys', list)
    if user_keys:
      user_db_keys = [ndb.Key(urlsafe=k) for k in user_keys]
      user_dbs = ndb.get_multi(user_db_keys)
      return helpers.make_response(user_dbs, model.User.FIELDS)

    user_dbs, cursors = model.User.get_dbs(prev_cursor=True)
    return helpers.make_response(user_dbs, model.User.FIELDS, cursors)

def merge_user_dbs(user_db, deprecated_keys):
  # TODO: Merge possible user data before handling deprecated users
  deprecated_dbs = ndb.get_multi(deprecated_keys)
  for deprecated_db in deprecated_dbs:
    deprecated_db.auth_ids = []
    deprecated_db.active = False
    deprecated_db.verified = False
    if not deprecated_db.username.startswith('_'):
      deprecated_db.username = '_%s' % deprecated_db.username
  ndb.put_multi(deprecated_dbs)

def get(self):
    post_keys = util.param('post_keys', list)
    if post_keys:
      post_db_keys = [ndb.Key(urlsafe=k) for k in post_keys]
      post_dbs = ndb.get_multi(post_db_keys)
      return helpers.make_response(post_dbs, model.post.FIELDS)

    post_dbs, post_cursor = model.Post.get_dbs()
    return helpers.make_response(post_dbs, model.Post.FIELDS, post_cursor)

def get(self):
    vote_keys = util.param('vote_keys', list)
    if vote_keys:
      vote_db_keys = [ndb.Key(urlsafe=k) for k in vote_keys]
      vote_dbs = ndb.get_multi(vote_db_keys)
      return helpers.make_response(vote_dbs, model.vote.FIELDS)

    vote_dbs, vote_cursor = model.Vote.get_dbs()
    return helpers.make_response(vote_dbs, model.Vote.FIELDS, vote_cursor)

def get(self):
    comment_keys = util.param('comment_keys', list)
    if comment_keys:
      comment_db_keys = [ndb.Key(urlsafe=k) for k in comment_keys]
      comment_dbs = ndb.get_multi(comment_db_keys)
      return helpers.make_response(comment_dbs, model.comment.FIELDS)

    comment_dbs, comment_cursor = model.Comment.get_dbs()
    return helpers.make_response(comment_dbs, model.Comment.FIELDS, comment_cursor)

def get(self):
    language_keys = util.param('language_keys', list)
    if language_keys:
      language_db_keys = [ndb.Key(urlsafe=k) for k in language_keys]
      language_dbs = ndb.get_multi(language_db_keys)
      return helpers.make_response(language_dbs, model.language.FIELDS)

    language_dbs, language_cursor = model.Language.get_dbs()
    return helpers.make_response(language_dbs, model.Language.FIELDS, language_cursor)

def get(self):
    user_keys = util.param('user_keys', list)
    if user_keys:
      user_db_keys = [ndb.Key(urlsafe=k) for k in user_keys]
      user_dbs = ndb.get_multi(user_db_keys)
      return helpers.make_response(user_dbs, model.User.FIELDS)

    user_dbs, cursors = model.User.get_dbs(prev_cursor=True)
    return helpers.make_response(user_dbs, model.User.FIELDS, cursors)

def merge_user_dbs(user_db, deprecated_keys):
  # TODO: Merge possible user data before handling deprecated users
  deprecated_dbs = ndb.get_multi(deprecated_keys)
  for deprecated_db in deprecated_dbs:
    deprecated_db.auth_ids = []
    deprecated_db.active = False
    deprecated_db.verified = False
    if not deprecated_db.username.startswith('_'):
      deprecated_db.username = '_%s' % deprecated_db.username
  ndb.put_multi(deprecated_dbs)

def remove_preferences(user, updated_preferences, subscription_key):
    """
    Parameters
    ----------
    user - ndb.User
    preferences - {SubscriptionDateTime.key:Boolean}
    subscription_key - ndb.Key

    Returns
    -------
    set(SubscriptionDateTime.Key)

    """
    removed = set()
    for preference in ndb.get_multi(user.subscription_preferences):
        if preference.subscription == subscription_key:
            if not updated_preferences.get(preference.preference, True):
                index = user.subscription_preferences.index(preference.key)
                removed.add(user.subscription_preferences[index])
                del user.subscription_preferences[index]
                user.put()

    for record in removed:
        record.delete()

    return removed

def operate_on_multiple_keys_at_once(list_of_entities):
    list_of_keys = ndb.put_multi(list_of_entities)
    list_of_entities = ndb.get_multi(list_of_keys)
    ndb.delete_multi(list_of_keys)

def get_cart_plus_offers(acct):
    cart = CartItem.query(CartItem.account == acct.key).fetch()
    offers = SpecialOffer.query().fetch(10)
    ndb.get_multi([item.inventory for item in cart] +
                  [offer.inventory for offer in offers])
    return cart, offers

def get_cart_plus_offers_async(acct):
    cart_future = CartItem.query(CartItem.account == acct.key).fetch_async()
    offers_future = SpecialOffer.query().fetch_async(10)
    cart = cart_future.get_result()
    offers = offers_future.get_result()
    ndb.get_multi([item.inventory for item in cart] +
                  [offer.inventory for offer in offers])
    return cart, offers


# [START cart_offers_tasklets]

def companies(self):
        rels = ContactCompany.query(ancestor=self.key.parent()).filter(
            ContactCompany.contact == self.key)
        keys = [rel.company for rel in rels]
        return ndb.get_multi(keys)

def main():
    user = users.get_current_user()
    if not user:
        return flask.redirect(users.create_login_url(flask.request.path))

    if flask.request.method == 'POST':
        util.csrf_protect()
        tab_ids = flask.request.values.getlist('tab_id')
        keys = [ndb.Key(Session, tab_id) for tab_id in tab_ids]
        if 'delete' in flask.request.values:
            if not all(s and s.user_id == user.user_id() for s in ndb.get_multi(keys)):
                return 'Not authorized to delete some sessions', 403
            ndb.delete_multi(keys)
        elif 'share' in flask.request.values:
            for key in keys:
                session = key.get()
                if session and session.user_id == user.user_id():
                    session.shared = True
                    session.put()
        else:
            return 'Incorrect POST name', 400
    date = flask.request.values.get('date', datetime.now().strftime('%Y-%m-%d'))
    cur_day = datetime.strptime(date, '%Y-%m-%d')
    next_day = cur_day + timedelta(days=1)
    sessions = (Session.query(Session.user_id == user.user_id(),
                Session.start_ts >= cur_day, Session.start_ts < next_day)
            .order(-Session.start_ts))
    num_shared = Session.query(Session.user_id == user.user_id(), Session.shared == True).count()
    return flask.render_template('main.html',
                                 user=user,
                                 date=date,
                                 year=datetime.now().year,
                                 logout_url=users.create_logout_url('/'),
                                 sessions=sessions,
                                 num_shared=num_shared)

def get_by_ids(cls, id_list, keys_only=False):
        if not id_list:
            return []
        keys = [ndb.Key(cls, x) for x in id_list]
        if keys_only:
            return cls.query(cls.key.IN(keys)).fetch(len(keys), keys_only=True)
        else:
            return ndb.get_multi(keys)

def get_by_ids(cls, id_list, keys_only=False):
        if not id_list:
            return []
        keys = [ndb.Key(cls, x) for x in id_list]
        if keys_only:
            return cls.query(cls.key.IN(keys)).fetch(len(keys), keys_only=True)
        else:
            return ndb.get_multi(keys)

def get_by_ids(cls, id_list, keys_only=False):
        if not id_list:
            return []
        keys = [ndb.Key(cls, x) for x in id_list]
        if keys_only:
            return cls.query(cls.key.IN(keys)).fetch(len(keys), keys_only=True)
        else:
            return ndb.get_multi(keys)

def get_by_ids(cls, id_list, keys_only=False):
        if not id_list:
            return []
        keys = [ndb.Key(cls, x) for x in id_list]
        if keys_only:
            return cls.query(cls.key.IN(keys)).fetch(len(keys), keys_only=True)
        else:
            return ndb.get_multi(keys)

def get_by_ids(cls, id_list, keys_only=False):
        if not id_list:
            return []
        keys = [ndb.Key(cls, x) for x in id_list]
        if keys_only:
            return cls.query(cls.key.IN(keys)).fetch(len(keys), keys_only=True)
        else:
            return ndb.get_multi(keys)

def resolve_key_reference(self, entity, info):
        key_value = self.__ndb_key_prop._get_user_value(entity)
        if not key_value:
            return None

        if isinstance(key_value, list):
            return ndb.get_multi(key_value)

        return key_value.get()