Python rethinkdb.desc函数代码示例

 def admin(self):
     selection = list(r.db(RDB['ticketsdb']).table('tickets').order_by(r.desc(lambda date: date['meta']['updated_at'])).run(g.rdb_conn))
     if selection is not None:
         print(selection)
         return render_template('tickets/ticketslist.html', results=selection)
     else:
         return "Not Found", 404

    def load_ebook(self, ebook_id):
        # query returns dict with ebook->versions->formats nested document
        # versions are ordered by popularity
        try:
            ebook = (
                r.table("ebooks")
                .get(ebook_id)
                .merge(
                    lambda ebook: {
                        "versions": r.table("versions")
                        .get_all(ebook["ebook_id"], index="ebook_id")
                        .order_by(r.desc("ranking"))
                        .coerce_to("array")
                        .merge(
                            lambda version: {
                                "formats": r.table("formats")
                                .get_all(version["version_id"], index="version_id")
                                .coerce_to("array")
                            }
                        )
                    }
                )
                .run()
            )

        except RqlRuntimeError as e:
            if "Cannot perform merge on a non-object non-sequence `null`" in str(e):
                return None
            else:
                raise e

        return ebook

def get_messages():
    conn = r.connect(host='localhost',
                     port=28015,
                     db='chatrethink')
    messages = r.table('messages').order_by(r.desc('added')).limit(25).run(conn)
    messages = [{'text': message['text'], 'username': message['by']} for message in reversed(list(messages))]
    return jsonify({'messages': messages})

    def get(self):

        conn = yield self.rethinkdb_conn

        posts = yield r.table("posts")\
            .order_by(index=r.desc("created_time"))\
            .pluck(
                {"images":{"low_resolution":{"url":True}}},
                {"user":{"username":True}},
                "created_time",
                "link",
                {"caption":{"text":True}})\
            .limit(9)\
            .run(conn)

        output_posts = []
        while(yield posts.fetch_next()):

            if len(output_posts) >= 9:
                break;

            p = yield posts.next()
            output_posts.append(p)

        home_template = template_env.get_template("home.html")

        subscriptions_raw = insta_api.list_subscriptions()
        subscriptions = [x['object_id'] for x in subscriptions_raw['data']]

        self.write(home_template.render(
            auth_url = insta_api.get_authorize_url(),
            posts = output_posts,
            subscriptions = subscriptions
            ))

 def get_peak_records(self, account_year_pairs):
     return self.uow.run_list(self.table.get_all(*account_year_pairs, index='peak_report')
                              .map(lambda record: {'account_id': record['account_id'],
                                                   'readingdateutc': record['readingdateutc'],
                                                   'demand': record['energy']['demand'],
                                                   'weather': record['weather']})
                              .order_by(r.desc('demand')).limit(50))

def list_notes(hostname):
    """Retrieve a list of notes associated with a host. Or given
      {'user': 'username', 'note': 'some message'} post a note."""
    if request.method == 'GET':
        try:
            #someday i should probably add offset support here and in the statelog
            limit = request.args.get('limit', 50, type=int)
        except ValueError:
            abort(400)
        notes = list(r.table("notes").filter({"hostname": hostname}).order_by(r.desc("ts")).limit(limit).run(rdb.conn))
        if notes:
            return jsonify({'notes': sorted(notes, key=lambda k: k['ts'])})
        else:
            abort(404)
    elif request.method == 'POST':
        if not request.json:
            abort(400)
        if not request.json.get("user") or not request.json.get("note"):
            abort(400)
        if not r.table("hosts").get_all(hostname, index="hostname").run(rdb.conn):
            abort(404)
        alerting = [x["check"] for x in r.table("checks").filter({"h stname": hostname, "status": False}).run(rdb.conn)]
        q = r.table("notes").insert({'hostname': hostname, 'user': request.json.get("user"),
                                     'note': request.json.get("note"), 'ts': time(), 'alerting': alerting}).run(rdb.conn)
        if q["inserted"] == 1:
            return jsonify({'success': True})
        else:
            logger.error(q)
            abort(500)
    else:
        abort(400)

 def history(
     self, method=None, hid=None,
         time=None, start=None, limit=None, rdb=None):
     ''' This will pull a monitors history from rethinkDB '''
     retdata = False
     if method == "mon-history":
         retdata = []
         monitors = r.table('history').filter(
             (r.row['cid'] == self.cid) & (r.row['starttime'] >= time) & (r.row['type'] == "monitor")).order_by(
             r.desc('starttime')).pluck('starttime', 'id', 'cid', 'zone', 'status', 'failcount', 'method', 'name').skip(start).limit(limit).run(rdb)
         for mon in monitors:
             mon['starttime'] = datetime.datetime.fromtimestamp(
                 mon['starttime']).strftime('%Y-%m-%d %H:%M:%S')
             retdata.append(mon)
     elif method == "detail-history":
         retdata = []
         mon = r.table('history').get(hid).pluck(
             'starttime', 'cid', 'zone', 'status',
             'failcount', 'method', 'name').run(rdb)
         mon['reactions'] = []
         reactions = r.table('history').filter(
             (r.row['cid'] == self.cid) & (r.row['starttime'] == mon['starttime']) & (r.row['zone'] == mon['zone']) & (r.row['type'] == "reaction")).pluck('name', 'rstatus', 'time', 'starttime').run(rdb)
         for react in reactions:
             react['starttime'] = datetime.datetime.fromtimestamp(
                 react['starttime']).strftime('%Y-%m-%d %H:%M:%S')
             react['time'] = datetime.datetime.fromtimestamp(
                 react['time']).strftime('%Y-%m-%d %H:%M:%S')
             mon['reactions'].append(react)
         mon['starttime'] = datetime.datetime.fromtimestamp(
             mon['starttime']).strftime('%Y-%m-%d %H:%M:%S')
         retdata.append(mon)
     elif method == "count":
         retdata = r.table('history').filter(
             (r.row['cid'] == self.cid) & (r.row['starttime'] >= time) & (r.row['type'] == "monitor")).count().run(rdb)
     return retdata

