def reload(self): '''This is the 'reload' instance. Deserializes the JSON file to __objects. If JSON file does not exist, do nothing. Return: __object or nothing ''' if os.path.isfile(FileStorage.__file_path) is True: with open(FileStorage.__file_path, 'r+', encoding='utf-8') as fn: obj = json.load(fn) for key in obj.keys(): is_dict = obj[key] is_class = is_dict['__class__'] if 'BaseModel' in is_class: FileStorage.__objects[key] = models.BaseModel(obj[key]) if 'Amenity' in is_class: FileStorage.__objects[key] = models.Amenity(obj[key]) if 'City' in is_class: FileStorage.__objects[key] = models.City(obj[key]) if 'Place' in is_class: FileStorage.__objects[key] = models.Place(obj[key]) if 'Review' in is_class: FileStorage.__objects[key] = models.Review(obj[key]) if 'State' in is_class: FileStorage.__objects[key] = models.State(obj[key]) if 'User' in is_class: FileStorage.__objects[key] = models.User(obj[key])
def create_review(project): """Create new review.""" review = models.Review( author='Jeff Knupp', content='Sandman rules!', documentation_review=models.ReviewMetric(name='documentation', stars=4, content='It\'s great'), project_infrastructure_review=models.ReviewMetric( name='project_infrastructure', stars=5, content='Continuous Integration and automated documentation' 'generation in place.'), ease_of_use_review=models.ReviewMetric(name='ease_of_use', stars=5, content='Wow!'), ease_of_contribution_review=models.ReviewMetric( name='ease_of_contribution', stars=3, content='Missing "CONTRIBUTING.md" or similar file!'), code_quality_review=models.ReviewMetric( name='code_quality', stars=3, content='This code sucks! The author should read <a ' 'href="https://www.jeffknupp.com/writing-idiomatic-python-ebook">Writing ' 'Idiomatic Python</a>'), overall_review=models.ReviewMetric(name='overall', stars=4, content='Meh...'), project=project) models.db.session.add(review) models.db.session.commit()
def Rinsert(items): global engine if (engine is None): engine = sqlmy.create_engine( "mysql+pymysql://" + mc['user'] + ":" + mc['psw'] + "@" + mc['host'] + ":" + mc['port'] + "/" + mc['db_name'] + "?charset=" + mc['charset'], echo=False) DBSession = sessionmaker(bind=engine) session = DBSession() get_data = session.query( M.Review).filter(M.Review.rid == items['rid']).first() if (get_data is None): new_data = M.Review(rid=items['rid'], sub_id=items['sub_id'], star=items['star'], review=items['review'], info_time=items['info_time']) session.add(new_data) session.commit() else: #print(get_data) print("repeat") session.close()
async def post_facility_reviews(self, facility_id, source, rating, count): """ :param facility_id: Идентификатор клиники :param source: Источник данных ("google") :param rating: Рейтинг (5.0) :param count: Количество отзывов (47) """ if self.base_address is not None: raise NotImplementedError async with models.AsyncSession() as session: review = session.query(models.Review).filter( models.Review.facility_id == facility_id, models.Review.source == source ).first() if review is None: review = models.Review( facility_id=facility_id, source=source ) session.add(review) review.rating = rating review.count = count session.commit()
def setupDB(): for index in range(0, len(reviews)): review = m.Review( reviews[index]['id'], reviews[index]['text'], reviews[index]['stars'], s.indi_sentimentR(s.singularTokenize(reviews[index]['text']))) m.db.session.add(review) m.db.session.commit()
def submit_review(book_id, review_title, content, score, language, user_id): user = models.User.query.filter_by(id=user_id).first() book = models.Book.query.filter_by(id=book_id).first() review = models.Review(review_title, content, score, language, str(datetime.date.today()), user, book) models.db.session.add(review) models.db.session.commit() update_avg_score(book.id)
def receive_review_add(): review = request.form['review'] stars = request.form['stars'] length = len(m.Review.query.all()) sentiment = s.indi_sentimentR(s.singularTokenize(review)) reviewAdd = m.Review(length, review, stars, sentiment) m.db.session.add(reviewAdd) m.db.session.commit() return ('', 202)
def _tx(): review = models.Review( key=key, product_key=prod.key, username=username, rating=rating, comment=comment) review.put() defer(utils.updateAverageRating, key, _transactional=True) return review
def test_joined_attr(): f = models.Review( app="Annoyed Birds", stars=5, reviewer_email="*****@*****.**", reviewer_name="Some One", ) print(f.serialize()) assert ulid.from_str(f.serialize()["ulid"]["S"]) assert ulid.from_str(f.serialize()["pk"]["S"].split("#")[-1]) assert f.serialize()["__type"]["S"] == "Review" assert f.serialize()["gsi1_pk"]["S"] == "REVIEW#[email protected]"
def _tx(): review = models.Review(key=key, product_key=prod.key, username=username, rating=rating, comment=comment) review.put() # in a transactional task, update the parent product's average # rating to include this review's rating, and flag the review as # processed. defer(utils.updateAverageRating, key, _transactional=True) return review
def add_review(): business_id = request.json['business_id'] worker_id = request.json['worker_id'] date = datetime.strptime(request.json['date'], '%b %d %Y %I:%M%p') content = request.json['content'] score = request.json['score'] listing_id = request.json['listing_id'] reviewer_type = request.json['reviewer_type'] new_review = models.Review(business_id, worker_id, date, content, score, listing_id, reviewer_type) db.session.add(new_review) db.session.commit() return "201 Created Review"
def db_start(): create_engine('sqlite:///tmp/testapi.db', convert_unicode=True) db.create_all() db.session.commit() product_1 = models.Product() product_1.name = 'Computer' product_1.description = 'Very big comupter' product_1.category = 'Personal computer' db.session.add(product_1) db.session.commit() review_1 = models.Review() review_1.author = 'Johny' review_1.text = 'Very nice computer' review_1.rating = 5 review_1.product_id = 1 db.session.add(review_1) db.session.commit()
def do_create(self, arg): '''Creates a new instance of BaseModel, save to JSON file.''' args = arg.split() if len(args) < 1: print(self.errors['noclass']) elif args[0] in self.new_class: if args[0] == 'BaseModel': new = models.BaseModel() if args[0] == 'Amenity': new = models.Amenity() if args[0] == 'City': new = models.City() if args[0] == 'Place': new = models.Place() if args[0] == 'Review': new = models.Review() if args[0] == 'State': new = models.State() if args[0] == 'User': new = models.User() new.save() print('{}'.format(new.id)) else: print(self.errors['badclass'])
def review(): majorCodes = db.session.query(models.MajorCodes).all() programs = db.session.query(models.Program).all() allUsers = db.session.query(models.Users).all() db.session.close() form = forms.WriteReview() # setting up the form form.majorCode.choices = sorted([(m.duke_major_code, m.duke_major_code) for m in majorCodes]) if form.validate_on_submit(): dateTimeObj = datetime.now() timestampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M:%S.%f)") id = timestampStr u_email = session.get('user_email') # get form responses duke_major_code = form.majorCode.data duke_code = str(duke_major_code) + " " + str(form.courseNumber.data) course_name = form.course.data rating = form.rating.data difficulty = form.difficulty.data content = form.thoughts.data user = db.session.query(models.Users).filter(Users.email == u_email).one() program_name = user.program_name for p in programs: if p.program_name == program_name: country = p.country break # check for errors if request.method == 'POST': error = None user = db.session.query(models.Users).filter(Users.email == u_email).first() specifcUserReviews = db.session.query(models.Review).filter(Review.u_email == u_email)\ .join(models.Course, Course.id == Review.course_id).filter(Course.course_name == course_name).all() if len(specifcUserReviews) != 0: error = 'You have already written a review for this class.' flash(error) return redirect(url_for('review')) # check if the course already exists courses = db.session.query(models.Course).filter(Course.course_name == course_name)\ .filter(Course.program_name == program_name).filter(Course.duke_code == duke_code).all() course_id = None for course in courses: if course.course_name == course_name and course.program_name == program_name and course.duke_code == duke_code: course_id = course.id break if course_id == None: new_course = models.Course(duke_code=duke_code, course_name=course_name, program_name=program_name) db.session.add(new_course) db.session.flush() db.session.commit() course_id = new_course.id new_review = models.Review(id=id, country=country, duke_major_code=duke_major_code, u_email=u_email, course_id=course_id , rating=rating, difficulty=difficulty, content=content) db.session.add(new_review) db.session.flush() db.session.commit() flash('New entry was successfully posted') return render_template('submitted.html', form=form) return render_template('review.html', form=form)
def add_review(request): # Current time in milliseconds post_time = int(time.time()) loc_id = request.get('URL') loc_obj = DatabaseReader.get_location(loc_id) loc_name = loc_obj.name try: vision_rating = int(request.get('Vision')) except: vision_rating = 0 try: mobility_rating = int(request.get('Mobility')) except: mobility_rating = 0 try: speech_rating = int(request.get('Speech')) except: speech_rating = 0 try: helpfulness_rating = int(request.get('Helpfulness')) except: helpfulness_rating = 0 text = request.get('Text') tag_ids = { '1': 'wheelchair-friendly', '2': 'blind-friendly', '3': 'understanding', '4': 'autism-friendly', '5': 'elevators', '6': 'secret laboratory' } tags_list = request.get_all('tags') # tags_list ={ # 'wheelchair-friendly': request.get('wheelchair-friendly').strip(), # 'blind-friendly': request.get('blind-friendly').strip(), # 'understanding': request.get('understanding').strip(), # 'autism-friendly': request.get('autism-friendly').strip() # } review = models.Review() review.loc_name = loc_name if vision_rating <= 5: review.vision_rating = vision_rating else: review.vision_rating = 0 vision_rating = 0 if mobility_rating <= 5: review.mobility_rating = mobility_rating else: review.mobility_rating = 0 mobility_rating = 0 if speech_rating <= 5: review.speech_rating = speech_rating else: review.speech_rating = 0 speech_rating = 0 if helpfulness_rating <= 5: review.helpfulness_rating = helpfulness_rating else: review.helpfulness_rating = 0 helpfulness_rating = 0 review.text = text review.time_created = datetime.datetime.fromtimestamp(post_time) review.loc_id = loc_id update_location_average(review) user = users.get_current_user() if user: review.user = user.nickname() review.user_email = user.email() else: review.user = "******" # Checking for tags Alpha # for tag in tags_list.keys(): # if(tags_list[tag] != ""): # logging.info("%s value is %s" %(tag, tags_list[tag])) # review = append_tag_to_review(tag, tags_list[tag], review) for tag in tags_list: if (tag != ""): try: tag = int(tag) tag_index = tag_ids[str(abs(tag))] except: continue logging.info("%s value is %s" % (tag_index, tag)) append_tag_to_review(tag_index, tag, review) add_review_tags_to_location(loc_obj, review) if (review.vision_rating != None and review.mobility_rating != None and review.speech_rating != None and review.helpfulness_rating != None): review.put() return loc_id # For now? else: return None
def setUp(self): """Setup for each testcase""" self.testcase = models.Review()
def get_reviews(self, url): try: amazon_url, asin = get_amazon_asin(url) headers = { 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36' } page = requests.get(amazon_url, headers=headers) page_response = page.text parser = html.fromstring(page_response) XPATH_AGGREGATE = '//span[@id="acrCustomerReviewText"]' XPATH_REVIEW_SECTION_1 = '//div[contains(@id,"reviews-summary")]' XPATH_REVIEW_SECTION_2 = '//div[@data-hook="review"]' XPATH_AGGREGATE_RATING = '//table[@id="histogramTable"]//tr' XPATH_PRODUCT_NAME = '//h1//span[@id="productTitle"]//text()' XPATH_PRODUCT_PRICE = '//span[@id="priceblock_ourprice"]/text()' raw_product_price = parser.xpath(XPATH_PRODUCT_PRICE) product_price = ''.join(raw_product_price).replace(',', '') ratings_dict = {} raw_product_name = parser.xpath(XPATH_PRODUCT_NAME) product_name = ''.join(raw_product_name).strip() total_ratings = parser.xpath(XPATH_AGGREGATE_RATING) # grabing the rating section in product page for ratings in total_ratings: extracted_rating = ratings.xpath('./td//a//text()') if extracted_rating: rating_key = extracted_rating[0] raw_raing_value = extracted_rating[1] rating_value = raw_raing_value if rating_key: ratings_dict.update({rating_key: rating_value}) XPATH_PAGER = '//*[@id="reviewSummary"]/div[1]/a/div/div/div[2]/div/span//text()' pager = parser.xpath(XPATH_PAGER) pager = ''.join(pager) total_pages_str = pager total_pages = int(re.sub("[^0-9.]*", '', total_pages_str)) number_of_pages = math.ceil(total_pages / 10) current_page = 1 reviews_list = [] while current_page <= number_of_pages: REVIEW_URL = r"http://www.amazon.com/product-reviews/%s/" REVIEW_URL += r"ref=cm_cr_arp_d_show_all?ie=UTF8&reviewerType=all_reviews&pageNumber=%s" url = REVIEW_URL % (asin, current_page) page = requests.get(url, headers=headers) page_response = page.text review_parser = html.fromstring(page_response) reviews = review_parser.xpath(XPATH_REVIEW_SECTION_1) if not reviews: reviews = review_parser.xpath(XPATH_REVIEW_SECTION_2) if not reviews: raise ValueError('unable to find reviews in page') for review in reviews: XPATH_RATING = './/i[@data-hook="review-star-rating"]//text()' XPATH_REVIEW_HEADER = './/a[@data-hook="review-title"]//text()' XPATH_REVIEW_POSTED_DATE = './/a[contains(@href,"/profile/")]/parent::span/following-sibling::span/text()' XPATH_REVIEW_TEXT_1 = './/span[@data-hook="review-body"]//text()' # './/div[@data-hook="review-collapsed"]//text()' XPATH_REVIEW_TEXT_2 = './/div//span[@data-action="columnbalancing-showfullreview"]/@data-columnbalancing-showfullreview' XPATH_REVIEW_COMMENTS = './/span[@data-hook="review-comment"]//text()' XPATH_AUTHOR = './/a[contains(@href,"/profile/")]/parent::span//text()' XPATH_REVIEW_TEXT_3 = './/div[contains(@id,"dpReviews")]/div/text()' raw_review_author = review.xpath(XPATH_AUTHOR) raw_review_rating = review.xpath(XPATH_RATING) raw_review_header = review.xpath(XPATH_REVIEW_HEADER) raw_review_posted_date = review.xpath( XPATH_REVIEW_POSTED_DATE) raw_review_text1 = review.xpath(XPATH_REVIEW_TEXT_1) raw_review_text2 = review.xpath(XPATH_REVIEW_TEXT_2) raw_review_text3 = review.xpath(XPATH_REVIEW_TEXT_3) review_id = review.attrib['id'] author = ' '.join( ' '.join(raw_review_author).split()).strip('By') # cleaning data review_rating = ''.join(raw_review_rating).replace( 'out of 5 stars', '') review_header = ' '.join( ' '.join(raw_review_header).split()) review_posted_date = dateparser.parse( ''.join(raw_review_posted_date)).strftime('%d %b %Y') review_text = ' '.join(' '.join(raw_review_text1).split()) # grabbing hidden comments if present if raw_review_text2: json_loaded_review_data = json.loads( raw_review_text2[0]) json_loaded_review_data_text = json_loaded_review_data[ 'rest'] cleaned_json_loaded_review_data_text = re.sub( '<.*?>', '', json_loaded_review_data_text) full_review_text = review_text + cleaned_json_loaded_review_data_text else: full_review_text = review_text if not raw_review_text1: full_review_text = ' '.join( ' '.join(raw_review_text3).split()) raw_review_comments = review.xpath(XPATH_REVIEW_COMMENTS) review_comments = ''.join(raw_review_comments) review_comments = re.sub('[A-Za-z]', '', review_comments).strip() review_dict = { 'review': full_review_text, 'date': review_posted_date, 'star_rating': review_rating, 'user_name': author, 'url': "https://www.amazon.com/gp/customer-reviews/{0}". format(review_id) } reviews_list.append(review_dict) current_page = current_page + 1 sleep(3) item = models.Item(name=product_name, url=amazon_url, ref_id=asin) db.session.add(item) db.session.commit() for comment in reviews_list: review = models.Review(user_name=comment['user_name'], review=comment['review'], url=comment['url'], date=comment['date'], star_rating=comment['star_rating'], item_id=item.id) db.session.add(review) db.session.commit() return item.id except Exception as e: print(os.environ) print(e) self.errors.append(e.__str__()) return {"error": self.errors} return {"error": "failed to process the page", "asin": asin}
def setUp(self): # Blank out the test JSON files: data_map = { # todo DRY, this is repeated in every model interface's tests module "user_data": "test/testing_mockUserDB.json", "datespot_data": "test/testing_mockDatespotDB.json", "match_data": "test/testing_mockMatchData.json", "review_data": "test/testing_mockReviewData.json", "message_data": "test/testing_mockMessageData.json", "chat_data": "test/testing_mockChatData.json" } with open(TEST_JSON_DB_NAME, 'w') as fobj: json.dump(data_map, fobj) fobj.seek(0) # make sure all the test-mock JSONs exist for filename in data_map: with open(data_map[filename], 'w') as fobj: json.dump({}, fobj) fobj.seek(0) # Make a mock restaurant self.terrezanos_location = (40.72289821341384, -73.97993915779077) self.terrezanos_name = "Terrezano's" self.terrezanos_traits = [ "italian", "wine", "pasta", "NOT FROM PIZZA HUT", "authentic", "warehouse" ] self.terrezanos_price_range = 2 self.terrezanos_hours = [ [14, 22], [14, 21], [14, 21], [14, 21], [14, 23], [14, 23], [14, 20] ] # ints in [0..23] representing hours, for now terrezanos_data = { "location": self.terrezanos_location, "name": self.terrezanos_name, "traits": self.terrezanos_traits, "price_range": self.terrezanos_price_range, "hours": self.terrezanos_hours, } # Make mock text self.mock_text_positive_relevant = "This was a wonderful place to go on a date. I had the pasta. It was authentic and not from Pizza Hut." self.expected_sentiment = 0.1906 # todo hardcoded self.expected_relevance = round( 1 / len(self.mock_text_positive_relevant), SENTIMENT_DECIMAL_PLACES) # i.e. "date" appears once. # Connect to the database with the mock data set self.db = DatabaseAPI(json_map_filename=TEST_JSON_DB_NAME) args_data = { "object_model_name": "datespot", "object_data": terrezanos_data } self.terrezanos_id = self.db.post_object(args_data) # Instantiate mock Review object self.review_obj = models.Review(datespot_id=self.terrezanos_id, text=self.mock_text_positive_relevant)
def test(): models.User.query.delete() models.Book.query.delete() models.Review.query.delete() models.Author.query.delete() # Adding users user1 = models.User( 'admin', '*****@*****.**', 'Sweden', 'Send me an email if a book is missing in the database.', str(datetime.date.today()), True) models.db.session.add(user1) models.db.session.commit() user1 = models.User('Pelle Nordfors', '*****@*****.**', 'Sweden', 'hi everyone!', str(datetime.date.today()), False) models.db.session.add(user1) models.db.session.commit() user2 = models.User( 'mrs. Lovett', '*****@*****.**', 'England', '''A great fan of fiction. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ''', str(datetime.date.today()), False) models.db.session.add(user2) models.db.session.commit() user3 = models.User('Elphaba Thropp', '*****@*****.**', 'Oz', 'I like books. Especially The Grimmerie!', str(datetime.date.today()), False) models.db.session.add(user3) models.db.session.commit() user4 = models.User('George Banks', '*****@*****.**', 'England', 'Hi! Mary Poppins in my favorite book!', str(datetime.date.today()), False) models.db.session.add(user4) models.db.session.commit() user5 = models.User('Magda Keller', '*****@*****.**', 'Hungary', 'Umm... I rarely read at all.', str(datetime.date.today()), False) models.db.session.add(user5) models.db.session.commit() # Adding Lolita by Nabokov author = models.Author('Vladimir Nabokov', 'Russia', 1899) book = models.Book( 'Lolita', 1955, 'A man marries his landlady so he can take advantage of her daughter.', 'English') book.written_by.append(author) models.db.session.add(author) models.db.session.commit() review = models.Review('Awesome!', 'blabla', 9, 'Swedish', str(datetime.date.today()), user1, book) models.db.session.add(review) review = models.Review('This is filth!', 'blablabla', 2, 'English', str(datetime.date.today()), user2, book) models.db.session.add(review) models.db.session.commit() database_helper.update_avg_score(book.id) # Adding It by King author = models.Author('Stephen King', 'USA', 1947) book = models.Book( 'It', 1986, 'In 1960, seven outcast kids known as "The Loser Club" fight an evil demon.', 'English') book.written_by.append(author) models.db.session.add(author) models.db.session.commit() database_helper.update_avg_score(book.id) # Adding The Shining by King book = models.Book( 'The Shining', 1977, 'A recovering alcoholic and his family move into a haunted hotel as caretakers.', 'English') book.written_by.append(author) models.db.session.add(author) models.db.session.commit() database_helper.update_avg_score(book.id) # Adding Carrie by King book = models.Book( 'Carrie', 1974, 'A classic horror tale about Carrie White, a shy girl.', 'English') book.written_by.append(author) models.db.session.add(author) models.db.session.commit() database_helper.update_avg_score(book.id) # Adding Misery by King book = models.Book( 'Misery', 1987, 'Paul Sheldon, a successful novelist, is rescued after a snow storm by his "Number One Fan".', 'English') book.written_by.append(author) models.db.session.add(author) models.db.session.commit() database_helper.update_avg_score(book.id)
def get_reviews(self, url): youtube_url, video_id = get_youtube_id(url) try: video_url = 'https://www.googleapis.com/youtube/v3/videos?id={0}&key={1}&fields=items(id,snippet(channelId,title,categoryId),statistics)&part=snippet,statistics'.format( video_id, DEVELOPER_KEY) headers = { 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36' } response = requests.get(video_url, headers=headers) video_details = response.json() if "items" not in video_details or len( video_details["items"]) == 0: raise ValueError("Unable to Get Video Details") video_information = { "ref_id": video_id, "ratings": "N/A", "name": video_details["items"][0]["snippet"]["title"], "reviews": [], "url": 'https://www.youtube.com/watch?v=' + video_id, "comment_count": video_details["items"][0]["statistics"]["commentCount"] } data = [] results = self.youtube.commentThreads().list( part="snippet", videoId=video_id, textFormat="plainText").execute() for item in results["items"]: snippet = item['snippet']['topLevelComment']['snippet'] if snippet: review_dict = { 'review': snippet.get('textOriginal', ''), 'date': dateparser.parse( snippet['publishedAt']).strftime('%d %b %Y'), 'star_rating': 0, 'user_name': snippet.get('authorDisplayName', ''), 'url': 'https://www.youtube.com/watch?v={0}&lc={1}'.format( video_id, item['id']) } data.append(review_dict) while "nextPageToken" in results: results = self.youtube.commentThreads().list( part="snippet", videoId=video_id, pageToken=results["nextPageToken"], textFormat="plainText", ).execute() for item in results["items"]: snippet = item['snippet']['topLevelComment']['snippet'] if snippet: review_dict = { 'review': snippet.get('textOriginal', ''), 'date': dateparser.parse( snippet['publishedAt']).strftime('%d %b %Y'), 'star_rating': 0, 'user_name': snippet.get('authorDisplayName', ''), 'url': 'https://www.youtube.com/watch?v={0}&lc={1}'. format(video_id, item['id']) } data.append(review_dict) video_information["reviews"] = data item = models.Item(name=video_information['name'], url=youtube_url, ref_id=video_id) db.session.add(item) db.session.commit() for comment in data: review = models.Review(user_name=comment['user_name'], review=comment['review'], url=comment['url'], date=comment['date'], star_rating=comment['star_rating'], item_id=item.id) db.session.add(review) db.session.commit() return item.id except Exception as e: print(e) self.errors.append(e.__str__()) return {"error": self.errors} return {"error": "failed to process comments", "video_id": video_id}