def article(article_slug): article = Article.query.filter(Article.slug == article_slug).first() if not article.published: abort(403) article.views += 1 db.session.add(article) db.session.commit() from sqlalchemy.sql.expression import func related_articles = Article.query.search(article.keywords[0]).\ filter(Article.id != article.id).order_by(func.random()).limit(3) _base_query = Article.query.public() # Tags tags = Tag.query.order_by(Tag.views.desc()).all() # recommended articles top 5 recommended_articles = _base_query.filter_by(recommended=True).limit(9) popular_articles = _base_query.\ order_by(Article.views.desc()).limit(9) random_articles = _base_query.order_by(func.random()).limit(9) return render_template('article.html', article=article, tags=tags, related_articles=related_articles, recommended_articles=recommended_articles, popular_articles=popular_articles, random_articles=random_articles)
def profile_product_redirect(attr_type): '''fetch random product''' if attr_type == "hs": p = getattr(attr_models, attr_type.capitalize()).query.order_by(func.random()).first_or_404() else: p = getattr(attr_models, attr_type.capitalize()).query.order_by(func.random()).first_or_404() return redirect(url_for(".profile_product", attr_type=attr_type, attr_id=p.get_display_id()))
def motive(): prefix = Prefix.query.order_by( func.random() ).first() if 'GET' == request.method : m = Madlib.query.order_by( func.random() ).first() else: m = Madlib.query.get( request.form['madlib_id'] ) sentence = m.text regex = re.compile( r"\{\{(.+?)\}\}" ) if 'GET' == request.method : # fill in with random words from the dictionary sentence = regex.sub( fill_in_word, sentence ) else: # for each match, replace with next word in submitted form tags = regex.findall( sentence ) i=0 for tag in tags: word = request.form["madlib-blank-" + str( i )].strip() i += 1 # entering blanks means we pick a random word if '' == word: t = Tag.query.filter( Tag.text == tag ).first() if None is t or [] == t.words: word = tag word = choice( t.words ).text else: # add new words to the dictionary # force to lowercase unless it's a proper noun if tag not in ['person', 'place'] : word = word.lower() w = Word.query.filter( Word.text == word ).first() if None is w: w = Word( word, [ tag ] ) db_session.add( w ) else: # add these tags if they don't exist t = Tag.query.filter( Tag.text == tag ).first() w.tags.append( t ) sentence = sentence.replace( "{{" + tag + "}}", word, 1 ) db_session.commit() # TODO save generated sentence for posterity - maybe only on up-vote? return render_template( 'motive.html', prefix=prefix, motivation=sentence )
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()
def feed_discover(): off = request.args.get("start_index") if off: entries = db.session.query(db.Books).order_by(func.random()).offset(off).limit(config.NEWEST_BOOKS) else: entries = db.session.query(db.Books).order_by(func.random()).limit(config.NEWEST_BOOKS) off = 0 xml = render_template('feed.xml', entries=entries, next_url="/feed/discover?start_index=%d" % (int(config.NEWEST_BOOKS) + int(off))) response = make_response(xml) response.headers["Content-Type"] = "application/xml" return response
def recommend_repos_for_user(username, limit=10): """ 1. store user stars to db if not there yet 2. find 10 most similar users in db 3. get 10 most starred repo of these users (not starred yet) :param username: :return: [repo object, ...] """ user = User.query.filter_by(username=username).first() if not user: store_user_data(username) user_repo_map = dict() repos_enc = set() user_list = list(User.query.order_by(func.random()).limit(100).options(joinedload('repos'))) for u in user_list + [user]: user_repo_map[u.id] = set() for repo in u.repos: user_repo_map[u.id].add(repo.id) repos_enc.add(repo.id) repos_enc = list(repos_enc) user_repo_enc = { u.id: [bool(repo_id in user_repo_map[u.id]) for repo_id in repos_enc] for u in user_list + [user] } user_scores = [] for u in user_list: user_scores.append((u.id, jscore(user_repo_enc[u.id], user_repo_enc[user.id]))) user_scores.sort(key=lambda item: item[1], reverse=True) repo_count_map = defaultdict() for uid, score in user_scores[1:30]: for repo in user_repo_map[uid]: if repo in user_repo_map[user.id]: continue if repo not in repo_count_map: repo_count_map[repo] = 0 repo_count_map[repo] += 1 repo_id_list = [repo_id for repo_id, _ in sorted( repo_count_map.items(), key=lambda item: item[1], reverse=True )][:limit] return Repo.query.filter(Repo.id.in_(repo_id_list)).order_by(func.random()).values('name', 'url')
def category(slug, page=1): category = Category.query.filter_by(slug=slug).first() _base_query = Article.query.public().filter_by(category=category) all_articles = _base_query.order_by(Article.created_at.desc()).\ paginate(page, Article.PER_PAGE, False).items # Tags tags = Tag.query.order_by(Tag.views.desc()).all() # recommended articles top 5 recommended_articles = _base_query.filter_by(recommended=True).limit(5) popular_articles = _base_query.\ order_by(Article.views.desc()).limit(5) from sqlalchemy.sql.expression import func random_articles = _base_query.order_by(func.random()).limit(5) return render_template('index.html', page=page, tags=tags, category=category, all_articles=all_articles, recommended_articles=recommended_articles, popular_articles=popular_articles, random_articles=random_articles)
def return_radom_question_set(n): """ It goes through the question bank and selects n random Questions along with it's answer list it also randomizes the answer choice sequence """ #select.order_by(func.random()) questions= Questions.query.order_by(func.random()).first() #print (questions.question) #print (questions) questions_answers = Questions.query.order_by(func.random()).join(Answers).limit(3) # questions_answers = Questions.query.rder_by(func.random()).join(Answers).limit(10) for k in questions_answers : print (k.question) #print (questions_answers.column_descriptions) q_a= Questions.query.join(Answers)
def schedule_yuyue(s): user_list = s.query(User).filter( User.flag == True, User.yuyue_cnt < User.req_yuyue_cnt, # 已经预约量小于预约总数 User.yuyue_start_time < time.time(), # 开始时间到了吗 User.last_yuyue_time + User.yuyue_interval + random.randint(157, 678) < time.time(), # 评价时间间隔,并且加上随机性 User.yuyue_per_day_cnt < User.rdm_yuyue_per_day_cnt, # 每天预约量小于客户每天规定的预约量 # User.yuyue_per_day_cnt < User.req_yuyue_cnt / User.req_day_cnt # 今天预约量是否够了,不够的才继续 ).order_by(func.random()).all() len_user = len(user_list) if not len_user: print u'当前没有符合条件的预约yy' return True print u'共有预约人数:', len_user idx_cnt = 0 for user in user_list: if len(user.urls) == 0: print user.id, u'没有urls' continue print #global_adsl.reconnect() # adsl重连 # time.sleep(3) idx_cnt += 1 print datetime.now(), '约第', idx_cnt, '/', len_user, '个人:', user.shop_id, user.id, user.qq, user.wangwang, user.company, ',原来约:', user.original_yuyue_cnt, '已经约:', user.yuyue_cnt, ',今天约了:', user.yuyue_per_day_cnt, ',今天还要约:', user.rdm_yuyue_per_day_cnt - user.yuyue_per_day_cnt # random_url = random.choice([url for url in user.urls if url.flag == True]) random_url = random.choice(user.urls) try: m_yuyue(s, user, random_url.href) except Exception, e: print e print traceback.format_exc() continue # time.sleep(random.randint(1, 5)) pass
def getRandomFeatureId(self, bodId): models = models_from_bodid(bodId) with self.getSession() as session: t = session.query(models[0]).limit(500).subquery('t') query = session.query(t).order_by(func.random()).limit(1) reslt = query.one() return reslt[0]
def classifier(): user = current_user exp = request.args.get('experiment', 'creativity') eclass = experiment_classes[exp] pattern = experiment_classes[exp]['pattern'] classes = experiment_classes[exp]['labels'] if request.method == 'POST': if 'class' in request.form: labels = request.form.getlist('class') value = 1 img_id = int(request.form['img_id']) for label in labels: db.session.add(Classification(img_id=img_id, user_id=user.id, label=label, value=value)) db.session.commit() q_existing = db.session.query(Classification, Image).filter(Classification.user_id==user.id).filter(Image.id==Classification.img_id) q_existing = q_existing.subquery() q_existing = aliased(Image, q_existing) q_existing = Image.query.join(q_existing) q_all = Image.query.filter(Image.url.like(pattern)) q = q_all.except_(q_existing) q = q.order_by(func.random()) nb = q.count() if nb == 0: return render_template('done.html') q = q.limit(1) img = q.one() img.url = parse(img.url) return render_template('classify_one.html', img=img, classes=classes, w=eclass.get('w', 250), h=eclass.get('h', 250), page_width=eclass.get('page_width'), nb=nb)
def build_msg(cursor, speaker, start): location = 'target' if speaker.startswith('#') else 'source' count = cursor.query(Babble_count).filter(Babble_count.type == location, Babble_count.key == speaker).first() if count is None: return "%s hasn't said anything =(" % speaker markov = cursor.query(Babble).filter(getattr(Babble, location) == speaker).offset(random.random() * count.count).first() if start is None: prev = markov.key else: # FIXME: use Babble_count? if len(start) == 1: markov = cursor.query(Babble).filter(Babble.key.like(start[0] + ' %')) elif len(start) == 2: markov = cursor.query(Babble).filter(Babble.key == " ".join(start)) else: return "Please specify either one or two words for --start" markov = markov.filter(getattr(Babble, location) == speaker).order_by(func.random()).first() if markov: prev = markov.key else: return "%s hasn't said %s" % (speaker, " ".join(start)) msg = prev while len(msg) < 256: data = cursor.query(Babble).filter(Babble.key == prev, getattr(Babble, location) == speaker).all() if not data: break next_word = weighted_next(data) msg = "%s %s" % (msg, next_word) prev = "%s %s" % (prev.split()[1], next_word) return "%s says: %s" % (speaker, msg)
def mark_available_phrases( user_id: int, language: str, limit: int) -> List[int]: phrases = db.session.query( Phrase.id ).filter( Phrase.user_id == user_id, Phrase.language == language, Phrase.status == Phrase.Status.visible.value, Phrase.date_available < datetime.now(), Phrase.progress_status < Phrase.ProgressStatus.after_two_week.value, ).order_by( func.random() ).limit(limit) phrase_ids = [phrase.id for phrase in phrases] if not phrase_ids: return [] redis_store.lpush( PHRASE_REDIS_KEY_TEMPLATE.format( user_id=user_id, language=language, ), *phrase_ids ) return phrase_ids
def visualize_redirect(app_name='tree_map'): '''fetch random country''' c = Country.query.get(choice(random_countries)) latest_hs_year = [available_years['hs92'][-1]] if app_name in ["tree_map", "stacked", "network"]: year = [available_years['hs92'][0], available_years['hs92'][-1]] if app_name == "stacked" else latest_hs_year redirect_url = url_for('.visualize', lang=g.locale, app_name=app_name, \ classification="hs92", trade_flow="export", \ origin_id=c.id_3char, dest_id="all", prod_id="show", year=year) elif app_name in ["geo_map", "rings"]: '''fetch random product''' p = Hs92.query.filter(Hs92.hs92 != None).filter(func.length(Hs92.hs92) == 4) \ .order_by(func.random()).limit(1).first() origin = "show" if app_name == "rings": origin = c.id_3char redirect_url = url_for('.visualize', lang=g.locale, app_name=app_name, \ classification="hs92", trade_flow="export", \ origin_id=origin, dest_id="all", prod_id=p.hs92, year=latest_hs_year) elif app_name in ["scatter"]: redirect_url = url_for('.visualize', lang=g.locale, app_name=app_name, \ classification="hs92", trade_flow="gdp", \ origin_id="show", dest_id="all", prod_id="all", year=latest_hs_year) else: abort(404) return redirect(redirect_url)
def get_issues(id=None): '''Regular response option for issues. ''' filters = request.args filters, querystring = get_query_params(request.args) if id: # Get one issue filter = Issue.id == id issue = db.session.query(Issue).filter(filter).first() if issue: return jsonify(issue.asdict(True)) else: # If no issue found return jsonify({"status": "Resource Not Found"}), 404 # Get a bunch of issues query = db.session.query(Issue).order_by(func.random()) for attr, value in filters.iteritems(): if 'project' in attr: proj_attr = attr.split('_')[1] query = query.join(Issue.project).filter(getattr(Project, proj_attr).ilike('%%%s%%' % value)) elif 'organization' in attr: org_attr = attr.split('_')[1] query = query.join(Issue.project).join(Project.organization).filter(getattr(Organization, org_attr).ilike('%%%s%%' % value)) else: query = query.filter(getattr(Issue, attr).ilike('%%%s%%' % value)) response = paged_results(query, int(request.args.get('page', 1)), int(request.args.get('per_page', 10)), querystring) return jsonify(response)
def sort_columns(self): return util.unalias_dict({ 'random': (func.random(), None), 'id': (db.Post.post_id, self.SORT_DESC), 'score': (db.Post.score, self.SORT_DESC), 'tag-count': (db.Post.tag_count, self.SORT_DESC), 'comment-count': (db.Post.comment_count, self.SORT_DESC), 'fav-count': (db.Post.favorite_count, self.SORT_DESC), 'note-count': (db.Post.note_count, self.SORT_DESC), 'relation-count': (db.Post.relation_count, self.SORT_DESC), 'feature-count': (db.Post.feature_count, self.SORT_DESC), 'file-size': (db.Post.file_size, self.SORT_DESC), ('image-width', 'width'): (db.Post.canvas_width, self.SORT_DESC), ('image-height', 'height'): (db.Post.canvas_height, self.SORT_DESC), ('image-area', 'area'): (db.Post.canvas_area, self.SORT_DESC), ('creation-date', 'creation-time', 'date', 'time'): (db.Post.creation_time, self.SORT_DESC), ('last-edit-date', 'last-edit-time', 'edit-date', 'edit-time'): (db.Post.last_edit_time, self.SORT_DESC), ('comment-date', 'comment-time'): (db.Post.last_comment_creation_time, self.SORT_DESC), ('fav-date', 'fav-time'): (db.Post.last_favorite_time, self.SORT_DESC), ('feature-date', 'feature-time'): (db.Post.last_feature_time, self.SORT_DESC), })
def category(name): random = db.session.query(db.Books).order_by(func.random()).limit(config.RANDOM_BOOKS) if name != "all": entries = db.session.query(db.Books).filter(db.Books.tags.any(db.Tags.name.like("%" +name + "%" ))).order_by(db.Books.last_modified.desc()).all() else: entries = db.session.query(db.Books).all() return render_template('index.html', random=random, entries=entries, title="Category: %s" % name)
def preview(self, article_id): article = Article.query.get_or_404(article_id) related_articles = Article.query.search(article.keywords). \ filter(Article.id != article.id).limit(3) _base_query = Article.query.public() # Tags tags = Tag.query.order_by(Tag.views.desc()).limit(10) # recommended articles top 5 recommended_articles = _base_query.filter_by(recommended=True).limit(5) popular_articles = _base_query. \ order_by(Article.views.desc()).limit(5) from sqlalchemy.sql.expression import func random_articles = _base_query.order_by(func.random()).limit(5) return self.render('article.html', article=article, tags=tags, related_articles=related_articles, recommended_articles=recommended_articles, popular_articles=popular_articles, random_articles=random_articles)
def get_questions(api_key='',method=1): ''' Accepts api_key and a paramteter method. Method determines the criteria by which the questions are generated.Currently only one method is de- fined. "1 Random Question Selection" ''' #-- Selects 1000 questions at random if method ==1: questions = Question.query.order_by(func.random()).limit(100).all() #questions = questions[1:100] return (questions,1) #-- Action corresponding to method 2 elif method == 2: # pass questions = [] for c in Category.query.all(): question_list = c.questions random.shuffle(question_list) if len(question_list) > 20 : question_list = question_list[0:20] for q in question_list: if q.question not in questions: questions.append(q.question) return (questions,2) #-- Action corresponding to method 3 etc, elif method == 3: pass else: pass
def index(page=1): _base_query = Article.query.public() # Latest 10 articles template_name = 'index.html' if page == 1 else 'includes/items.html' all_articles = _base_query.order_by(Article.created_at.desc()).\ paginate(page, Article.PER_PAGE, False).items # Tags tags = Tag.query.order_by(Tag.views.desc()).all() slides = _base_query.filter_by(slider=True).order_by( Article.created_at.desc()).limit(5) # recommended articles top 5 recommended_articles = _base_query.filter_by(recommended=True).limit(9) popular_articles = _base_query.\ order_by(Article.views.desc()).limit(9) from sqlalchemy.sql.expression import func random_articles = _base_query.order_by(func.random()).limit(9) return render_template(template_name, all_articles=all_articles, recommended_articles=recommended_articles, popular_articles=popular_articles, random_articles=random_articles, slides=slides, tags=tags, page=page)
def madlib(): m = Madlib.query.order_by( func.random() ).first() regex = re.compile( r"\{\{(.+?)\}\}" ) blanks = regex.findall( m.text ) return render_template( 'madlib.html', madlib=m, blanks=blanks )
def sorting(request): session=DBSession() if request.method == "GET": #length_table=session.query(func.count(Item.id)).scalar() #randoms=random.sample(range(1,length_table+1),2) #first=session.query(Item).order_by(Item.id).offset(random).first() #second=session.query(Item).order_by(Item.id).offset(random) #query1=session.query(Item).filter_by(id=randoms[0]+1) #results = session.query(Item).filter(Item.id.in_(randoms)).all() results = session.query(Item).order_by(func.random()).limit(2).all() #item1=query1.one() #query2=session.query(Item).filter_by(id=randoms[1]+1) #item2=query2.one() id1=results[0].id id2=results[1].id name1=results[0].name name2=results[1].name data1=results[0].data disp_data1="%0.2f" % (data1-5) data2=results[1].data disp_data2="%0.2f" % (data2-5) url1=results[0].url url2=results[1].url dist=(data2-data1)/400 corr1=decimal.Decimal(math.exp(-((data1-10)**2)/3)) corr2=decimal.Decimal(math.exp(-((data2-10)**2)/3)) return {'disp_data1':disp_data1,'disp_data2':disp_data2, 'dist':dist, 'id1':id1,'id2':id2,'results':results, 'name1':name1,'name2':name2, 'data1':data1,'data2':data2, 'url1':url1,'url2':url2} if request.method == "POST": post_data=request.POST #output=post_data.get('myradio') key1=request.params['id1'] key2=request.params['id2'] #dist=float(request.params['dist']) data1=decimal.Decimal(request.params['data1']) data2=decimal.Decimal(request.params['data2']) dist=data2-data1 corr1=decimal.Decimal(math.exp(-((data1-10)**2)/5)) corr2=decimal.Decimal(math.exp(-((data2-10)**2)/5)) randoms=[key1,key2] #results = session.query(Item).filter(Item.id.in_(randoms)).all() result1= session.query(Item).filter(Item.id==key1).one() result2= session.query(Item).filter(Item.id==key2).one() x=3 print dist if request.params["form"] == "form1": result1.data=result1.data+(1-(1/(1+10**dist)))*corr1*x result2.data=result2.data+(0-(1/(1+10**(-1*dist))))*corr2*x return HTTPFound(location=request.route_url('sorting')) if request.params["form"] == "form2": result1.data=result1.data+(0-(1/(1+10**dist)))*corr1*x result2.data=result2.data+(1-(1/(1+10**(-1*dist))))*corr2*x return HTTPFound(location=request.route_url('sorting')) return {'results':results, 'randoms':randoms}
def get(self): session = Session() messages = list(session.query(Message).order_by(func.random()).limit(100)) messages.append(Message(content='Hello, World!')) messages.sort(key=lambda m: m.content) response = loader.load('template.html').generate(messages=messages) session.close() self.write(response)
def find_participants(n=2): bots = list(db.query(Bot).order_by(func.random()).limit(n)) if len(bots) != n: raise LookupError('Not enough bots found in database') logging.info('Letting %s fight', bots) return bots
def search(): term = request.args.get("query") if term: random = db.session.query(db.Books).order_by(func.random()).limit(config.RANDOM_BOOKS) entries = db.session.query(db.Books).filter(db.or_(db.Books.tags.any(db.Tags.name.like("%"+term+"%")),db.Books.series.any(db.Series.name.like("%"+term+"%")),db.Books.authors.any(db.Authors.name.like("%"+term+"%")),db.Books.title.like("%"+term+"%"))).all() return render_template('search.html', searchterm=term, entries=entries) else: return render_template('search.html', searchterm="")
def index(): landing_image = ImageLink.query.get(Config.query.first().landing_image_id) sponsors = Sponsor.query.order_by(func.random()).limit(3).all() front_page = { 'projects': [i.serialize for i in Project.query .order_by(func.random()).limit(2)], 'events': [i.content for i in Event.query.all()], 'sticky': [i.serialize for i in Post.query.filter_by(sticky=True) .order_by(Post.date.desc())], 'recent': [i.serialize for i in Post.query.filter_by(sticky=False) .order_by(Post.date.desc()).limit(10)] } return render_template('index.html', landing_image=landing_image.link, sponsors=sponsors, front_page=front_page)
def get_solve_task(): sess = db.Session() task_id = request.args.get('task') if task_id: task = sess.query(db.OpenTask).filter(db.OpenTask.id == task_id).first() else: task = sess.query(db.OpenTask).filter(db.OpenTask.solved == False).order_by(func.random()).limit(1).first() user_id = session.get("user_id") or "" return render_template("solve_task.html", task=task, user_id=user_id)
def get_comments_for_training(self, limit=None): # Using 'subreddit' as placeholder for username - should be changed comments = (db.query(Comment) .filter_by(author=self.subreddit) .order_by(func.random()) ) valid_comments = [comment for comment in comments if self.should_include_comment(comment)] return valid_comments
def index(page): random = db.session.query(db.Books).order_by(func.random()).limit(config.RANDOM_BOOKS) if page == 1: entries = db.session.query(db.Books).order_by(db.Books.last_modified.desc()).limit(config.NEWEST_BOOKS) else: off = int(int(config.NEWEST_BOOKS) * (page - 1)) entries = db.session.query(db.Books).order_by(db.Books.last_modified.desc()).offset(off).limit(config.NEWEST_BOOKS) pagination = Pagination(page, config.NEWEST_BOOKS, len(db.session.query(db.Books).all())) return render_template('index.html', random=random, entries=entries, pagination=pagination, title="Latest Books")
def get_comments_for_training(self, limit=None): comments = (db.query(Comment) .filter_by(subreddit=self.subreddit) .order_by(func.random()) .limit(Settings["max corpus size"]) ) valid_comments = [comment for comment in comments if self.should_include_comment(comment)] return valid_comments
def __init__(self, full_game=False, double_jeopardy=False): self.categories = {} self.round = Round.query.filter_by(name="Jeopardy!").first() self.full_game = full_game self.double_jeopardy = double_jeopardy self.unanswered_questions = 30 first_question_value = 200 # Set to double jeopardy accordingly if double_jeopardy: self.round = Round.query.filter_by(name="Double Jeopardy!").first() first_question_value = 400 while len(self.categories) < 6: # Find a random category in the chosen round that hasn't been chosen already, check to ensure this category has 5 clues category = None while category is None or category in self.categories: category = Category.query.filter_by( round_id=self.round.id).order_by(func.random()).first() if Clue.query.filter_by(round_id=self.round.id, category_id=category.id).count() < 5: category = None # Get category clues; break out of loop early (e.g < 5 categories) if we can't find all 5 clue values for category self.categories[category.name] = {} cur_value = first_question_value while len(self.categories[category.name]) < 5: clue = Clue.query.filter_by( round_id=self.round.id, category_id=category.id, value_id=Value.query.filter_by( value=cur_value).first().id).first() if clue is None: break # Create dictionary of clue data self.categories[category.name][clue.value.value] = { "id": clue.id, "round": clue.round.name, "category": clue.category.name, "value": clue.value.value, "question": clue.question, "answered": False, "answer": clue.answer, "air_date": clue.air_date.air_date } cur_value += first_question_value # Ensure we got all 5 clues; if not, delete category and we need to start over if len(self.categories[category.name]) < 5: del self.categories[category.name]
def setup(): def find_sentence(word): if len(word.sentence) < 3: url = "https://twinword-word-graph-dictionary.p.rapidapi.com/example/" querystring = {"entry": word.word} headers = { 'x-rapidapi-host': "twinword-word-graph-dictionary.p.rapidapi.com", 'x-rapidapi-key': os.getenv('RAPID_API_KEY') } response = requests.request("GET", url, headers=headers, params=querystring) raw_sentence_response = response.json() while True: index_choice = random.choice( range(len(raw_sentence_response["example"]))) sentence_response = raw_sentence_response["example"][ index_choice] if Sentence.query.filter_by( example=sentence_response).count() == 0: break sentence = Sentence(example=sentence_response, from_api=True, word_id=word.id) sentence.save() return sentence.example else: return random.choice(word.sentence).example if not request.data: return make_response(jsonify(error="Missing token."), 400) token = str(request.json.get('token', '')) user = User.query.filter_by(token=token) if user.count() > 0: words = Word.query.order_by(func.random()).limit(64) random_words = [] for word in words: sentence = find_sentence(word) random_words.append({"word": word.word, "sentence": sentence}) return jsonify(random_words) else: return make_response(jsonify(error="User not found."), 404)
def sort_columns(self): return { 'random': (func.random(), None), 'user': (db.User.name, self.SORT_ASC), 'author': (db.User.name, self.SORT_ASC), 'post': (db.Comment.post_id, self.SORT_DESC), 'creation-date': (db.Comment.creation_time, self.SORT_DESC), 'creation-time': (db.Comment.creation_time, self.SORT_DESC), 'last-edit-date': (db.Comment.last_edit_time, self.SORT_DESC), 'last-edit-time': (db.Comment.last_edit_time, self.SORT_DESC), 'edit-date': (db.Comment.last_edit_time, self.SORT_DESC), 'edit-time': (db.Comment.last_edit_time, self.SORT_DESC), }
def get_quiz_next_question(): body = request.get_json() previous_questions = body.get('previous_questions', None) quiz_category = body.get('quiz_category', None) if previous_questions is None or quiz_category is None: abort(400) try: quiz_category_id = int(quiz_category["id"]) except (KeyError, ValueError): abort(400) if (not isinstance(previous_questions, list) and all( isinstance(previous_question, int) for previous_question in previous_questions)): abort(400) if len(previous_questions) > 0: if quiz_category_id is 0: next_question = (Question.query.filter( ~Question.id.in_(previous_questions)).order_by( func.random()).first_or_404()) else: next_question = (Question.query.filter( Question.category == quiz_category_id, ~Question.id.in_(previous_questions)).order_by( func.random()).first_or_404()) else: if quiz_category_id is 0: next_question = (Question.query.order_by( func.random()).first_or_404()) else: next_question = (Question.query.filter( Question.category == quiz_category_id).order_by( func.random()).first_or_404()) return jsonify({"success": True, "question": next_question.format()})
def all_tutors_view(): tutors = Tutor.query.order_by(func.random()).all() form = SortTutorsForm() if form.validate_on_submit(): if form.select_sort.data == "rating": tutors = Tutor.query.order_by(Tutor.rating.desc()).all() elif form.select_sort.data == "price_desc": tutors = Tutor.query.order_by(Tutor.price.desc()).all() elif form.select_sort.data == "price_asc": tutors = Tutor.query.order_by(Tutor.price).all() return render_template("all.html", tutors=tutors, form=form)
def category(name): random = db.session.query(db.Books).order_by(func.random()).limit( config.RANDOM_BOOKS) if name != "all": entries = db.session.query(db.Books).filter( db.Books.tags.any(db.Tags.name.like("%" + name + "%"))).order_by( db.Books.last_modified.desc()).all() else: entries = db.session.query(db.Books).all() return render_template('index.html', random=random, entries=entries, title="Category: %s" % name)
def viewCommunity(): users = User.query.order_by(func.random()).limit(20).all() user_icons = [] for user in users: user_icon = user.user_icon if user_icon: user_icons.append(b64encode(user_icon).decode('utf-8')) else: user_icons.append(None) teams = Team.query.order_by(func.random()).limit(20).all() team_icons = [] team_chorusbattles = [] for team in teams: team_logo = team.team_logo if team_logo: team_icons.append(b64encode(team_logo).decode('utf-8')) else: team_icons.append(None) team_chorusbattles.append(ChorusBattle.query.filter_by(id=team.chorusbattle).first().name) print(users, teams) return render_template('community.html', users=users, user_icons=user_icons, teams=teams, team_chorusbattles=team_chorusbattles, \ team_icons=team_icons, icon=getUserIcon((session['username'] if 'username' in session else None)))
def random_dinger(): """Returns a random home run """ play = Play.query.order_by(func.random()) team = request.args.get('team') if team is not None: play = play.filter(Play.batter_team == team) play = play.first() return JsonResponse(serialize_play(play))
def get_quiz_questions(): previous_questions = request.json.get('previous_questions') quiz_category = request.json.get('quiz_category') if quiz_category is None: return abort(404) category_id = Question.query.filter( Question.category == category_id, Question.id.in_(previous_questions)) if category_id else \ Question.query.filter(Question.id.in_(previous_questions)) question = questions.order_by(func.random()).first() if not question: return jsonify({}) return jsonify({'question': question.format()})
def test_delete_question_valid_id(self): test_id = Question.query.order_by(func.random()).first().id total_before = len(Question.query.all()) response = self.client().delete('/questions/{}'.format(test_id)) data = json.loads(response.data) total_after = len(Question.query.all()) # check response self.assertEqual(response.status_code, 200) self.assertEqual(data['success'], True) # check response body self.assertEqual(data['deleted'], test_id) # check database changes self.assertEqual(total_before - 1, total_after)
def index(): categories = db.session.query(CategoryModel).all() cat_meals_dict = {} # формируем список их 3х товаров по каждой из категорий for category in categories: meals = db.session.query(MealModel) \ .filter(MealModel.category == category) \ .order_by(func.random()) \ .limit(3) \ .all() cat_meals_dict[category] = meals return render_template('main.html', meals=cat_meals_dict, session=session)
def get_three_reviews(restaurant_id): """ Given the restaurant_di return three random reviews """ reviews = ( db.session.query(Review) .filter_by(restaurant_id=restaurant_id) .order_by(func.random()) .limit(3) .all() ) return reviews
def home_view(request): """View for home route.""" session = request.dbsession real_tweet = session.query(Tweet).order_by(func.random()).first() fake_tweet = gen_tweet() if request.method == "POST" and request.POST: new_entry = FakeTweet(faketweet=request.POST['fakeTweet'], tweeted=False, shown=1, chosen=1) request.dbsession.add(new_entry) return {} return {'page': 'Home', 'real': real_tweet.tweet, 'fake': fake_tweet}
def add_word(word_list, n): if not word_list: word = db.session.query(models.UpperWords).order_by( func.random()).first().word #postgre elif len(word_list) <= n: word = get_word(word_list, len(word_list)) else: word = get_word(word_list, n) if word: word_list.append(word) return True else: return False
def category_menu(self): """Display categories for the user Returns: str: Return a list of choices """ q = session.query(Category.category_name).order_by( func.random()).limit(6).all() print(Fore.GREEN + "\n------ Catégories ------\n") for n, category_name in enumerate(q): print(f"{n} - {category_name}") choice = input("Choissisez une option:") return self.main_menu
def _gallery_orderby(model_name, capture=db.model_name(db.Gallery)): return { ItemSort.GalleryRandom.value: (func.random(), ), ItemSort.GalleryTitle.value: (db.Title.name, ), ItemSort.GalleryArtist.value: (db.ArtistName.name, ), ItemSort.GalleryDate.value: (db.Gallery.timestamp, ), ItemSort.GalleryPublished.value: (db.Gallery.pub_date, ), ItemSort.GalleryRead.value: (db.Gallery.last_read, ), ItemSort.GalleryUpdated.value: (db.Gallery.last_updated, ), ItemSort.GalleryRating.value: (db.Gallery.rating, ), ItemSort.GalleryReadCount.value: (db.Gallery.times_read, ), ItemSort.GalleryPageCount.value: (db.func.count(db.Page.id), ), }
def random_food(): food = Foods.query.filter_by(food_type="main_course").order_by( func.random()).first() obj = dict() obj['id'] = food.id obj['food_id'] = food.food_id obj['food_type'] = food.food_type obj['food_name'] = food.food_name obj['food_image'] = food.food_image obj['ingredients'] = food.ingredients obj['recipe'] = food.recipe return jsonify({"result": obj})
def get_random(): limit = request.args.get('limit') try: limit = int(limit) except Exception: limit = 100 query = db.session.query(Staff).filter(Staff.type == 0).order_by( func.random()).limit(limit) temp = [] for s in query: temp.append(s.to_json()) res = ResponseMsg(temp) return res.json_body()
def quizzes(): body = request.get_json() app.logger.info(body) prev = [data for data in body.get('previous_questions')] app.logger.info(prev) if body.get('quiz_category') is None: abort(400) elif body.get('quiz_category').get('id') == 0: next_ques = Question.query.filter( Question.id.notin_(prev)).order_by(func.random()).first() else: next_ques = Question.query.filter( Question.category == body['quiz_category']['id'], Question.id.notin_(prev)).order_by(func.random()).first() if len(prev) == 0 and next_ques is None: abort(400) return jsonify({ 'success': True, 'question': None if next_ques is None else next_ques.format() })
def group(): users = [] if current_user.is_authenticated: posts = current_user.followed_posts().all() tempUsers = User.query.filter(User.id != current_user.id).order_by( func.random()).all() for tempUser in tempUsers: if not current_user.is_following(tempUser) and len(users) <= 2: users.append(tempUser) return render_template('group/groups.html', posts=posts, users=users, active='group')
def random(self): while self.running: if len(self.queue) > 0: time.sleep(1) continue random_blog = self.db.query(Blog).filter( or_(Blog.updated != Blog.last_crawl_update, Blog.last_crawl_update == None)).order_by( func.random()).limit(1).scalar() self.log(random_blog.name, random_blog.total_posts) self.archive(random_blog)
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()
def play_quiz(): error = 422 previous_questions = request.json.get('previous_questions', None) quiz_category = request.json.get('quiz_category', None) try: # retrieve category_id from quiz_category dictionary category = quiz_category.get('id') prevques = [] for question in previous_questions: prevques.append(question) except: abort(400) try: # frontend sets value of 'ALL' categories to 'click' if category == 0: next_question = Question.query.filter( ~Question.id.in_(prevques)).order_by( func.random()).first() else: next_question = Question.query.filter( Question.category == category).filter( ~Question.id.in_(prevques)).order_by( func.random()).first() if not next_question: error = 404 abort() else: return jsonify({ 'success': True, 'question': next_question.format() }) except: abort(error)
def get_orgs_issues(organization_name, labels=None): ''' A clean url to get an organizations issues ''' # Get one named organization. organization = Organization.query.filter_by(name=raw_name(organization_name)).first() if not organization: return "Organization not found", 404 # Get that organization's projects projects = Project.query.filter_by(organization_name=organization.name).all() project_ids = [project.id for project in projects] if labels: # Get all issues belonging to these projects query = Issue.query.filter(Issue.project_id.in_(project_ids)) # Create a labels list by comma separating the argument labels = [label.strip() for label in labels.split(',')] # Create the filter for each label labels = [Label.name.ilike(format_ilike_term(label)) for label in labels] # Create the base query object by joining on Issue.labels query = query.join(Issue.labels) # Filter for issues with each individual label label_queries = [query.filter(L) for L in labels] # Intersect filters to find issues with all labels query = query.intersect(*label_queries).order_by(func.random()) else: # Get all issues belonging to these projects query = Issue.query.filter(Issue.project_id.in_(project_ids)).order_by(func.random()) filters, querystring = get_query_params(request.args) response = paged_results(query=query, include_args=dict(include_project=True, include_labels=True), page=int(request.args.get('page', 1)), per_page=int(request.args.get('per_page', 10)), querystring=querystring) return jsonify(response)
def create_fake_order(discounts): user = User.query.order_by(func.random()).first() address = create_fake_address() status = random.choice(list(OrderStatusKinds)).value order_data = { "user_id": user.id, "shipping_address": address.full_address, "status": status, "token": str(uuid4()), } shipping_method = ShippingMethod.query.order_by(func.random()).first() order_data.update({ "shipping_method_name": shipping_method.title, "shipping_method_id": shipping_method.id, "shipping_price_net": shipping_method.price, }) order = Order.create(**order_data) lines = create_order_lines(order, discounts, random.randrange(1, 5)) order.total_net = sum([line.get_total() for line in lines]) order.save() create_payment(order) return order
async def read(self, ids, fields=Available): if ids['id'] == 'random': provider_id = ids['provider_id'] account = self.get_account(provider_id) kw = dict(account_id=account.id, account_provider_id=account.provider_id, provider_id=provider_id) self.policy.grant_query(account, self.__model__, kw) ids = dict(provider_id=provider_id) query = await self.query(ids, kw) random = query.order_by(func.random()).first() if random: ids['id'] = random.id return await super().read(ids, fields=fields)
def _random_story(message=''): story = Story.query.filter(Story.author_id != current_user.id).filter_by( published=1).order_by(func.random()).first() if story is None: message = 'Ooops.. No random story for you!' rolls_outcome = [] else: rolls_outcome = json.loads(story.rolls_outcome) return render_template("story.html", message=message, story=story, url="/story/", current_user=current_user, rolls_outcome=rolls_outcome)
def fill_indexpage(page, database, db_filter, order, *join): if current_user.show_detail_random(): randm = db.session.query(db.Books).filter(common_filters())\ .order_by(func.random()).limit(config.config_random_books) else: randm = false() off = int(int(config.config_books_per_page) * (page - 1)) pagination = Pagination(page, config.config_books_per_page, len(db.session.query(database).filter(db_filter).filter(common_filters()).all())) entries = db.session.query(database).join(*join, isouter=True).filter(db_filter).filter(common_filters()).\ order_by(*order).offset(off).limit(config.config_books_per_page).all() for book in entries: book = order_authors(book) return entries, randm, pagination
def getRandom(self, limit=1): ''' Return a list of rows taken randomly. Works only on SQLite. :param int limit: Limit :return: List of non persistent entities :rtype: list of entities.Common ''' '''return self._session.query(self._persistent_entity) .order_by(func.random()) .limit(limit).all() ''' return self._getBy(order=func.random(), limit=limit)
def search(): term = request.args.get("query") if term: random = db.session.query(db.Books).order_by(func.random()).limit( config.RANDOM_BOOKS) entries = db.session.query(db.Books).filter( db.or_( db.Books.tags.any(db.Tags.name.like("%" + term + "%")), db.Books.series.any(db.Series.name.like("%" + term + "%")), db.Books.authors.any(db.Authors.name.like("%" + term + "%")), db.Books.title.like("%" + term + "%"))).all() return render_template('search.html', searchterm=term, entries=entries) else: return render_template('search.html', searchterm="")