def renderScores(nameOfTable, GameName):
    r.connect().repl()

    try:
        r.db("test").table_create(nameOfTable).run()
    except r.ReqlOpFailedError:
        pass

    bestScorePerPlayer = r.table(nameOfTable).group("username").max("score").run()
    topscoresPerPlayer = r.expr(bestScorePerPlayer.values()).order_by(r.desc("score")).limit(10).run()
    topscoresofalltime = r.table(nameOfTable).order_by(r.desc("score")).limit(10).run()
    
    tabifyResult(topscoresPerPlayer)
    tabifyResult(topscoresofalltime)
    
    return render_template('bshighScores.html',gameName=GameName, topscoresByPlayerTable=topscoresPerPlayer,topscoresalltimeTable=topscoresofalltime)

 def get_latest_with_keyword(cls, search_keyword):
     # Looks like we can't chain a get_all with an order_by, so we can't use
     # the search_keyword index.
     query = (r.table(cls._TABLE_NAME)
             .order_by(index=r.desc('pushed_at'))
             .filter({'search_keyword': search_keyword}))
     return db.util.get_first(query)

 def get_all(self):
     selection = list(r.db(rdb['chatdb']).table('chats').order_by(r.desc(lambda date: date['meta']['updated_at'])).run(g.rdb_conn))
     if selection is not None:
         print("Chat.get_all: Retrieved Chat messages from DB: {}".format(selection))
         return render_template('chat/chatlist.html', results=selection)
     else:
         return "Not Found", 404

 def players_by_score(cls):
     watershed = datetime.datetime.now() - datetime.timedelta(minutes=1)
     players = cls.query(
         rdb.row['beat'] > pytz.utc.localize(watershed)
     ).order_by(
         rdb.desc('score')
     ).fetch()
     return players

def latest():
    last_report = r.table(STATS_TABLE).order_by(r.desc('datetime'))[0]
    selection = last_report['by_milestone'].filter(lambda report_by_m:
            is_in_array(report_by_m['milestone'], MILESTONES)
        ).map(lambda filtered_report: 
            filtered_report.merge({'datetime': last_report['datetime']})
        ).run(g.rdb_conn)
    return json.dumps(selection)

 def on_get(self, req, resp):
     filter = (req.get_param('filter') or 'launched').capitalize()
     limit = req.get_param_as_int('limit') or 1
     projects = r.table('projectsRecently%s' % filter) \
         .order_by(r.desc('launched_at')) \
         .limit(limit) \
         .run(self.connection)
     resp.body = json.dumps(projects)

 def test_sort_1_attr_2_desc(self, conn):
     expected = [
         {'id': 'bill', 'age': 35, 'score': 78},
         {'id': 'joe', 'age': 26, 'score': 60},
         {'id': 'todd', 'age': 52, 'score': 15},
     ]
     result = r.db('y').table('scores').order_by(r.desc('score')).run(conn)
     assertEqual(expected, list(result))

def languages_db():
    """Get the languages stored in the database"""
    s_langs = r.db("indielangs").table("languages").order_by(r.desc("timestamp")).limit(1).run(DB)

    if len(s_langs) != 0:
        return s_langs[0]
    else:
        return {}