예제 #1
0
def make_sentence(username, prompt=""):
    sentence = ''
    # Try to find the user
    user = session.query(model.User).filter(model.User.name==username).first()
    if not user:
        raise exceptions.UserNotFoundException(
            'Username "{}" not found'.format(username))

    sentence = ''
    word = ''
    if prompt: # Load up an initial word
        word = session.query(model.WordEntry)\
            .filter(model.WordEntry.user == user.id, model.WordEntry.word_prev == prompt)\
            .order_by(func.rand()).first()
    if word:
        sentence += word.word_prev + " "
    else:
        word = session.query(model.WordEntry)\
            .filter(model.WordEntry.user == user.id, model.WordEntry.word_prev == '')\
            .order_by(func.rand()).first()
    if not word:
        raise exceptions.UserHasntSpoken(
            'I haven\'t seen "{}" say anything'.format(username))
    word = word.word_next
    sentence += word
    for i in xrange(SENTENCE_WORD_LIMIT):
        last_words = ' '.join(sentence.split()[-2:])
        word = get_next_word(user, word, last_words)
        if word:
            sentence += ' ' + word
        else:
            break
    sentence = "*{}:* ".format(str(user)) + str(sentence.encode('utf8'))

    # Slack surrounds URLs with < and >, which breaks their linking.  So we
    # strip that out.
    sentence = re.sub(
        '<(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)>',
        r'\1', sentence)

    # Replace @u1010101 references with actual user names
    user_ids = re.finditer(r'(@[\d\w]{9})', sentence)
    for match in user_ids:
        user_id = match.group()
        user = session.query(model.User).filter(
            model.User.id==user_id.strip('@')).first()
        if not user:
            continue
        sentence = sentence.replace(user_id, '@' + str(user))
    return sentence
예제 #2
0
def fetch_mammothRun_record(session, supergroup_key, version, host, redo_error):
	"""
	First attempts to lock the hpf.mammothRun table in order to ensure this process gets
	a mammoth record that no other mammothrun_driver process is working on simultaneously.
	
	When a lock is acheived (it's a blocking call), queries the mammothRun table for records
	of the supergroup_key and version specified with a status of 'unprocessed' (if 
	redo_error is True, then also with status 'error').

	If no record, returns None. Otherwise, sets the record's status to 'running',
	sets the host field, unlocks the table, and returns the record.
	"""
	from sqlalchemy import or_
	from hpf.hddb.db import MammothRun
	from sqlalchemy.sql.expression import func
	session.execute("LOCK TABLES {0} WRITE".format(MammothRun.__tablename__))
	if redo_error:
		ready_record = session.query(MammothRun).filter(MammothRun.supergroup_key==supergroup_key)\
											.filter(MammothRun.version==version)\
											.filter(or_(MammothRun.status=='unprocessed', MammothRun.status=='error'))\
											.order_by(func.rand())\
											.first()
	else:
		ready_record = session.query(MammothRun).filter(MammothRun.supergroup_key==supergroup_key).filter(MammothRun.version==version)\
											.filter(MammothRun.status=='unprocessed')\
											.first()
	if ready_record:
		ready_record.status = 'running'
		ready_record.host = host
		session.flush()
	session.execute("UNLOCK TABLES")
	return ready_record
예제 #3
0
def cricket_board(id):
	markStyles = get_mark_styles().order_by(func.rand())
	markStyle = markStyles.first()
	markStyleIds = []
	for ms in markStyles:
		markStyleIds.append(int(ms.id))
	return render_template("matches/modes/cricket/board.html", match = getGameData(id), markStyle = markStyle, markStyleIds = markStyleIds)
예제 #4
0
파일: sqldb.py 프로젝트: atzm/amazonas
 def r(self):
     if self.url.startswith('sqlite'):
         return func.random()
     if self.url.startswith('mysql'):
         return func.rand()
     if self.url.startswith('postgresql'):
         return func.random()
     if self.url.startswith('oracle'):
         return 'dbms_random.value'
     raise NotImplementedError()
예제 #5
0
def random_row(model):
    """Retrieves a random row for the given model."""

    try:
        # PostgreSQL, SQLite
        instance = model.query.order_by(func.random()).limit(1).first()
    except OperationalError:
        # MySQL
        instance = model.query.order_by(func.rand()).limit(1).first()

    return instance
예제 #6
0
def reply():
	print request.remote_addr
	while True:
		quote = Quote.query.order_by(func.rand()).first()
		if len(quote.content) < 150:
			break

	q = {}
	q['content'] = quote.content
	q['author'] = quote.author
	return json.dumps(q)
예제 #7
0
파일: facts.py 프로젝트: lauxley/StupidBot
    def get_response(self):
        # this should query the base using the biggest word as a search term
        q = self.session.query(self.plugin.SCHEMA)

        if self.date:
            fact = q.filter(self.plugin.SCHEMA.date == self.date).order_by(func.rand()).first()
        else:
            # testing with the whole 'sentence'
            fact = q.filter(or_
                            (and_(*[self.plugin.SCHEMA.text.like('%%%s%%' % e) for e in self.context]),
                            and_(*[self.plugin.SCHEMA.author.like('%%%s%%' % e) for e in self.context]))
                            ).order_by(func.rand()).first()
            if not fact:
                # we only keep 'big' words (>1) and see how it goes
                c = [w for w in self.context if len(w) > 1]
                fact = q.filter(or_(*[self.plugin.SCHEMA.text.like('%%%s%%' % e) for e in c]),
                                or_(*[self.plugin.SCHEMA.author.like('%%%s%%' % e) for e in c])
                                ).order_by(func.rand()).first()
        if fact:
            return repr(fact)
        else:
            return u"no match"
예제 #8
0
    def load_photos(self, **filters) -> List[Photo]:
        q = self.session.query(Photo)

        owner_id = filters.get('owner_id')
        if owner_id is not None:
            q = q.filter(
                Photo.owner_id == owner_id
            )

        albums = filters.get('albums')
        if albums is not None:
            q = q.filter(
                Photo.album.in_(albums)
            )
        restricted_albums = filters.get('restricted_albums')
        if restricted_albums is not None:
            q = q.filter(
                Photo.album.notin_(restricted_albums)
            )

        start_datetime = filters.get('start_datetime')
        if start_datetime is not None:
            q = q.filter(
                Photo.date_time >= start_datetime
            )
        end_datetime = filters.get('end_datetime')
        if end_datetime is not None:
            q = q.filter(
                Photo.date_time <= end_datetime
            )

        posted = filters.get('posted')
        if posted is not None:
            q = q.filter(
                Photo.posted.is_(posted)
            )

        random = filters.get('random')
        if random is not None:
            q = q.order_by(func.rand())

        limit = filters.get('limit')
        if limit is not None:
            q = q.limit(limit)

        offset = filters.get('offset')
        if offset is not None:
            q = q.offset(offset)

        photos = q.all()
        return photos
