def get_multiple(index, data=None): """ Get multiple records by ID """ try: serverClient = FaunaClient( secret=os.environ.get("FAUNA_SERVER_SECRET")) res_arr = [] if data is None: res = serverClient.query( q.map_(q.lambda_("data", q.get(q.var("data"))), q.paginate(q.match(q.index(index))))) res_arr.extend(res["data"]) elif isinstance(data, list): for x in data: res = serverClient.query( q.map_(q.lambda_("data", q.get(q.var("data"))), q.paginate(q.match(q.index(index), q.casefold(x))))) res_arr.extend(res["data"]) else: res = serverClient.query( q.map_(q.lambda_("data", q.get(q.var("data"))), q.paginate(q.match(q.index(index), q.casefold(data))))) res_arr.extend(res["data"]) arr = [] for x in res_arr: x["data"]["ref_id"] = x["ref"].id() arr.append(x["data"]) return arr except Exception as ex: raise ex
def test_reverse(self): #arrays list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] self.assertEqual(self._q(query.reverse(list)), [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) self.assertEqual(self._q(query.reverse(query.reverse(list))), list) self.assertEqual(self._q(query.reverse([])), []) self._q(query.create_collection({"name": "reverse_collection"})) self._q(query.create_index({ "name": "rev_coll_idx", "source": query.collection("reverse_collection"), "values": [{"field": ["data", "val"]}] })) index = query.index("rev_coll_idx") for i in range(100): self._q(query.create(query.collection( "reverse_collection"), {"data": {"val": i}})) assertPaginate = lambda q, expected, size = None : self.assertEqual(self._q(query.select("data", query.paginate(q, size))), expected) assertPaginate(query.reverse(query.match(index)), [99, 98, 97, 96, 95], 5) assertPaginate(query.reverse(query.reverse(query.match(index))), list, 11) q1 = query.select(["data", 0], query.reverse(query.paginate(query.match(index), size=50))) self.assertEqual(self._q(q1), 49) self._assert_bad_query(query.reverse("a string")) self._assert_bad_query(query.reverse(index)) self._assert_bad_query(query.reverse({"a": 1, "b": 2}))
def fetch_matches_from_db(afterPtr, isFirstPage): try: all_matches = [] if isFirstPage: all_matches = client.query( q.paginate(q.match(q.index("all_raw_matches")), size=10000)) else: all_matches = client.query( q.paginate(q.match(q.index("all_raw_matches")), size=10000, after=afterPtr)) all_matches_data = all_matches['data'] match_ids = [] for match in all_matches_data: match_id = match.value['id'] match_ids.append(match_id) enqueue_match_ids(match_ids) if 'after' in all_matches: all_matches_after = all_matches['after'] fetch_matches_from_db(all_matches_after, False) except Exception as e: logging.error(f'Error occurred {str(e)}')
def test_collection_predicates(self): self.assertTrue(self._q(query.is_empty([]))) self.assertFalse(self._q(query.is_empty([1, 2, 3]))) self.assertFalse(self._q(query.is_nonempty([]))) self.assertTrue(self._q(query.is_nonempty([1, 2, 3]))) self._create(n=111) self.assertFalse( self._q( query.is_empty( query.paginate(query.match(self.n_index_ref, 111))))) self.assertTrue( self._q( query.is_empty( query.paginate(query.match(self.n_index_ref, 112))))) self.assertTrue( self._q( query.is_nonempty( query.paginate(query.match(self.n_index_ref, 111))))) self.assertFalse( self._q( query.is_nonempty( query.paginate(query.match(self.n_index_ref, 112)))))
def create_question(request): quiz_all=client.query(q.paginate(q.match(q.index("quiz_get_index"), "active"))) all_quiz=[] for i in quiz_all["data"]: all_quiz.append(q.get(q.ref(q.collection("Quiz"),i.id()))) context = {"quiz_all":client.query(all_quiz)} if request.method=="POST": quiz_name=request.POST.get("quiz_name") question_asked=request.POST.get("question") answer_1=request.POST.get("answer_1") answer_2=request.POST.get("answer_2") answer_3=request.POST.get("answer_3") answer_4=request.POST.get("answer_4") correct_answer=request.POST.get("correct_answer") try: question_create = client.query(q.get(q.match(q.index("question_index"), question_asked))) messages.add_message(request, messages.INFO, 'This question already exists') return redirect("App:create-question") except: question_create = client.query(q.create(q.collection("Question"), { "data": { "quiz_name": quiz_name, "question_asked": question_asked, "answer_1": answer_1, "answer_2": answer_2, "answer_3": answer_3, "answer_4": answer_4, "correct_answer": correct_answer, } })) messages.add_message(request, messages.INFO, 'Question Created Successfully.') return redirect("App:create-question") return render(request,"create-questions.html",context)
def questions(): username = session["user"]["username"] question_type = request.args.get("type", "all").lower() if question_type == "answered": question_indexes = client.query( q.paginate(q.match(q.index("questions_index"), True, username), size=100_000)) elif question_type == "unanswered": question_indexes = client.query( q.paginate(q.match(q.index("questions_index"), False, username), size=100_000)) elif question_type == "all": question_indexes = client.query( q.paginate(q.union( q.match(q.index("questions_index"), True, username), q.match(q.index("questions_index"), False, username)), size=100_000)) else: return redirect(url_for("questions")) questions = [ q.get(q.ref(q.collection("questions"), i.id())) for i in question_indexes["data"] ] return render_template("questions.html", questions=client.query(questions)[::-1])
def create_reviews(): reviews = [] conferences = client.query( q.paginate(q.match(q.index("allConferences")), size=1000)) for conf in conferences['data']: reviewers = client.query( q.paginate(q.match(q.index("conference_reviewers_by_conference"), conf), size=1000)) for reviewer in reviewers['data']: submissions = client.query( q.paginate(q.match( q.index("conference_submissions_by_conference"), conf), size=1000)) for submission in submissions['data']: new_review = { "reviewer": reviewer, "submission": submission, "score": random.randint(0, 5), "public": fake.paragraph(), "private": fake.paragraph() } reviews.append(new_review) return reviews
def _fetch_column_info_refs(table_name: str, column_name: str): convert_to_collection_ref_set = functools.partial( fql.convert_to_ref_set, "information_schema_columns_") return q.intersection( convert_to_collection_ref_set( q.range( q.match( q.index( fql.index_name( "information_schema_columns_", column_name="table_name_", index_type=fql.IndexType.VALUE, ))), table_name, table_name, ), ), convert_to_collection_ref_set( q.range( q.match( q.index( fql.index_name( "information_schema_columns_", column_name="name_", index_type=fql.IndexType.VALUE, )), ), column_name, column_name, ), ), )
def get(self, message_hash=None): if not message_hash: page = q.paginate(q.match(q.index("confirmed"), 'True')) ns = q.map_(lambda a: q.select(["data"], q.get(a)), page) result = client.query(ns)['data'] for message in result: messages[message['hash']] = message message_hash = random.choice(messages.keys()) message = fill_line(messages[message_hash]['title']) suggester = messages[message_hash]['suggester'] else: page = q.paginate(q.match(q.index("hash"), message_hash)) ns = q.map_(lambda a: q.select(["data"], q.get(a)), page) result = client.query(ns)['data'] if len(result) > 0: message = fill_line(result[0]['title']) suggester = result[0]['suggester'] else: raise tornado.web.HTTPError(404) self.output_message(message, message_hash, suggester) image = Image.new("RGBA", (300, 150), (255, 255, 255)) image_size = image.size # load the font and image font = ImageFont.truetype(fontFile, 18) # image = Image.open(imageFile) # firts you must prepare your text (you dont need this for english text) # text = unicode(message, "utf-8") text = message # start drawing on image draw = ImageDraw.Draw(image) lines = text_wrap(text, font, image_size[0] - 10) line_height = font.getsize('hg')[1] x = 10 y = 20 for line in lines: reshaped_text = arabic_reshaper.reshape(line) # correct its shape bidi_text = get_display(reshaped_text) # correct its direction # draw the line on the image x = image_size[0] - font.getsize(bidi_text)[0] - x draw.text((x, y), bidi_text, (0, 0, 0), font=font) # update the y position so that we can use it for next line y = y + line_height x = 10 # draw.text((10, 0), bidi_text, (0,0,0), font=font) draw = ImageDraw.Draw(image) # save it image.save("thumbnails/{}.png".format(message_hash))
def test_union(self): n_value = 101 m_value = 201 ref_n = self._create(n=n_value)["ref"] ref_m = self._create(m=m_value)["ref"] ref_nm = self._create(n=n_value, m=m_value)["ref"] q = query.union(query.match(self.n_index_ref, n_value), query.match(self.m_index_ref, m_value)) self.assertEqual(self._set_to_list(q), [ref_n, ref_m, ref_nm])
def test_intersection(self): n_value = 102 m_value = 202 ref_nm = self._create(n=n_value, m=m_value)["ref"] self._create(n=n_value) self._create(m=m_value) q = query.intersection(query.match(self.n_index_ref, n_value), query.match(self.m_index_ref, m_value)) self.assertEqual(self._set_to_list(q), [ref_nm])
def test_difference(self): n_value = 103 m_value = 203 ref_n = self._create(n=n_value)["ref"] self._create(m=m_value) self._create(n=n_value, m=m_value) q = query.difference(query.match(self.n_index_ref, n_value), query.match(self.m_index_ref, m_value)) self.assertEqual(self._set_to_list(q), [ref_n]) # but not ref_nm
def test_join(self): join_refs = [self._create(n=12)["ref"], self._create(n=12)["ref"]] assoc_refs = [self._create(m=ref)["ref"] for ref in join_refs] source = query.match(self.n_index_ref, 12) self.assertEqual(self._set_to_list(source), join_refs) # For each obj with n=12, get the set of elements whose data.m refers to it. joined = query.join(source, lambda a: query.match(self.m_index_ref, a)) self.assertEqual(self._set_to_list(joined), assoc_refs)
def create_reviewers(): reviewers = [] users = client.query(q.paginate(q.match(q.index("allUsers")), size=1000)) conferences = client.query( q.paginate(q.match(q.index("allConferences")), size=1000)) for conf in conferences['data']: for user in random.sample(users['data'], 7): new_committee_member = {"conference": conf, "reviewer": user} reviewers.append(new_committee_member) return reviewers
def create_authors(): authors = [] users = client.query(q.paginate(q.match(q.index("allUsers")), size=1000)) submissions = client.query( q.paginate(q.match(q.index("allSubmissions")), size=1000)) for paper in submissions['data']: for author in random.sample(users['data'], random.randint(0, 1) + 1): new_author = {"submissionID": paper, "userID": author} authors.append(new_author) return authors
def test_set(self): index = Ref("frogs_by_size", Native.INDEXES) json_index = '{"@ref":{"collection":{"@ref":{"id":"indexes"}},"id":"frogs_by_size"}}' match = SetRef(query.match(index, self.ref)) json_match = '{"@set":{"match":%s,"terms":%s}}' % (json_index, self.json_ref) self.assertJson(match, json_match) self.assertNotEqual( match, SetRef( query.match(index, query.ref(query.collection("frogs"), "456"))))
def read_three_customers(client, cust_id1, cust_id2, cust_id3): # # Here is a more general use case where we retrieve multiple class references # by id and return the actual data underlying them. # res = client.query( q.map_( lambda x: q.select("data", q.get(x)), q.paginate( q.union(q.match(q.index("customer_by_id"), cust_id1), q.match(q.index("customer_by_id"), cust_id2), q.match(q.index("customer_by_id"), cust_id3))))) print('Union specific \'customer\' 1, 3, 8: {0}'.format(res))
def start_quiz(update, context): ''' Starts the quiz and gets the questions from aloc API, then saves to database ''' chat_id = update.effective_chat.id message = update.message.text try: name = update["message"]["chat"]["first_name"] except: name = update["message"]["chat"]["username"] subject = message.split('_')[1] questions = get_questions(subject=subject, mode='utme') quiz = client.query( q.create( q.collection("quiz"), { "data": { "user_id": chat_id, "subject": subject, "answered": 0, "score": 0, "id_": random.randint(0, 100), 'completed': False, 'questions': questions, } })) user = client.query(q.get(q.match(q.index("users"), chat_id))) client.query( q.update(q.ref(q.collection("users"), user["ref"].id()), {"data": { "last_command": "start_quiz" }})) msg = f"{subject.upper()}\n\n10 questions, enter 'q' to continue\n\n/end_quiz to end the quiz session." context.bot.send_message(chat_id=chat_id, text=msg)
def test_range(self): data = list(range(1, 20)) self._q(query.create_collection({"name": "range_test"})) self._q( query.create_index({ "name": "range_idx", "source": query.collection("range_test"), "active": True, "values": [{ "field": ["data", "value"] }] })) self._q( query.foreach( query.lambda_query(lambda x: query.create( query.collection("range_test"), {"data": { "value": x }})), data)) m = query.match(query.index("range_idx")) q1 = query.select("data", query.paginate(query.range(m, 3, 8))) q2 = query.select("data", query.paginate(query.range(m, 17, 18))) q3 = query.select("data", query.paginate(query.range(m, 19, 0))) self.assertEqual(self._q(q1), [3, 4, 5, 6, 7, 8]) self.assertEqual(self._q(q2), [17, 18]) self.assertEqual(self._q(q3), [])
def test_paginate(self): n_value = 200 refs = [ self._create(n=n_value)["ref"], self._create(n=n_value)["ref"], self._create(n=n_value)["ref"] ] test_set = query.match(self.n_index_ref, n_value) self.assertEqual(self._q(query.paginate(test_set)), {"data": refs}) data = [] page1 = self._q(query.paginate(test_set, size=1)) data.extend(page1["data"]) page2 = self._q(query.paginate(test_set, size=1, after=page1["after"])) data.extend(page2["data"]) self.assertEqual(data, [refs[0], refs[1]]) self.assertEqual( self._q(query.paginate(test_set, sources=True)), { "data": [{ "sources": [SetRef(test_set)], "value": refs[0] }, { "sources": [SetRef(test_set)], "value": refs[1] }, { "sources": [SetRef(test_set)], "value": refs[2] }] })
def add_book(request): if request.method=="POST": title= request.POST.get("title") genres=request.POST.get("genres") summary=request.POST.get("summary") pages=request.POST.get("pages") copies=request.POST.get("copies") author= request.POST.get("author") about=request.POST.get("about") try: book = client.query(q.get(q.match(q.index("book_index"), title))) messages.add_message(request, messages.INFO, 'Book Already Exists') return redirect("App:add_book") except: book = client.query(q.create(q.collection("Books"), { "data": { "title":title, "genres": genres, "summary": summary, "pages":pages, "copies":copies, "author":author, "about":about, "availability":"True" } })) messages.add_message(request, messages.INFO, 'Book added Successfully') return redirect("App:add_book") return render(request,"add-book.html")
def test_count_mean_sum(self): data = [1, 2, 3, 4, 5, 6, 7, 8, 9] self._q(query.create_collection({"name": "countmeansum_test"})) self._q( query.create_index({ "name": "countmeansum_idx", "source": query.collection("countmeansum_test"), "active": True, "values": [{ "field": ["data", "value"] }] })) self._q( query.foreach( query.lambda_( "x", query.create( query.collection("countmeansum_test"), {"data": { "value": query.add(query.var("x"), 2) }})), data)) m = query.match(query.index("countmeansum_idx")) expected = [9, 5.0, 45, 9, 7.0, 63] self.assertEqual( self._q([ query.count(data), query.mean(data), query.sum(data), query.count(m), query.mean(m), query.sum(m) ]), expected)
def create_appointment(request): if "user" in request.session: if request.method == "POST": name = request.POST.get("name") description = request.POST.get("description") time = request.POST.get("time") date = request.POST.get("date") try: user = client.query( q.get(q.match(q.index("events_index"), date, time))) messages.add_message( request, messages.INFO, 'An Event is already scheduled for the specified time.') return redirect("core:create-appointment") except: user = client.query( q.create( q.collection("Events"), { "data": { "name": name, "description": description, "time": time, "date": date, "user": request.session["user"]["username"], "status": 'False', } })) messages.add_message(request, messages.INFO, 'Appointment Scheduled Successfully.') return redirect("core:create-appointment") return render(request, "appoint/create-appointment.html") else: return HttpResponseNotFound("Page not found!")
def detail(request,slug): try: book= client.query(q.get(q.match(q.index("book_index"), slug)))["data"] context={"book":book} return render(request,"detail.html",context) except: return render(request,"detail.html")
def all_appointment(request): if "user" in request.session: try: appointments = client.query( q.paginate( q.match(q.index("events_index_paginate"), request.session["user"]["username"])))["data"] appointments_count = len(appointments) page_number = int(request.GET.get('page', 1)) appointment = client.query( q.get( q.ref(q.collection("Events"), appointments[page_number - 1].id()))) if request.GET.get("delete"): client.query( q.delete( q.ref(q.collection("Events"), appointments[page_number - 1].id()))) return redirect("core:all-appointment") context = { "count": appointments_count, "appointment": appointment, "page_num": page_number, "next_page": min(appointments_count, page_number + 1), "prev_page": max(1, page_number - 1) } return render(request, "all-appointments.html", context) except: return render(request, "all-appointments.html") else: return HttpResponseNotFound("Page not found!") return render(request, "all-appointments.html")
def start(update, context): ''' Starts the bot and saves the user details if it is not existing ''' chat_id = update.effective_chat.id try: name = update["message"]["chat"]["first_name"] except: name = update["message"]["chat"]["username"] try: client.query(q.get(q.match(q.index("users"), chat_id))) except: client.query( q.create( q.collection("users"), { "data": { "id": chat_id, "name": name, "last_command": "", "date": datetime.now(pytz.UTC) }, })) botler = Botler().get() msg = messenger.get(name, botler) context.bot.send_message(chat_id=chat_id, text=msg)
def register(request): if request.method == "POST": username = request.POST.get("username").strip().lower() email = request.POST.get("email").strip().lower() password = request.POST.get("password") try: user = client.query( q.get(q.match(q.index("users_index"), username))) messages.add_message(request, messages.INFO, 'User with that username already exists.') return redirect("core:register") except: user = client.query( q.create( q.collection("Users"), { "data": { "username": username, "email": email, "password": hashlib.sha512(password.encode()).hexdigest(), "date": datetime.datetime.now(pytz.UTC) } })) messages.add_message(request, messages.INFO, 'Registration successful.') return redirect("core:login") return render(request, "register.html")
async def scrape_article(article: ReadingReference, response: Response): if NHK_PREFIX in article.url: try: # see if an article exists client.query(q.get(q.match(q.index('reading_by_url'), article.url))) return {"success": True, "status": "DocumentExists"} except: # scrape article and save article = requests.get(article.url) soup = BeautifulSoup(article.content, 'html.parser') article_body_text = soup.find( class_='article-main__body').get_text() article_title_text = soup.find( class_='article-main__title').get_text() client.query( q.create( q.collection('Reading'), { "data": { "reading_url": article.url, "article_title": article_title_text, "text": article_body_text } })) response.status_code = status.HTTP_201_CREATED return {"success": True, "status": "CreatedDocument"} else: response.status_code = status.HTTP_400_BAD_REQUEST return {"success": False, "status": "UnknownArticleType"}
def products(): if request.method == "GET": category = request.args.get("category") or None if category: data = client.query( q.map_( lambda x: q.get(x), q.paginate( q.match(q.index("products_by_category"), category)))) response = [i["data"] for i in data["data"]] for i in range(0, len(response)): response[i]['id'] = str(data["data"][i]["ref"].id()) return jsonify(data=response) data = client.query( q.map_(lambda x: q.get(x), q.paginate(q.documents(q.collection("products"))))) response = [i["data"] for i in data["data"]] for i in range(0, len(response)): response[i]['id'] = str(data["data"][i]["ref"].id()) return jsonify(data=response) elif request.method == "POST": request_data = request.get_json() response = client.query( q.create(q.collection("products"), {"data": request_data})) return jsonify(id=response["ref"].id())
def build_document_set_intersection( table: sql.Table, filter_group: typing.Optional[sql.FilterGroup]) -> QueryExpression: """Build FQL match query based on intersection of filtered results from given group. Params: ------- table: A Table object associated with a Fauna collection. filter_group: A group of filters representing an intersection of filtered results. Returns: -------- FQL query expression that matches on the same conditions as the Table's filters. """ filter_group_filters = [] if filter_group is None else filter_group.filters group_filter_names = [ sql_filter.name for sql_filter in filter_group_filters ] filters = [ sql_filter for sql_filter in table.filters if sql_filter.name in group_filter_names ] if not any(filters): return q.intersection(q.match(q.index(index_name(table.name)))) document_sets = [ _define_match_set(query_filter) for query_filter in filters ] return q.intersection(*document_sets)
def list(event, context): # fetch all todos from the database results = client.query( query.map_expr(lambda ref: query.get(ref), query.paginate(query.match(ALL_TODOS)))) # create a response response = { "statusCode": 200, "body": json.dumps(map(make_result, results['data'])) } return response