def book_page(book_id): searchform = SearchForm() db = current_app.config["db"] book, author_id = db.get_book(book_id) reviews, users = db.get_reviews(book_id) if book is None: abort(404) form = ReviewForm() if form.validate_on_submit(): score = form.data["score"] comment = form.data["comment"] author = db.get_user_id(current_user.username) review = Review(author=author, book=book_id, score=score, comment=comment) review_id = db.add_review(review) review.id = review_id return redirect(url_for("book_page", book_id=book_id)) return render_template("book.html", book=book, author_id=author_id, form=form, reviews=reviews, users=users, searchform=searchform)
def test_review(): txt = "I don't love her any more" r = Review('abc',txt) d = r.to_dict() cpyr = Review.from_dict(d) print cpyr.to_dict()
def get_data_from_file(self): ngram_count = {} ngrams_list = [] reviews = [] x_train_dataset = [] y_train_dataset = [] threshold = 128 train = random.sample(self.files, 10000) #train = self.files for path in train: if ('train' not in path[0]): continue with open(path[0] + '/' + path[1]) as reader: review = reader.read() review = Review(review, path) if (self.n > 1): ngrams = review.generate_ngrams(n=2) else: ngrams = review.review reviews.append(review) for elem in ngrams: if (elem not in ngram_count): ngram_count[elem] = 0 ngram_count[elem] += 1 x_train_dataset, y_train_dataset, input_size = self.make_bag_of_words( ngram_count, reviews, threshold) return x_train_dataset, y_train_dataset, reviews, input_size
def review(user_msg): """ This function analyzes the users review of a cafe and returns a response about the sentiment of the review. :param user_msg: string :return: str """ # initiate review object rvw = Review(user_msg) # determine if review is positive or negative predicted_sentiment = rvw.predict_sentiment() # store review rvw.store_review() # if positive, respond to positive experience if predicted_sentiment == 1: response_msg = "Based on your review, it seems that you had a good time. Great! For another recommendation, please write: recommend me" # otherwise it was negative, respond to negative experience else: response_msg = "Based on your review, it seems that you did not have a good time. I'm sorry! For another recommendation, please write: recommend me" return response_msg
def test_review(): txt = "I don't love her any more" r = Review('abc', txt) d = r.to_dict() cpyr = Review.from_dict(d) print cpyr.to_dict()
def get_book_reviews(book_link): """Given a url representing a book, return the reviews for that book. The reviews are stored in a dictionary. Each review has an id as the key, and a dictionary as the value. The value stores the date and the contents of the review, as strings. """ page = requests.get(book_link) soup = BeautifulSoup(page.content, 'html.parser') reviews = {} dates = soup.find_all("a", {"class": "reviewDate createdAt right"}, href=True) contents = soup.find_all("div", {"class": "reviewText stacked"}) analyser = SentimentIntensityAnalyzer() for id in range(len(contents)): score = analyser.polarity_scores(contents[id].get_text().strip()) key = str(id) review = Review(date=dates[id].get_text().strip(), content=contents[id].get_text().strip(), score=score) reviews[key] = review.create_dictionary() print(contents[id].get_text().strip()) return reviews
def getReviews(self): reviews_array = [] i = 1 hdr = {'User-Agent': 'super happy flair bot by /u/spladug'} url = self.REVIEWS_ENDPOINT + self.id + '&pagenumber=' + str( i) + '&pagesize=50&recipeType=Recipe&sortBy=MostHelpful' req = urllib2.Request(url, headers=hdr) data = urllib2.urlopen(req).read() lxml_data = lxml.html.fromstring(data) reviews = lxml_data.xpath(self.REVIEWS_TAG) while len(reviews) != 0: for review in reviews: r = Review() r.parseReview(review, self.id) reviews_array.append(r) i += 1 try: time.sleep(random.random() + 1) data = urllib2.urlopen( self.REVIEWS_ENDPOINT + self.id + '&pagenumber=' + str(i) + '&pagesize=50&recipeType=Recipe&sortBy=MostHelpful').read( ) lxml_data = lxml.html.fromstring(data) reviews = lxml_data.xpath(self.REVIEWS_TAG) except: # Assume if we cannot get the next page of the reviews, then there are no more reviews reviews = {} return reviews_array
def post(self, product_id, member_id): json_string = self.request.body review_props = review_properties(json_string) new_review = Review(product_id=product_id, member_id=member_id, time=review_props["time"], rating=review_props["rating"], summary=review_props["summary"], text=review_props["text"]) new_review.put() json_response_dict = new_review.to_dict() # This dictionary is not quite ready to serialize into JSON because JSON has no native datetime type. # It is common in JSON to use an ISO 8601 datetime string with Z (representing GMT/UT) as the timezone. # Such a datetime looks like: "2016-10-04T18:55:11Z". Therefore we make that substitution (including the # trailing "Z" which is not optional, but the library leaves it off because conventionally python does # not distinguish between offsetless datetimes and UTC datetimes (a datetime with an offset that is 0). json_response_dict["time"] = json_response_dict["time"].isoformat( ) + "Z" # Now we can dump into valid json. json_response_string = json.dumps(json_response_dict) # Set the response type and write the json. self.response.headers["Content-Type"] = "application/json" self.response.write(json_response_string)
def callback(ch, method, properties, body): """ This function will be triggered when an element enter the pastebin_parser queue. Review object will be create in order to parse the content of a text file stored at "tmp/pastebin/<filename>". """ body = body.decode('utf-8') msg = f"Data {body} received from queue {lc.PARSER_QUEUE}" if gc.DEBUG: log_info('pastebin', msg) path = f"{lc.TEMP_STORAGE}/{body}" try: with open(path, 'r') as f: data = f.read() except Exception as e: msg = f"callback() failed, for file {body}: {e}" log_info('pastebin', msg) return delimiter = data.find('\n') metadata = data[0:delimiter] data = data[delimiter + 1::] review = Review(metadata, data) review.search(path, body) ch.basic_ack(delivery_tag=method.delivery_tag)
def get_reviews(hotel_file): hotel = TaHotel(hotel_file) for index,tareview in enumerate( hotel.reviews): review = Review() review.business_id = hotel.id review.ratings = tareview.ratings review.assign_content(tareview.entire_content(),StopWords) yield review
def read_review_data(filename): review_list = [] with open(filename) as json_file: data = json.load(json_file) for obj in data['reviews']: review = Review() review.rating = obj['rating'] review.date = obj['date'] review.text = obj['review_text'] review_list.append(review) return review_list
def new_review(): if request.method == 'GET': return render_template('new_review.html') elif request.method == 'POST': form = request.form au = form['author'] s = form['song'] ar = form['artist'] c = form['content'] print(au, s, ar, c) new_review = Review(author=au, song=s, artist=ar, content=c) new_review.save() return redirect(url_for('reviews'))
def run(self): for index,fname in enumerate(self.allfiles): hotel = TaHotel(fname) reviews = [] for tareview in hotel.reviews: review = Review() review.business_id = hotel.id review.ratings = tareview.ratings review.assign_comment(tareview.entire_content(),self.stopwords) reviews.append(review) if len(reviews)>0: self.queue.put(reviews) print "[PARSER]: {}-th file<{}> parsed, {} reviews enqueued".format(index+1,fname,len(reviews))
def test_user(): user1 = User('Martin', 'pw12345') user4 = User('Martin', 'pw12345') user2 = User('Ian', 'pw67890') user3 = User('Daniel', 'pw87465') movie = Movie("Moana", 2009) review_text = "It was so average" rating = 10 review = Review(movie, review_text, rating) print(movie) movie.runtime_minutes = 107 movie3 = Movie("", 4545) print(movie3) movie2 = Movie("Inception", 2010) movie2.runtime_minutes = 133 user1.watch_movie(movie) user1.watch_movie(movie2) user1.watch_movie(movie) user2.add_review(review) print(user1) print(user4) print(user2) print(user3) print(user1 == user4) print(user1 > user2) print(user1.time_spent_watching_movies_minutes) print(user2.reviews) print(user1.watched_movies)
def get(self, id=None): self.response.headers["Content-Type"] = "text/html" url = "" user = users.get_current_user() review_form_url = '/electric_vehicles/review/' if user: url = users.create_logout_url(self.request.uri) url_string = "logout" else: url = users.create_login_url(self.request.uri) url_string = "login" if id: electric_vehicle = ElectricVehicle.get_by_id(int(id)) reviews = Review.query(Review.electric_vehicle == electric_vehicle. key).order(-Review.date).fetch() for_score = [rev.score for rev in reviews] avg_review = 0 if len(for_score): avg_review = sum(for_score) / len(for_score) template_values = { "avg_review": avg_review, "reviews": reviews, "review_form_url": review_form_url, "electric_vehicle": electric_vehicle, "url": url, "url_string": url_string, "user": user } template = JINJA_ENVIRONMENT.get_template( "electric_vehicles/show.html") self.response.write(template.render(template_values))
def readReviews(reviewIDs, folder, ironic): """Returns a dictionary containing reviews to the given IDs.""" return { reviewID: Review(filename="{0}{1}.txt".format(folder, reviewID), ironic=ironic) for reviewID in reviewIDs }
def getReviews(self): reviews_array = [] i = 1 data = urllib2.urlopen(self.REVIEWS_ENDPOINT + self.id + '&pagenumber=' + str(i) + '&pagesize=50&recipeType=Recipe').read() lxml_data = lxml.html.fromstring(data) reviews = lxml_data.xpath(self.REVIEWS_TAG) while len(reviews) != 0: for review in reviews: r = Review() r.parseReview(review, self.id) reviews_array.append(r) i += 1 data = urllib2.urlopen(self.REVIEWS_ENDPOINT + self.id + '&pagenumber=' + str(i) + '&pagesize=50&recipeType=Recipe').read() lxml_data = lxml.html.fromstring(data) reviews = lxml_data.xpath(self.REVIEWS_TAG) return reviews_array
def crawl(url): data = urllib.request.urlopen(url).read() review_list = [] soup = bs(data, 'html.parser') soup.select('h3>a')[0].text title = soup.find('h3', class_='h_movie').find('a').text div = soup.find('div', class_='score_result') data_list = div.select('ul > li') for review in data_list: star = review.find('div', class_='star_score').text.strip() reply = review.find('div', class_='score_reple') comment = reply.find('p').text date = reply.select('dt>em')[1].text.strip() button = review.find('div', class_='btn_area') sympathy = button.select('strong') good = sympathy[0].text bad = sympathy[1].text review_list.append(Review(comment, date, star, good, bad)) return title, review_list
def review_edit_page(review_id): searchform = SearchForm() db = current_app.config["db"] review = db.get_review(review_id) if review is None: abort(404) if not current_user.id == review.author: abort(401) form = ReviewForm() if form.validate_on_submit(): score = form.data["score"] comment = form.data["comment"] author = review.author book_id = review.book review_id = review.id review_ = Review(score=score, comment=comment, author=author, book=book_id, id=review_id) db.update_review(review_) flash("Review updated successfully.") return redirect(url_for("book_page", book_id=book_id)) form.score.data = str(review.score) form.comment.data = review.comment return render_template("review_edit.html", form=form, searchform=searchform)
def add_review(self, item, text, rating): new_review = Review(self, item, text, rating) self.reviews.append(new_review) logger.info( f"{self.first_name} {self.last_name}'s review for '{item.title}' was added." ) return new_review
def create_review(self, item, rate): new_review = Review(self, item, rate) self.reviews.append(new_review) logger.info( f"New review by {new_review}, is created by the customer: {self.id}" ) return new_review
def read_data(path): reviews_list = []; f1 = open(path, 'r'); lines1 = f1.readlines(); for i in range(len(lines1)): reviews_list += [Review(lines1[i].strip(),"")] return reviews_list;
async def handle_dm(self, message): # Translate unicode message.content = uni2ascii(message.content) # Handle a help message if message.content == Report.HELP_KEYWORD: reply = "Use the `report` command to begin the reporting process.\n" reply += "Use the `cancel` command to cancel the report process.\n" await message.channel.send(reply) return author_id = message.author.id responses = [] # Let the report class handle this message; forward all the messages it returns to us if author_id not in globals.CURRENT_REVIEWERS_DB: # Only respond to messages if they're part of a reporting flow if author_id not in self.reports and not message.content.startswith(Report.START_KEYWORD): return # If we don't currently have an active report for this user, add one if author_id not in self.reports: self.reports[author_id] = Report(self) responses, report = await self.reports[author_id].handle_message(message) for r in responses: await message.channel.send(r) # If the report is complete or cancelled, remove it from our map if self.reports[author_id].report_complete(): if report is not None and report.reporting_user not in globals.BAD_REPORT_TRACKER: globals.BAD_REPORT_TRACKER[report.reporting_user] = 1 self.reports.pop(author_id) if report is not None and globals.BAD_REPORT_TRACKER[report.reporting_user] <= globals.BAD_REPORT_THRESHOLD: globals.TICKET_NUM += 1 globals.REPORTS_DATABASE[globals.TICKET_NUM] = report await self.handle_report(globals.TICKET_NUM) else: # This is a review from a moderator # If we don't currently have an active report for this user, add one if author_id not in self.reviews and message.content != "s": return if author_id not in self.reviews: self.reviews[author_id] = Review(self) case_id = globals.CURRENT_REVIEWERS_DB[author_id] report = globals.REPORTS_DATABASE[(int)(case_id)] responses = await self.reviews[author_id].review_report(message, report, case_id, author_id) for r in responses: await message.channel.send(r) # If the review is complete or cancelled, remove it from our map if self.reviews[author_id].review_complete(): self.reviews.pop(author_id) del globals.CURRENT_REVIEWERS_DB[author_id] # Set number of reviewers in globals file if (len(globals.REVIEWS_DATABASE[case_id]) >= globals.NUM_REVIEWERS): await self.handle_review(case_id)
def reviews(self): recipes = self.recipes() reviews = [] for recipe in recipes: for review in Review.all(): if recipe == review.recipe: reviews.append(review) return reviews
def reviews(self): recipe_list = self.recipes() review_list = [] for item in recipe_list: review_list += [ review for review in Review.all() if review.recipe == item ] return review_list
def test_review_class_methods(self): self.assertItemsEqual(Review._all, [ review_1, review_2, review_3, review_4, review_5, review_6, review_7, review_8, review_9, review_10 ]) self.assertItemsEqual(Review.all(), [ review_1, review_2, review_3, review_4, review_5, review_6, review_7, review_8, review_9, review_10 ])
def sentence_stream(colname): client = pymongo.MongoClient() collection = client.popcorn[colname] cursor = collection.find({}, {'words':0 }) for d in cursor: yield Review.from_dict(d) client.close()
def insert_review(self, rating, product_id, customer_email): try: review = Review(rating, product_id, customer_email) self.session.add(review) self.session.commit() if id is not None or id != 0: return [True, review] except SQLAlchemyError as e: return [False, e]
def LogisticTest(self, words, parser): x_test = [] for word in words: review = Review(word) x_test.append(parser.bag_of_one_word(review, self.n)) print(self.nb.predict(x_test)) print(self.nb.predict_proba(x_test))
def sentence_stream(colname): client = pymongo.MongoClient() collection = client.popcorn[colname] cursor = collection.find({}, {'words': 0}) for d in cursor: yield Review.from_dict(d) client.close()
def load(self, directory, label): reviews = [] for root, subFolders, files in os.walk(directory): for file in files: with open(os.path.join(root, file), 'r') as fin: for lines in fin: reviews.append( Review(lines, label, os.path.join(root, file))) return reviews
def get(self, member_id): q = Review.query().filter(Review.member_id == member_id) count = q.count() to_fetch = count if count < 10 else 10 reviews = q.fetch(to_fetch) print("Found " + str(count) + " reviews for member " + member_id + ", returning " + str(to_fetch)) self.response.headers["Content-Type"] = "application/json" write_reviews(reviews, self.response)
def init_data(textfile, lablesfile): reviews_list = [] f1 = open(textfile, 'r') f2 = open(lablesfile, 'r') lines1 = f1.readlines() lines2 = f2.readlines() for i in range(len(lines1)): reviews_list += [Review(lines1[i].strip(), lines2[i].strip())] return reviews_list
def bottom_three(cls): recipe_dict = {} for item in Review.all(): recipe_dict[item.recipe] = item.recipe.avg_rating() sorted_recipe_dict = dict( sorted(recipe_dict.items(), key=lambda item: item[1])) final_list = [] for i in range(0, 3): final_list.append(list(sorted_recipe_dict.keys())[i]) return final_list
def favorite_recipe(self): recipe_list = { review.recipe: review.rating for review in Review.all() if review.reviewer == self } favorite = max(recipe_list.values()) return [ review for review, rating in recipe_list.items() if rating == favorite ][0]
def getReviews(self): reviews_array = [] i = 1 data = urllib2.urlopen(self.REVIEWS_ENDPOINT + self.id + '&pagenumber=' + str(i) + '&pagesize=50&recipeType=Recipe&sortBy=MostHelpful').read() lxml_data = lxml.html.fromstring(data) reviews = lxml_data.xpath(self.REVIEWS_TAG) while len(reviews) != 0: for review in reviews: r = Review() r.parseReview(review, self.id) reviews_array.append(r) i += 1 try: data = urllib2.urlopen(self.REVIEWS_ENDPOINT + self.id + '&pagenumber=' + str(i) + '&pagesize=50&recipeType=Recipe&sortBy=MostHelpful').read() lxml_data = lxml.html.fromstring(data) reviews = lxml_data.xpath(self.REVIEWS_TAG) except: # Assume if we cannot get the next page of the reviews, then there are no more reviews reviews = {} return reviews_array
def get_all_known_aspect_sentences(dbname): client = MongoClient() review_collection = client[dbname]["reviews"] query_condition = {"sentences": {'$elemMatch': {'aspect': {'$ne':'Unknown'}} } } cursor = review_collection.find(query_condition,{"sentences":1}) for d in cursor: review = Review.from_dict(d) for sentence in review.sentences: if sentence.aspect != "Unknown": yield sentence client.close()
def test_load_review_words(): client = MongoClient() collection = client['airbnb']['reviews'] cursor = collection.find({}) for index in xrange(10): d = next(cursor) review = Review.from_dict(d) print "*************** {} ***************".format(index+1) print "raw: {}".format(review.sent.raw) print "words: {}".format(review.sent.words) client.close()
def load_reviews_save_sentiment_sentences(dbname,classifier): client = MongoClient() db = client[dbname] reviews_collection = db["reviews"] sentisent_collection = db["sentiment_sentences"] review_cursor = reviews_collection.find({}) for index,rd in enumerate(review_cursor): review = Review.from_dict(rd) sentence_dicts = [ s.to_dict() for s in review_to_sentences(review,classifier) ] if len(sentence_dicts)>0: sentisent_collection.insert_many(sentence_dicts) print "{}-th review extract {} sentences and saved".format(index+1,len(sentence_dicts)) client.close()
def update_add_neg_suffix(dbname,query_condition): stop_words = common.make_stop_words() client = MongoClient() review_collection = client[dbname]['reviews'] cursor = review_collection.find(query_condition,{"sentences.raw":1,"sentences.words":1}) for rindex,rd in enumerate(cursor): review = Review.from_dict(rd) update_content = {} for sindex,sent in enumerate(review.sentences): new_sent = Sentence.from_raw(sent.raw,stop_words) if set(new_sent.words) != set(sent.words): update_content["sentences.{}.words".format(sindex)] = new_sent.words if len(update_content)>0: result = review_collection.update_one({"_id":review.id},{"$set":update_content}) if result.modified_count != 1: raise Exception("failed to update review<{}>".format(review.id)) print "{}-th review updated {} sentences".format(rindex+1,len(update_content)) client.close()
class QAReviewer(gnomeglade.GnomeApp): # # Program Initialization # def __init__(self, arguments): """Creates a new QA reviewer window. Keyword -- arguments: arguments: A commandline to process when setting up the environment """ # Create the properties for this checklist ### FIXME: Properties is hard-coded right now. Needs some love. self.properties = Properties('fedoraus.xml') # Load the interface gladefile = 'glade/qa-assistant.glade' gnomeglade.GnomeApp.__init__(self, __programName__, __version__, gladefile, 'ReviewerWindow') self.program.set_property(gnome.PARAM_HUMAN_READABLE_NAME, __programHumanName__) # # Create additional interface components # iconFile = self._GnomeApp__uninstalled_file('pixmaps/qa-icon.png') if iconFile == None: iconFile = self.locate_file(gnome.FILE_DOMAIN_APP_PIXMAP, 'qa-icon.png') if iconFile == []: iconFile = None else: iconFile = iconFile[0] if iconFile: self.ReviewerWindow.set_property('icon', gnomeglade.load_pixbuf(iconFile)) # Create a treeview for our listPane self.checkView = gtk.TreeView() self.checkView.set_rules_hint(True) # load the checklist data (Associates itself with checkView) self.__load_checklist() renderer = gtk.CellRendererToggle() renderer.set_radio(False) column = gtk.TreeViewColumn('Display', renderer, active=checklist.DISPLAY, visible=checklist.ISITEM) renderer.connect('toggled', self.display_toggle) self.checkView.append_column(column) renderer = OptionCellRenderer() column = gtk.TreeViewColumn('pass/fail', renderer, optionlist=checklist.RESLIST, selectedoption=checklist.RESOLUTION, mode=checklist.ISITEM) column.set_cell_data_func(renderer, self.__translate_option_mode) renderer.connect('changed', self.resolution_changed) self.checkView.append_column(column) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn('Description', renderer, text=checklist.SUMMARY) self.checkView.append_column(column) renderer = gtk.CellRendererText() renderer.connect('edited', self.output_edited, self.checklist.tree) column = gtk.TreeViewColumn('Output', renderer, markup=checklist.OUTPUT, visible=checklist.DISPLAY, editable=checklist.DISPLAY) self.outputColumn = column self.checkView.append_column(column) self.tips = TreeTips(self.checkView, checklist.DESC) self.listPane.add(self.checkView) self.checkView.show() self.grabArrow=gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE) self.grabArrow.set_size_request(4,4) label=self.grabBar.get_child() self.grabBar.remove(label) self.grabBar.add(self.grabArrow) self.grabArrow.show() self.reviewView = Review(self.checklist.tree, self.properties) self.reviewView.show() self.reviewPane.add(self.reviewView) self.reviewScroll.hide() # # Command line initialization # ### FIXME: take care of the command line args ### FIXME: Absolute dependence on arguments[1] being an SRPM without a # check to make sure of it. Need to fix that up with cmd-line args. if len(arguments) == 2: self.SRPM_into_properties(arguments[1]) # # Blast off! # self.__check_readiness() self.ReviewerWindow.show() # # Helper Functions # def __load_checklist(self): ### FIXME: When calling this function to load a new checklist, we # need to be careful. There was a bug where loading a new checklist # was causing editing of cells to no longer work. I think we have # to reload our checklistPane everytime we load a new checklist.... # -- Some restructuring of code to do there. # -- May only need to make sure self.checklist.tree is set correctly? filename = os.path.join('data', self.properties.checklistName) checkFile = self._GnomeApp__uninstalled_file(filename) if checkFile == None: filename = os.path.join(__programName__, filename) checkFile = self.locate_file(gnome.FILE_DOMAIN_APP_DATADIR, filename) if checkFile == []: checkFile = None else: checkFile = checkFile[0] if checkFile == None: ### FIXME: When we can select checklists via property, we need to # print error and recover. sys.stderr.write("Unable to find checklist: %s\n" % (filename)) sys.exit(1) try: self.checklist = checklist.CheckList(checkFile, self.properties) except (libxml2.parserError, libxml2.treeError, checklist.Error), msg: ### FIXME: When we can select checklists via property, we need to # print error and recover. sys.stderr.write("Unable to parse the checklist: %s\n" % (msg)) sys.exit(1) self.checkView.set_model(self.checklist.tree) if self.checklist.type == 'SRPM': from srpmqa import SRPMQA qamenu = SRPMQA(self) else: from genericqa import GenericQA qamenu = GenericQA(self) self.QAMenuItem.set_submenu(qamenu) qamenu.show_all()
break; for hotel in soup.findAll('a',{'class': 'property_title'}): hotel_name = hotel.string[1:] url_path = base_url + hotel['href'] ##Initialize fetch = FetchInfo(url_path) ##fetch thumb_up rank and total_reviews thumb_up = fetch.fetch_thumb_up() #thumb up rank = fetch.fetch_rank() #rank total_reviews = fetch.fetch_total_reviews() #total_reviews address = fetch.fetch_address() ##construct Review object ##txt_title = """%s, %s, %s, %s """ %(hotel_name, thumb_up.string, rank.string, str(total_reviews) + " Reviews") # txt_title rev = Review(hotel_name,address,thumb_up,rank[8:]) #Review Object ##fill all review properties in the reviewers i = 0 while i <= 4: fetch.fetch_review_properties(rev,total = total_reviews, index = i) i = i + 1 rev.write_into_file() count = count + 1 print "No. " + str(count) + " finish " + rev.hotel_name + "!" page = page + 1 except Exception, e: print sys.exc_traceback.tb_lineno print e
def find_review_summary(cls): from review import Review return Review.stats_query().join(cls).add_entity(cls).group_by(cls)
class QAReviewer(gnomeglade.GnomeApp): # # Program Initialization # def __init__(self, arguments): """Creates a new QA reviewer window. Keyword -- arguments: arguments: A commandline to process when setting up the environment """ # Create the properties for this checklist ### FIXME: Properties is hard-coded right now. Needs some love. self.properties = Properties('fedoraus.xml') # Load the interface gladefile = 'glade/qa-assistant.glade' gnomeglade.GnomeApp.__init__(self, __name__, __version__, gladefile, 'ReviewerWindow') # # Create additional interface components # # Create a treeview for our listPane self.checkView = gtk.TreeView() self.checkView.set_rules_hint(True) # load the checklist data (Associates itself with checkView) self.__load_checklist() renderer = gtk.CellRendererToggle() renderer.set_radio(False) column = gtk.TreeViewColumn('Display', renderer, active=checklist.DISPLAY, visible=checklist.ISITEM) renderer.connect('toggled', self.display_toggle) self.checkView.append_column(column) renderer = OptionCellRenderer() column = gtk.TreeViewColumn('pass/fail', renderer, optionlist=checklist.RESLIST, selectedoption=checklist.RESOLUTION, mode=checklist.ISITEM) column.set_cell_data_func(renderer, self.__translate_option_mode) renderer.connect('changed', self.resolution_changed) self.checkView.append_column(column) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn('Description', renderer, text=checklist.SUMMARY) self.checkView.append_column(column) renderer = gtk.CellRendererText() renderer.connect('edited', self.output_edited, self.checklist.tree) column = gtk.TreeViewColumn('Output', renderer, text=checklist.OUTPUT, visible=checklist.DISPLAY, editable=checklist.DISPLAY) self.outputColumn = column self.checkView.append_column(column) self.tips = TreeTips(self.checkView, checklist.DESC) self.listPane.add(self.checkView) self.checkView.show() self.grabArrow=gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE) self.grabArrow.set_size_request(4,4) label=self.grabBar.get_child() self.grabBar.remove(label) self.grabBar.add(self.grabArrow) self.grabArrow.show() self.reviewView = Review(self.checklist.tree, self.properties) self.reviewView.show() self.reviewPane.add(self.reviewView) self.reviewScroll.hide() # # Command line initialization # ### FIXME: take care of the command line args ### FIXME: Absolute dependence on arguments[1] being an SRPM without a # check to make sure of it. Need to fix that up with cmd-line args. if len(arguments) == 2: self.__SRPM_into_properties(arguments[1]) # # Blast off! # self.__check_readiness() self.ReviewerWindow.show() # # Helper Functions # def __load_checklist(self): try: self.checklist = checklist.CheckList('data/'+self.properties.checklistName) except (libxml2.parserError, libxml2.treeError, checklist.Error), msg: ### FIXME: When we can select checklists via property, we need to # print error and recover. sys.stderr.write("Unable to parse the checklist: %s\n" % (msg)) sys.exit(1) self.checkView.set_model(self.checklist.tree)
for cur in range(start, end): print 'page: ' + str(cur) data_dir = 'data/' + str(cur) + '/' paths = os.listdir(data_dir) paths = [relpath for relpath in paths if \ relpath.find('index.html') == -1 and \ relpath != "urls" and relpath.find('.arff') == -1] for relpath in paths: path = data_dir + relpath print path soup = BeautifulSoup(open(path)) try: meta = soup.find('ul', {"class":"review-meta"}) rev = Review() rev.id = int(re.search('\d+', relpath).group(0)) rev.artist = meta.find('h1').find('a').get_text() rev.album = meta.find('h2').get_text() str_date = meta.find('span', {"class":"pub-date"}).get_text() rev.date = datetime.strptime(str_date, '%B %d, %Y') rev.score = float(meta.find('span', {"class":"score"}).get_text()) rev.text = soup.find('div', {"class":"editorial"}).get_text() db.reviews.insert(rev.__dict__) count = count + 1 print count #out.write(rev.arff_row()) #print str(rev) except Exception as e:
def __init__(self, arguments): """Creates a new QA reviewer window. Keyword -- arguments: arguments: A commandline to process when setting up the environment """ # Create the properties for this checklist ### FIXME: Properties is hard-coded right now. Needs some love. self.properties = Properties('fedoraus.xml') # Load the interface gladefile = 'glade/qa-assistant.glade' gnomeglade.GnomeApp.__init__(self, __programName__, __version__, gladefile, 'ReviewerWindow') self.program.set_property(gnome.PARAM_HUMAN_READABLE_NAME, __programHumanName__) # # Create additional interface components # iconFile = self._GnomeApp__uninstalled_file('pixmaps/qa-icon.png') if iconFile == None: iconFile = self.locate_file(gnome.FILE_DOMAIN_APP_PIXMAP, 'qa-icon.png') if iconFile == []: iconFile = None else: iconFile = iconFile[0] if iconFile: self.ReviewerWindow.set_property('icon', gnomeglade.load_pixbuf(iconFile)) # Create a treeview for our listPane self.checkView = gtk.TreeView() self.checkView.set_rules_hint(True) # load the checklist data (Associates itself with checkView) self.__load_checklist() renderer = gtk.CellRendererToggle() renderer.set_radio(False) column = gtk.TreeViewColumn('Display', renderer, active=checklist.DISPLAY, visible=checklist.ISITEM) renderer.connect('toggled', self.display_toggle) self.checkView.append_column(column) renderer = OptionCellRenderer() column = gtk.TreeViewColumn('pass/fail', renderer, optionlist=checklist.RESLIST, selectedoption=checklist.RESOLUTION, mode=checklist.ISITEM) column.set_cell_data_func(renderer, self.__translate_option_mode) renderer.connect('changed', self.resolution_changed) self.checkView.append_column(column) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn('Description', renderer, text=checklist.SUMMARY) self.checkView.append_column(column) renderer = gtk.CellRendererText() renderer.connect('edited', self.output_edited, self.checklist.tree) column = gtk.TreeViewColumn('Output', renderer, markup=checklist.OUTPUT, visible=checklist.DISPLAY, editable=checklist.DISPLAY) self.outputColumn = column self.checkView.append_column(column) self.tips = TreeTips(self.checkView, checklist.DESC) self.listPane.add(self.checkView) self.checkView.show() self.grabArrow=gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE) self.grabArrow.set_size_request(4,4) label=self.grabBar.get_child() self.grabBar.remove(label) self.grabBar.add(self.grabArrow) self.grabArrow.show() self.reviewView = Review(self.checklist.tree, self.properties) self.reviewView.show() self.reviewPane.add(self.reviewView) self.reviewScroll.hide() # # Command line initialization # ### FIXME: take care of the command line args ### FIXME: Absolute dependence on arguments[1] being an SRPM without a # check to make sure of it. Need to fix that up with cmd-line args. if len(arguments) == 2: self.SRPM_into_properties(arguments[1]) # # Blast off! # self.__check_readiness() self.ReviewerWindow.show()