예제 #9
0
def add_projects():
    rand_client = db.session.query(Customer).order_by(func.rand()).first
    projects = [
        {
            "customer_id": 1,
            "name": "Build a time tracker application"
        },
        {
            "customer_id": 2,
            "name": "New landing page"
        },
        {
            "customer_id": 3,
            "name": "Migrate database architectures"
        }
    ]
    add_objects(projects, Project)
예제 #10
0
def get_random_user(method):
    """
        Pick random user from db acording to some rules
        
        Pick first that is true
        1. If main user never scraped, then scrape it
        2. If main user to long since scraped, then scrape it
        3. If user with degree priority high enough to be fully scraped never was scraped, then scrape it
        4. If user with degree priority high enough to be fully scraped is to long since updated, then scrape it
        5. if user never scraped, then scrape it
        6. If user to old since update, then scrape it
        
        todo:
            remove or keep rule 5 and 6? 
        
        args:
            method (str): friendship|user|tweet. Used to pick which last updated field to check
    """
    users=None
    if method == "friendship":
        users = _get_random_user("friendships_last_updated", user_main_delta=twitter_config.FRIENDSHIP_USER_MAIN_DELTA, 
                      user_full_delta=twitter_config.FRIENDSHIP_USER_FULL_DELTA)
    elif method == "user":
        users = _get_random_user("last_updated", user_main_delta=twitter_config.USER_MAIN_DELTA, 
                      user_full_delta=twitter_config.USER_FULL_DELTA, user_delta=twitter_config.USER_DELTA)
    elif method == "tweet":
        users = _get_random_user("tweets_last_updated", user_main_delta=twitter_config.TWEET_USER_MAIN_DELTA, 
                      user_full_delta=twitter_config.TWEET_USER_FULL_DELTA)
    
    if not users:
        return None
    if not users.first():
        return None
    
    #This should shuffle the list retrieved for different type of db. Not tested on all
    #Might also become to slow when db gets large, not tested.
    if twitter_config.DATABASE == twitter_const.MYSQL:
        users = users.order_by(func.rand())
    elif twitter_config.DATABASE == twitter_const.POSTGRESSQL or twitter_config.DATABASE == twitter_const.SQLITE:
        users = users.order_by(func.random())
    elif twitter_config.DATABASE == twitter_const.ORACLE:
        users = users.order_by('dbms_random.value')
        
    return users.first()
예제 #11
0
파일: Model.py 프로젝트: jroose/notochord
    def __init__(self,
                 session,
                 widget_query,
                 num_splits=10,
                 table_name="tmp_widget_random"):
        from sqlalchemy import Column
        from sqlalchemy.sql.expression import func, select

        t_w = schema.widget

        class tmp_widget_random(schema.TableBase):
            idfold = Column(t_w.idwidget.type,
                            nullable=False,
                            primary_key=True)
            idwidget = Column(t_w.idwidget.type,
                              nullable=False,
                              primary_key=True)
            __table_args__ = ({
                'prefixes': ["TEMPORARY"],
                'keep_existing': True
            }, )
            __tablename__ = table_name

        self.num_splits = int(num_splits)
        self.session = session
        self.tmp_wr = tmp_widget_random

        self.tmp_wr.__table__.create(bind=self.session.bind)

        if self.session.bind.dialect.name.lower() == "mysql":
            randfunc = func.rand()
        else:
            randfunc = func.random()

        num_rows = widget_query.count()
        row_number_column = func.row_number().over(
            order_by=randfunc).label('row_number')
        self.session.execute(
            self.tmp_wr.__table__.insert().from_select(
                [self.tmp_wr.idfold, self.tmp_wr.idwidget],
                select([((row_number_column-1) * int(self.num_splits)) / int(num_rows), t_w.idwidget]) \
                    .where(t_w.idwidget.in_(widget_query)) \
        ))
예제 #12
0
def info():
    req = request.values
    id = int(req['id']) if ('id' in req and req['id']) else 0
    if id < 1:
        return redirect(urlManager.buildURL('/'))

    info = Movie.query.filter_by(id=id).first()
    if not info:
        return redirect(urlManager.buildURL('/'))

    info.view_counter += 1
    db.session.add(info)
    db.session.commit()

    recommend_list = Movie.query.order_by(func.rand()).limit(4)
    return ops_render("info.html", {
        'info': info,
        'recommend_list': recommend_list
    })
예제 #13
0
def inbox_read(mid):
    user = get_user()
    if not user:
        return error(401, "AuthorizationError", "인증 오류")

    if mid == "random":
        mail = user.mails.order_by(func.rand()).first()
    else:
        mail = Mail.query.filter_by(mail_id=mid).one()
    if not mail:
        return error(401, "MailError", "접근 오류")

    f = open('app/static/web/mail/%s.html' % mail.mail_id, "r")
    body = f.read()
    f.close()

    ppos = user.get_config("ppos")
    ppos = ppos.value if ppos else "0"

    return resolve_name(body, user.get_nickname(mail.member.id), ppos == "1")
예제 #14
0
def test():

    page = request.args.get('page')
    if page and page.isdigit():
        page = int(page)
    else:
        page = 1

    selected = db.session.query(Quizz).order_by(func.rand()).limit(10)
    selected = selected.from_self()
    pages = selected.paginate(page=page, per_page=1, error_out=False)

    if request.method == "POST":
        curr_answer = request.form['answer_form']
        correct_answer = Quizz.right_answer
        score = 0
        print(score)
        if not pages.has_next:
            return redirect(url_for('/result', score=score))
    return render_template('test.html', pages=pages)
예제 #15
0
파일: views.py 프로젝트: Grant1219/reactdb
def home (request):
    mysql = DBSession ()
    images = None
    sphinx = SphinxClient ()
    sphinx.SetServer ('127.0.0.1', 9312)
    sphinx.SetMatchMode (sphinxapi.SPH_MATCH_ANY)

    if 'query' in request.GET and len (request.GET['query']) > 0:
        # do search
        results = sphinx.Query (request.GET['query'])
        matches = []
        for match in results['matches']:
            matches.append (match['id'])

        if results['total'] > 0:
            images = mysql.query (Image.id.label ('id'), Image.filename.label ('filename'), func.count (Keyword.id).label ('match_count') ).join (Image.keywords).filter (Keyword.id.in_ (matches) ).group_by (Image).order_by ('match_count DESC').distinct ()
    else:
        # get some random images
        images = mysql.query (Image).order_by (func.rand () ).limit (30).all ()

    return {'images': images}
예제 #16
0
class MnMEntry(BASE):
    """A Mix'n'match entry."""

    __tablename__ = ENTRY_TABLE

    id = Column(
        INTEGER(11, unsigned=True),
        unique=True,
        primary_key=True,
        autoincrement=True,
    )
    catalog = Column(INTEGER(10, unsigned=True), nullable=False, index=True)
    ext_id = Column(String(255), nullable=False, index=True, default='')
    ext_url = Column(String(255), nullable=False, default='')
    ext_name = Column(String(128), nullable=False, index=True, default='')
    ext_desc = Column(String(255), nullable=False, default='')
    q = Column(Integer, index=True)
    user = Column(INTEGER(10, unsigned=True), index=True)
    timestamp = Column(String(16), index=True)
    random = Column(Float, index=True, default=func.rand())
    type = Column(String(16), nullable=False, index=True, default='')
예제 #17
0
def info():
    req = request.values
    id = int(req['id']) if ('id' in req and req['id']) else 0
    if id < 1:
        return redirect(UrlManager.buildUrl("/"))

    info = Movie.query.filter_by(id=id).first()
    if not info:
        return redirect(UrlManager.buildUrl("/"))

    '''
    更新阅读数量
    '''
    info.view_counter += 1
    db.session.add(info)
    db.session.commit()
    '''
    获取推荐
    '''
    recommend_list = Movie.query.order_by(func.rand()).limit(4)
    return ops_render("info.html", {"info": info, "recommend_list": recommend_list})
예제 #18
0
    def load_photos(self, **filters) -> List[Photo]:
        q = self.session.query(Photo)

        owner_id = filters.get('owner_id')
        if owner_id is not None:
            q = q.filter(Photo.owner_id == owner_id)

        albums = filters.get('albums')
        if albums is not None:
            q = q.filter(Photo.album.in_(albums))
        restricted_albums = filters.get('restricted_albums')
        if restricted_albums is not None:
            q = q.filter(Photo.album.notin_(restricted_albums))

        start_datetime = filters.get('start_datetime')
        if start_datetime is not None:
            q = q.filter(Photo.date_time >= start_datetime)
        end_datetime = filters.get('end_datetime')
        if end_datetime is not None:
            q = q.filter(Photo.date_time <= end_datetime)

        posted = filters.get('posted')
        if posted is not None:
            q = q.filter(Photo.posted.is_(posted))

        random = filters.get('random')
        if random is not None:
            q = q.order_by(func.rand())

        limit = filters.get('limit')
        if limit is not None:
            q = q.limit(limit)

        offset = filters.get('offset')
        if offset is not None:
            q = q.offset(offset)

        photos = q.all()
        return photos
예제 #19
0
def blog(id):
    # 获取文章
    article = Article.query.get_or_404(id)
    Article.query.filter_by(id=id).update({'views_num': Article.views_num + 1})
    # 获取栏目
    currentnav = Nav.query.get(article.nav_id)
    #上一篇
    prev = Article.query.order_by(
        Article.id.desc()).filter(Article.id < id).first()
    #下一篇
    next = Article.query.order_by(
        Article.id.asc()).filter(Article.id > id).first()

    # 相关文章
    relations = Article.query.filter(Article.nav_id == article.nav_id).filter(
        Article.id != id).order_by(func.rand()).limit(6)
    return render_template('index/article/detail.html',
                           article=article,
                           currentnav=currentnav,
                           prev=prev,
                           next=next,
                           relations=relations)
예제 #20
0
def main(num_accounts):
    maybe_enable_rollbar()

    with global_session_scope() as db_session:
        accounts = (db_session.query(Account).filter(
            Account.sync_should_run == true()).order_by(
                func.rand()).limit(num_accounts).all())

        accounts = [acc.id for acc in accounts][:num_accounts]
        db_session.expunge_all()

    pool = Pool(size=100)
    results = pool.map(process_account, accounts)

    global_results = dict()
    for ret in results:
        for key in ret:
            if key not in global_results:
                global_results[key] = 0

            global_results[key] += ret[key]

    print(global_results)
예제 #21
0
    def get_sound_by_string(string: str, server_id: int,
                            uploader_id: int) -> typing.Optional[Sound]:
        r = re.match(r'(?:(?i)ID:)?(\d+)', string)

        if r is not None:
            return session.query(Sound).get(int(r.groups()[0]))

        else:
            q = session.query(Sound).filter(Sound.name == string.lower()) \
                .order_by(
                Sound.server_id != server_id,
                Sound.uploader_id != uploader_id,
                Sound.public == False,
                func.rand()) \
                .first()

            if q is None or (q.server_id != server_id
                             and q.uploader_id != uploader_id
                             and not q.public):
                return None

            else:
                return q
예제 #22
0
def search():
    by = request.args.get('by', 'invalid', type=str)
    search_value = request.args.get('value', '', type=str)

    if by == 'name':
        if search_value == '':
            search_result = "%{}%".format(g.search_form.search.data)
            search_value = g.search_form.search.data
        else:
            search_result = "%{}%".format(search_value)
        games = Games.query.filter(Games.name.like(search_result))
    elif by == 'new':
        games = Games.query.order_by(Games.released.desc())
    elif by == 'top':
        games = Games.query.order_by(Games.rating.desc())
    elif by == 'all':
        games = Games.query.order_by(func.rand())

    page = request.args.get('page', 1, type=int)
    games = games.paginate(page, app.config['POSTS_PER_PAGE'], False)

    user_games_objects = User_games.query.filter_by(
        user_id=current_user.id).all()
    user_games = [it.game_id for it in user_games_objects]

    next_url = url_for('search', by=by, value=search_value, page=games.next_num) \
        if games.has_next else None
    prev_url = url_for('search', by=by, value=search_value, page=games.prev_num) \
        if games.has_prev else None
    games = games.items

    return render_template('search.html',
                           games=games,
                           ugames=user_games,
                           url_next=next_url,
                           url_prev=prev_url,
                           current_page=page)
예제 #23
0
def create_journal():
    error = ""
    form = JournalForm()
    if request.method == 'POST':
        title = form.title.data
        entry = form.entry.data
        author_id = current_user.id
        author = current_user.first_name

        if len(title) == 0 or len(entry) == 0:
            error = "Please supply a title and entry."
        else:
            journal_submission = Journal(date_created=datetime.now().date(),
                                         time_created=datetime.now().time(),
                                         author_id=author_id,
                                         entry=entry,
                                         title=title)
            db.session.add(journal_submission)
            db.session.commit()
            journal_id = journal_submission.journal_id
            return redirect(
                url_for('specific_journal_page',
                        journal_id=journal_id,
                        user_id=author_id))
    if current_user.is_authenticated:
        random_theme = db.session.query(JournalTheme.theme).order_by(
            func.rand()).first()
        return render_template('create_journal_entry.html',
                               form=form,
                               message=error,
                               is_logged_in=True,
                               randomtheme=random_theme[0],
                               is_edit=False,
                               delete_form="")
    else:
        raise PageRequiresLoginError(
            "User tried to access journal creation page without logging in.")
예제 #24
0
def get_results(channel_slug):
    channel = Channel.query.filter_by(slug=channel_slug).first()
    if not channel:
        return "404 - Not found"
    results = Record.query.filter_by(executed=False,
                                     channel_id=channel.id).all()
    if not results:
        random_rec = Record.query.filter_by(channel_id=channel.id).order_by(
            func.rand()).first()
        if random_rec:
            entry = Record(channel.id, random_rec.video.id)
            db.session.add(entry)
            db.session.commit()
            results = [entry]
    return jsonify({
        "videos":
        map(
            lambda x: {
                'code': x.video.code,
                'r_id': x.id,
                'title': x.video.title,
                'duration': x.video.duration
            }, results)
    })
예제 #25
0
def process_account(account_id):
    ret = defaultdict(int)

    try:
        with session_scope(account_id) as db_session:
            acc = db_session.query(Account).get(account_id)
            db_session.expunge(acc)

        one_month_ago = datetime.datetime.utcnow() - datetime.timedelta(
            days=30)

        for _ in range(NUM_MESSAGES):
            with session_scope(account_id) as db_session:
                block = (db_session.query(Block).filter(
                    Block.namespace_id == acc.namespace.id,
                    Block.created_at < one_month_ago,
                ).order_by(func.rand()).limit(1).first())

                if block is None:
                    continue

                if len(block.parts) == 0:
                    ret["null_failures"] += 1
                    continue

                message = block.parts[0].message
                raw_mime = get_raw_from_provider(message)

            if raw_mime != "":
                ret["successes"] += 1
            else:
                ret["null_failures"] += 1
    except Exception as e:
        ret[type(e).__name__] += 1

    return ret
예제 #26
0
def random_songs(limit=20):
    session = Session()
    res = session.query(Song).order_by(func.rand()).limit(limit).all()
    session.commit()
    songs = [song.dictify() for song in res]
    return {'query': '', 'limit': limit, 'results': songs}
예제 #27
0
def picture_random(language):
    word = Word.query.order_by(func.rand()).first()
    return redirect("/%s/word/%s" % (util.get_language(language), word.uid), code=303)
예제 #28
0
def male(nyt_id=None):
    if current_user.is_authenticated and current_user.is_admin:    
        row = Metadata().query.filter(and_(Metadata.review_type == "needs_audit_probably_male", Metadata.year > 1905, Metadata.year < 1923)).order_by(func.rand()).first()
        endpoint = row.nyt_pdf_endpoint
        if ".xml" not in endpoint:
            r = requests.get(endpoint)
            html = BeautifulSoup(r.text, features="html.parser")
            link = html.find("a", {"class":"user-action archive-user-action"})
            pdf_link = link['href'].replace('.html', '.pdf')
        else: pdf_link = endpoint
        return render_template("index.html", nyt_id=row.nyt_id, row=row, endpoint=endpoint, pdf_link=pdf_link) 
    else:
        return render_template("index.html", nyt_id=None, endpoint=None, pdf_link=None)
예제 #29
0
def index(nyt_id=None):
    if current_user.is_authenticated and current_user.is_admin:
        if nyt_id != None:
            row = Metadata().query.filter(Metadata.nyt_id == nyt_id).one_or_none()
            endpoint = row.nyt_pdf_endpoint
            r = requests.get(endpoint)
            html = BeautifulSoup(r.text, features="html.parser")
            link = html.find("a", {"class":"user-action archive-user-action"})
            pdf_link = link['href'].replace('.html', '.pdf')

            return render_template("index.html", nyt_id=nyt_id, row=row, endpoint=endpoint, pdf_link=pdf_link)
        else:
            row = Metadata().query.filter(and_(Metadata.year > 1905, Metadata.year < 1926)).filter(Metadata.review_type.like("needs_audit%")).order_by(func.rand()).first()
            #pages = ['BR3', 'BR4', 'BR5', 'BR6', 'BR7', 'BR8', 'BR9', 'BR10']
            #row = [i for i in row if i.page in pages]
            #row = row[0]
            # BR1, 'BR2', 'BR3', 'BR4', 'BR5', 'BR6', 'BR7', 'BR8', 'BR9', 'BR10'
            endpoint = row.nyt_pdf_endpoint
            if ".xml" not in endpoint:
                r = requests.get(endpoint)
                html = BeautifulSoup(r.text, features="html.parser")
                link = html.find("a", {"class":"user-action archive-user-action"})
                pdf_link = link['href'].replace('.html', '.pdf')
            else: pdf_link = endpoint

            return render_template("index.html", nyt_id=row.nyt_id, row=row, endpoint=endpoint, pdf_link=pdf_link) 
    else:
        return render_template("index.html", nyt_id=None, endpoint=None)
예제 #30
0
 def get_random_account(self, session):
     q = session.query(Account).filter(Account.is_login == true())
     return q.order_by(func.rand()).first()
예제 #31
0
 def get_randomCrawlIdentifiers(self, limit=100):
     from sqlalchemy.sql.expression import func
     it = self._session.query(CrawlFile).filter_by(status = "Incomplete").order_by(func.rand()).limit(limit)
     return [i.id for i in it if "crawl-002" not in i.key]
예제 #32
0
    def getIndex(self, form):
        '''
        觅声首页:
        {
            action: 'get_index',
            listentype: 'diff'/'like',
            channel: 'unset'/'channel_name',
        }
        {
            feed: feed{},
            feed_next: feed{}
        }
        // 上一首由前端记录
        '''

        audioChannel = form["channel"]

        if audioChannel == "unset":
            audioChannel = ""

        # 目前有8个分类,用0-7代表,因此暂定channel为8也返回全部频道。
        if audioChannel == "8":
            audioChannel = ""

        logger.info("getIndex. audioChannel = %s" % audioChannel)

        # 不同的数据库类型有不同的随机查询方式
        if self.dbName == "sqlite":
            randfunc = func.random()
        else:
            # for mysql
            randfunc = func.rand()

        # 随机查询两个audio
        randTwoAudios = self.session.query(User, Audio).filter(and_(
            User.openid == "system",  # index 页只显示PGC
            Audio.deleted == False,
            R_User_Create_Audio.deleted == False,
            User.openid == R_User_Create_Audio.user_openid,
            R_User_Create_Audio.audio_id == Audio.audio_id
        ))

        if audioChannel:
            randTwoAudios = randTwoAudios.filter(and_(
                R_Audio_In_AudioChannel.deleted == False,
                R_Audio_In_AudioChannel.audio_id == Audio.audio_id,
                R_Audio_In_AudioChannel.channel_id == int(audioChannel) + 1
            ))

        randTwoAudios = randTwoAudios.order_by(randfunc).limit(2).all()

        # 查询对应的user,tag,以及其他信息,组装成feed
        openid = form["openid"]
        feeds = [self.packFeed(openid, user, audio) for user, audio in randTwoAudios]

        feedlen = len(feeds)

        return Status.success({
            "feed": feeds[0] if feedlen > 0 else "",
            "feed_next": feeds[1] if feedlen > 1 else "",
        })
예제 #33
0
def testWebhook(message):
    if current_user.is_authenticated:
        webhookID = int(message['webhookID'])
        webhookType = message['webhookType']
        channelID = None

        if 'channelID' in message:
            channelID = int(message['channelID'])

        sysSettings = settings.settings.query.first()
        webhookQuery = None

        # Acquire a Channel to Test With
        channelQuery = None
        if channelID is not None:
            channelQuery = Channel.Channel.query.filter_by(
                id=channelID).first()
        else:
            channelQuery = Channel.Channel.query.order_by(func.rand()).first()

        # Acquire a Topic to Test With
        topic = topics.topics.query.order_by(func.rand()).first()

        # Retrieve Current Picture
        pictureLocation = current_user.pictureLocation
        if current_user.pictureLocation is None:
            pictureLocation = '/static/img/user2.png'
        else:
            pictureLocation = '/images/' + pictureLocation

        if channelQuery is not None:

            # Prepare Channel Image
            if channelQuery.imageLocation is None:
                channelImage = (sysSettings.siteProtocol +
                                sysSettings.siteAddress +
                                "/static/img/video-placeholder.jpg")
            else:
                channelImage = (sysSettings.siteProtocol +
                                sysSettings.siteAddress + "/images/" +
                                channelQuery.imageLocation)

            if webhookType == "global":
                if current_user.has_role("Admin"):
                    webhookQuery = webhook.globalWebhook.query.filter_by(
                        id=webhookID).first()

            elif webhookType == "channel":
                webhookQuery = webhook.webhook.query.filter_by(
                    id=webhookID).first()
                if webhookQuery is not None:
                    if webhookQuery.channel.id != current_user.id:
                        webhookQuery = None

            randomVideoQuery = RecordedVideo.RecordedVideo.query.order_by(
                func.random()).first()

            webhookFunc.testWebhook(
                webhookType,
                webhookQuery.id,
                channelname=channelQuery.channelName,
                channelurl=(sysSettings.siteProtocol +
                            sysSettings.siteAddress + "/channel/" +
                            str(channelQuery.id)),
                channeltopic=templateFilters.get_topicName(channelQuery.topic),
                channelimage=channelImage,
                streamer=templateFilters.get_userName(channelQuery.owningUser),
                channeldescription=str(channelQuery.description),
                streamname="Testing Stream",
                streamurl=(sysSettings.siteProtocol + sysSettings.siteAddress +
                           "/view/" + channelQuery.channelLoc),
                streamtopic=templateFilters.get_topicName(topic.id),
                streamimage=(sysSettings.siteProtocol +
                             sysSettings.siteAddress +
                             "/static/img/video-placeholder.jpg"),
                user=current_user.username,
                userpicture=(sysSettings.siteProtocol +
                             sysSettings.siteAddress + str(pictureLocation)),
                videoname=randomVideoQuery.channelName,
                videodate=str(randomVideoQuery.videoDate),
                videodescription=randomVideoQuery.description,
                videotopic=templateFilters.get_topicName(
                    randomVideoQuery.topic),
                videourl=(sysSettings.siteProtocol + sysSettings.siteAddress +
                          '/play/' + str(randomVideoQuery.id)),
                videothumbnail=(sysSettings.siteProtocol +
                                sysSettings.siteAddress + '/videos/' +
                                str(randomVideoQuery.thumbnailLocation)),
                comment="This is just a test comment!",
                message="This is just a test message!")
    db.session.commit()
    db.session.close()
    return 'OK'
예제 #34
0
파일: song.py 프로젝트: harshk360/beats
def random_songs(limit=20):
    session = Session()
    res = session.query(Song).order_by(func.rand()).limit(limit).all()
    session.commit()
    songs = [song.dictify() for song in res]
    return {'query': '', 'limit': limit, 'results': songs}
예제 #35
0
def explore():
    """发现页,随机展示问题,待修改
    """
    random_questions = Question.query.order_by(func.rand()).limit(5)
    return render_template('explore.html', questions=random_questions)
예제 #36
0
 def train_model(self, model_name):
     session = Session()
     model_record = session.query(ModelEntry).filter(ModelEntry.name == model_name).one()
     model_record.state = 'training'
     session.commit()
     parent_models = self.model_manager.models[model_name].input_models
     for parent_model in parent_models:
         # Train any untrained parent models
         if session.query(ModelEntry).filter(ModelEntry.name == parent_model, ModelEntry.state == 'untrained')\
                 is not None:
             self.train_model(parent_model)
         # Wait for any parent models that are still in training, in cases where another process started the training
         while session.query(ModelEntry).filter(ModelEntry.name == parent_model,
                                                     ModelEntry.state == 'training').one_or_none()\
                 is not None:
             time.sleep(30)
     model = self.model_manager.models[model_name]
     dataset_name = model.dataset
     entry_count = model.training_entry_count
     if dataset_name == 'core_dataset':
         dataframe = pandas.read_sql(session.query(Base.metadata.tables['core_dataset']).order_by(func.rand()).limit(entry_count).statement,
                                     self.database_engine)
     else:
         dataframe = pandas.read_csv(DEFAULT_DATA_PATH, sep='\s+', names=DEFAULT_DATA_HEADERS)
         if entry_count > len(dataframe):
             entry_count = len(dataframe)
         dataframe = dataframe.sample(entry_count)
     for parent_model in parent_models:
         self.recursive_process(parent_model, dataframe)
     model.train(dataframe)
     self.model_manager.save_model(model_name)
     model_record.state = 'trained'
     session.commit()
     # Update the model manager max input count - done here to happen at the end of training
     self.model_manager.update_max_inputs(len(self.model_manager.get_model_inputs(model_name)))
     session.close()
예제 #37
0
def download_questions():

    questions = Questions.query.order_by(func.rand()).limit(5)
    question_schema = QuestionSchema(many=True)
    output = question_schema.dump(questions)
    return jsonify(output)
def index():
  example_host = Host.query.filter_by(active=1).filter_by(ssl_result=6).order_by(sqlalchemy_func.rand()).first()
  return render_template('index.html', example_host=example_host)
예제 #39
0
def random_question(size=5):
    random_questions = Question.query.order_by(func.rand()).limit(5)
    question = [dict(link=url_for('main.question_page', id=x.id),
                     title=x.title) for x in random_questions]
    return jsonify(question=question)
예제 #40
0
파일: views.py 프로젝트: relsqui/openqdb
def goodrandomquote():
    quotes = Quotes.query.filter_by(pending = False).filter(Quotes.upvotes > Quotes.downvotes).order_by(func.rand()).limit(POSTS_PER_PAGE).from_self()
    return render_quotes(quotes, filter_pending = False, bayesian_sort = False)
예제 #41
0
    def run(self):
        if self.experiment is None: return
        experiment = self.experiment
        db = self.db
        while True:
            job = None
            try:
                job = db.session.query(db.ExperimentResult) \
                        .filter_by(experiment=self.experiment) \
                        .filter_by(status=-1) \
                        .order_by(func.rand()).limit(1).first()
                job.status = 0
                db.session.commit()
            except:
                db.session.rollback()

            if job:
                job.startTime = func.now()
                db.session.commit()

                client_line = '/usr/bin/time -f ";time=%U;mem=%M;" '
                client_line += os.path.join(PACKAGE_DIR, 'solvers', launch_command(job.solver_configuration, os.path.join(PACKAGE_DIR, 'instances', str(job.instance.idInstance)+ '_' + job.instance.name), str(job.seed))[2:])


                print "running job", job.idJob, client_line
                stdout = open(os.path.join(TMP, str(job.idJob) + 'stdout~'), 'w')
                stderr = open(os.path.join(TMP, str(job.idJob) + 'stderr~'), 'w')
                start = time.time()

                p = subprocess.Popen(shlex.split(str(client_line)), preexec_fn=setlimits(self.experiment.CPUTimeLimit), stdout = stdout, stderr = stderr)

                returncode = p.wait()
                print "Job", job.idJob, "done .. Realtime:", str(time.time() - start), "s"
                stdout.close()
                stderr.close()

                stdout = open(os.path.join(TMP, str(job.idJob) + 'stdout~'), 'r')
                stderr = open(os.path.join(TMP, str(job.idJob) + 'stderr~'), 'r')
                time_output = stderr.read().split(';')
                runtime = float([d.split('=')[1] for d in time_output if d.startswith('time=')][0])
                memory = int([d.split('=')[1] for d in time_output if d.startswith('mem=')][0])

                job.solverOutput = stdout.read()
                stdout.close()
                stderr.close()
                os.remove(os.path.join(TMP, str(job.idJob) + 'stdout~'))
                os.remove(os.path.join(TMP, str(job.idJob) + 'stderr~'))

                job.resultTime = runtime


                #cpuinfo = open('/proc/cpuinfo')
                #job.solverOutput = cpuinfo.read()
                #cpuinfo.close()

                print "  retcode", returncode

                if returncode != 10 and returncode != 0: # CPU Time limit exceeded exit code guess
                    job.status = 21
                else:
                    job.status = 1
                    if 's SATISFIABLE' in job.solverOutput:
                        job.resultCode = 11
                print "  CPU time:", runtime, "s", "Memory used:", memory, "kB"
                job.computeQueue = self.experiment.grid_queue[0].idgridQueue
                db.session.commit()
            else:
                if db.session.query(db.ExperimentResult) \
                        .filter_by(experiment=self.experiment) \
                        .filter_by(status=-1) \
                        .order_by(func.rand()).count() == 0: break # no more jobs
예제 #42
0
파일: cricket.py 프로젝트: enkeistar/darts
def cricket_board(id):
	markStyle = model.Model().select(markStyleModel.MarkStyle).filter_by(approved = 1).order_by(func.rand()).first()
	return render_template("matches/modes/cricket/board.html", match = getGameData(id), markStyle = markStyle)
예제 #43
0
 def get(self):
     user = self.get_current_user()
     randUrl = self.session.query(Article).order_by(func.rand()).limit(1).first()
     self.write(escape.json_encode({'short_url':randUrl.aurl}))
예제 #44
0
def dashboard():
  if 'username' not in session:
    return redirect(url_for('signin'))

  user = User.query.filter_by(username = session['username']).first()

  if user.verified == 0:
    print 'user is not verified'
    return redirect(url_for('verify'))

  if user.portfolioname == None or len(user.portfolioname.replace(' ', '')) < 1:
    print 'user does not have a portfolioname'
    return redirect(url_for('portfolioSetup'))

  user = User.query.filter_by(username = session['username']).first()
  uploads = Upload.query.filter_by(publisher=session['username'])

  following = Follow.query.filter_by(follower_username=session['username'])
  following_count = []
  for i in following:
    following_count.append(i)
  amount_of_following = len(following_count)
  user.following = amount_of_following
  db.session.commit()

  followers_count = []
  for person in User.query.all():
    followers = Follow.query.filter_by(followed_username=person.username)

    if followers != None:
      for i in followers:
        followers_count.append(i)

        amount_of_followers = len(followers_count)
        User.query.filter_by(username=person.username).first().followers = amount_of_followers
        db.session.commit()
    else:
      amount_of_followers = 0
      User.query.filter_by(username=person.username).first().followers = amount_of_followers
      db.session.commit()

  random_people = []

  for i in User.query.order_by(func.rand()).limit(2).all():
    random_people.append(i)

  #work on filtering posts

  peopleFollowing = []
  for i in Follow.query.filter_by(follower_username=session['username']):
    peopleFollowing.append(i.followed_username)


  posts_query = Posts.query.all()
  postsFollowing = [session['username']]

  for i in posts_query:
    if i.poster_username in peopleFollowing:
      postsFollowing.append(i.poster_username)

  posts = Posts.query.filter(Posts.poster_username.in_(postsFollowing))

  upload_folder = '/Users/developeraccount/Desktop/Lens/lens/src/static/accounts/%s' % session['username']

  if user is None:
    return redirect(url_for('signin'))
  else:
    firstname = user.firstname
    lastname = user.lastname
    username = user.username
    figure = user.figure
    location = user.location
    following = user.following
    followers = user.followers
    twitter = user.twitter
    appreciations = user.appreciations
    instagram = user.instagram
    github = user.github
    bio = user.bio
    location = user.location

    if request.method == 'POST':
      file = request.files['file']
      if file and allowed_file(file.filename.lower()):
          filename = secure_filename(file.filename)
          # newupload = Upload(filename, '/accounts/%s/%s' % (session['username'], filename), session['username'], request.form['title'], request.form['description'])
          newupload = Upload(filename, 'accounts/%s/%s' % (session['username'], filename), session['username'], "none", "none")
          db.session.add(newupload)
          db.session.commit()
          file.save(os.path.join(upload_folder, filename))
          return redirect(url_for('dashboard'))


    return render_template('dashboard.html', User=User, user=user, peopleFollowing=peopleFollowing, posts=posts, random_people=random_people, bio=bio, uploads=uploads, location=location,
                            github=github, instagram=instagram, username=username, firstname=firstname,
                            lastname=lastname, figure=figure, following=following,
                            followers=followers, twitter=twitter,
                            appreciations=appreciations)
예제 #45
0
 def get_random(self):
     return Lunch.query.order_by(func.rand()).first()
예제 #46
0
def dashboard():
    if 'username' not in session:
        return redirect(url_for('signin'))

    user = User.query.filter_by(username=session['username']).first()

    if user.verified == 0:
        print 'user is not verified'
        return redirect(url_for('verify'))

    if user.portfolioname == None or len(user.portfolioname.replace(' ',
                                                                    '')) < 1:
        print 'user does not have a portfolioname'
        return redirect(url_for('portfolioSetup'))

    user = User.query.filter_by(username=session['username']).first()
    uploads = Upload.query.filter_by(publisher=session['username'])

    following = Follow.query.filter_by(follower_username=session['username'])
    following_count = []
    for i in following:
        following_count.append(i)
    amount_of_following = len(following_count)
    user.following = amount_of_following
    db.session.commit()

    followers_count = []
    for person in User.query.all():
        followers = Follow.query.filter_by(followed_username=person.username)

        if followers != None:
            for i in followers:
                followers_count.append(i)

                amount_of_followers = len(followers_count)
                User.query.filter_by(username=person.username).first(
                ).followers = amount_of_followers
                db.session.commit()
        else:
            amount_of_followers = 0
            User.query.filter_by(username=person.username).first(
            ).followers = amount_of_followers
            db.session.commit()

    random_people = []

    for i in User.query.order_by(func.rand()).limit(2).all():
        random_people.append(i)

    #work on filtering posts

    peopleFollowing = []
    for i in Follow.query.filter_by(follower_username=session['username']):
        peopleFollowing.append(i.followed_username)

    posts_query = Posts.query.all()
    postsFollowing = [session['username']]

    for i in posts_query:
        if i.poster_username in peopleFollowing:
            postsFollowing.append(i.poster_username)

    posts = Posts.query.filter(Posts.poster_username.in_(postsFollowing))

    upload_folder = '/Users/developeraccount/Desktop/Lens/lens/src/static/accounts/%s' % session[
        'username']

    if user is None:
        return redirect(url_for('signin'))
    else:
        firstname = user.firstname
        lastname = user.lastname
        username = user.username
        figure = user.figure
        location = user.location
        following = user.following
        followers = user.followers
        twitter = user.twitter
        appreciations = user.appreciations
        instagram = user.instagram
        github = user.github
        bio = user.bio
        location = user.location

        if request.method == 'POST':
            file = request.files['file']
            if file and allowed_file(file.filename.lower()):
                filename = secure_filename(file.filename)
                # newupload = Upload(filename, '/accounts/%s/%s' % (session['username'], filename), session['username'], request.form['title'], request.form['description'])
                newupload = Upload(
                    filename,
                    'accounts/%s/%s' % (session['username'], filename),
                    session['username'], "none", "none")
                db.session.add(newupload)
                db.session.commit()
                file.save(os.path.join(upload_folder, filename))
                return redirect(url_for('dashboard'))

        return render_template('dashboard.html',
                               User=User,
                               user=user,
                               peopleFollowing=peopleFollowing,
                               posts=posts,
                               random_people=random_people,
                               bio=bio,
                               uploads=uploads,
                               location=location,
                               github=github,
                               instagram=instagram,
                               username=username,
                               firstname=firstname,
                               lastname=lastname,
                               figure=figure,
                               following=following,
                               followers=followers,
                               twitter=twitter,
                               appreciations=appreciations)
예제 #47
0
    def run(self):
        if self.experiment is None: return
        experiment = self.experiment
        db = self.db
        while True:
            job = None
            try:
                job = db.session.query(db.ExperimentResult) \
                        .filter_by(experiment=self.experiment) \
                        .filter_by(status=-1) \
                        .order_by(func.rand()).limit(1).first()
                job.status = 0
                db.session.commit()
            except:
                db.session.rollback()

            if job:
                job.startTime = func.now()
                db.session.commit()

                client_line = '/usr/bin/time -f ";time=%U;mem=%M;" '
                client_line += os.path.join(
                    PACKAGE_DIR, 'solvers',
                    launch_command(
                        job.solver_configuration,
                        os.path.join(
                            PACKAGE_DIR, 'instances',
                            str(job.instance.idInstance) + '_' +
                            job.instance.name), str(job.seed))[2:])

                print "running job", job.idJob, client_line
                stdout = open(os.path.join(TMP,
                                           str(job.idJob) + 'stdout~'), 'w')
                stderr = open(os.path.join(TMP,
                                           str(job.idJob) + 'stderr~'), 'w')
                start = time.time()

                p = subprocess.Popen(shlex.split(str(client_line)),
                                     preexec_fn=setlimits(
                                         self.experiment.CPUTimeLimit),
                                     stdout=stdout,
                                     stderr=stderr)

                returncode = p.wait()
                print "Job", job.idJob, "done .. Realtime:", str(time.time() -
                                                                 start), "s"
                stdout.close()
                stderr.close()

                stdout = open(os.path.join(TMP,
                                           str(job.idJob) + 'stdout~'), 'r')
                stderr = open(os.path.join(TMP,
                                           str(job.idJob) + 'stderr~'), 'r')
                time_output = stderr.read().split(';')
                runtime = float([
                    d.split('=')[1] for d in time_output
                    if d.startswith('time=')
                ][0])
                memory = int([
                    d.split('=')[1] for d in time_output
                    if d.startswith('mem=')
                ][0])

                job.solverOutput = stdout.read()
                stdout.close()
                stderr.close()
                os.remove(os.path.join(TMP, str(job.idJob) + 'stdout~'))
                os.remove(os.path.join(TMP, str(job.idJob) + 'stderr~'))

                job.resultTime = runtime

                #cpuinfo = open('/proc/cpuinfo')
                #job.solverOutput = cpuinfo.read()
                #cpuinfo.close()

                print "  retcode", returncode

                if returncode != 10 and returncode != 0:  # CPU Time limit exceeded exit code guess
                    job.status = 21
                else:
                    job.status = 1
                    if 's SATISFIABLE' in job.solverOutput:
                        job.resultCode = 11
                print "  CPU time:", runtime, "s", "Memory used:", memory, "kB"
                job.computeQueue = self.experiment.grid_queue[0].idgridQueue
                db.session.commit()
            else:
                if db.session.query(db.ExperimentResult) \
                        .filter_by(experiment=self.experiment) \
                        .filter_by(status=-1) \
                        .order_by(func.rand()).count() == 0:
                    break  # no more jobs
예제 #48
0
def respond():
    """Respond to incoming texts"""

    resp = twilio.twiml.Response()

    incoming_msg = request.values.get('Body', '')

    # this clears all cookies
    if(incoming_msg.lower()=='clear'):
        session['seen_intro'] = False
        session['seen_prompt'] = False
        session['gave_ans'] = False
        session['extra_msg'] = False
        resp.sms("erasing my memory of our conversation")
        return str(resp)


    # # if exchange has been completed
    # if session.get('extra_msg',False):
    #     session['extra_msg'] = False
    #     if incoming_msg.lower().startswith('y'):
    #         session['seen_prompt'] = False
    #         session['gave_ans'] = False
    #     elif incoming_msg.lower().startswith('n'):
    #         # TODO: ask for feedback?
    #         resp.sms('ok, later!')
    #         return str(resp)



    if not session.get('seen_prompt',False):
        # if this is the original interaction with a bot
        if not session.get('seen_intro', False):
            resp.sms("hello friend - nice to meet you! i'm a self-care SMS bot (:\n\nreply with life advice, self-care tips, or a compliment to send to a stranger, and you'll get texted some nice things by someone in return! <3")
            session['seen_intro'] = True
        # if the user is submitting additional fortunes
        else:
            resp.sms("reply with life advice, self-care tips, or a compliment to send to a stranger, and you'll get texted some nice things by someone in return! <3")

        session['seen_prompt'] = True

    elif not session.get('gave_ans',False):
        # saving answer here
        if incoming_msg: # only if there is a msg
            new_ans = Answer(request.values.get('SmsSid'), request.values.get('From'), incoming_msg)
            # TODO: error handling here
            db.session.add(new_ans)
            db.session.commit()

        # grabbing a fortune from a stranger
        # TODO: ensure that this is not a fortune from yourself
        random_ans = Answer.query.filter_by(is_approved=True)\
                                .filter((Answer.from_number!=request.values.get('From'))|(Answer.from_number == None))\
                                .order_by(func.rand())\
                                .first()

        if random_ans:
            resp.sms("what a lovely message! here's what someone submitted for you:\n\n%s" %random_ans.answer_text)

            if incoming_msg: # only if there is a msg
                random_ans.view_count = random_ans.view_count+1
                db.session.add(random_ans)
                db.session.commit()

                # alerting rec-giver when rec has been seen for the first time
                if random_ans.from_number and random_ans.view_count==1:
                    client = TwilioRestClient(
                                CONFIG_VARS['TWILIO_ACCOUNT_SID'],
                                CONFIG_VARS['TWILIO_AUTH_TOKEN']
                            )
                    msg = "hey! just wanted to let you know that your message has been sent to a stranger! <3 "
                    message = client.messages.create(
                                to=random_ans.from_number,
                                from_=CONFIG_VARS['TWILIO_PHONE_NO'],
                                body=msg
                            )
        else:
            resp.sms("sorry, there doesn't seem to be any messages in the queue right now! but I hope you have a lovely day nonetheless <3")

        # session['gave_ans'] = True
    elif not session.get('extra_msg',False):
        session['extra_msg'] = True
        resp.sms("if you want another message, text me again tomorrow! have a lovely rest of the day <3 ")
    else:
        return ''


    return str(resp)
예제 #49
0
def explore():
    photos = Photo.query.order_by(func.rand()).limit(12)
    return render_template("main/explore.html", photos=photos)
예제 #50
0
 def get_random_question(self):
     q = self.session.query(Question).filter(Question.is_fetch == False and Question.answernum >= 5).order_by(func.rand()).limit(10)
     print(q.first())
     return q.first()
예제 #51
0
 def get_random(self):
     return Starter.query.order_by(func.rand()).first()
예제 #52
0
def getRandomBookingIDs(numberToGet):
    teleData = telemetry.query.order_by(func.rand()).limit(numberToGet).all()
    return (teleData)
예제 #53
0
 def get(self):
     user = self.current_user
     users = db.query(User).order_by(
         func.rand()).filter(User.id != user.id).limit(9).all()
     self.render("user/referrers.html", users=users)
     return
예제 #54
0
 def search_random(cls, **kwargs):
     return cls._search(**kwargs).order_by(func.rand())