def update_session(self):
"""
Update session feeds, entries and entries scores
"""
session_dict = shelve(self.previous_session)
self.initialize_shelve_structure(session_dict)
self.initialize_each_seen_entry_as_useless(
session_dict["seen_entries_keys"])
for feed in self.feeds_url_dict:
feed_url = self.feeds_url_dict[feed]
if feed_url in session_dict["feed_url_names"]:
old_feed_name = session_dict["feed_url_names"][feed_url]
if feed != old_feed_name:
self.change_feed_name_session_dict(session_dict,
old_feed_name, feed)
session_dict["feed_url_names"][feed_url] = feed
received_entries = preprocess_feed(feed_url)
for key, entry in received_entries.iteritems():
if feed not in session_dict["preferences"][self.home]:
session_dict["preferences"][self.home][feed] = {}
if key not in session_dict["seen_entries_keys"]:
session_dict["preferences"][self.home][feed][key] = entry
session_dict["seen_entries_keys"][key] = 1
self.predict_entries_in_dict(
session_dict["preferences"][self.home][feed])
self.filter_url_feeds(session_dict)
self.filter_previous_session_file_after_config_update(session_dict)
self.prune_useless_stored_entries_keys(
session_dict["seen_entries_keys"])
session_dict.close()
def update_feed_or_preference_folder(self):
"""
Updates the values for server.feed_chosen or server.current_preference_folder
according to the values of the path
"""
preference, feed = self.extract_chosen_preference_and_feed_from_path()
session_dict = shelve(self.server.previous_session)
if preference in session_dict["preferences"].keys():
self.server.current_preference_folder = preference
self.server.feed_chosen = ""
if feed in self.server.feeds_url_dict.keys():
self.server.feed_chosen = feed
session_dict.close()
def update_preference_feed_menus_from_submission(self):
"""
Sends rated entries to its corresponding location in preference menu
(i.e. Liked entries to Like location, Unliked to Unlike ...)
"""
query_components = self.extract_query_components()
if query_components.keys():
component = query_components.keys()[0].split(".")[0]
preference = query_components[component]
entry_information = self.extract_data_from_id_entry(component)
feed_name = entry_information["feed"]
index = entry_information["index"]
session_dict = shelve(self.server.previous_session)
if index in session_dict["preferences"][
self.server.current_preference_folder][feed_name].keys():
if preference == "Like":
entry = session_dict["preferences"][
self.server.current_preference_folder][feed_name].pop(
index)
if feed_name not in session_dict["preferences"][
preference]:
session_dict["preferences"][preference][feed_name] = {}
session_dict["preferences"][preference][feed_name][
index] = entry
x = tranform_feed_entry_to_bag_of_words(entry)
self.server.nayesdog.fit(x, 1)
session_dict.close()
if preference == "Dislike":
entry = session_dict["preferences"][
self.server.current_preference_folder][feed_name].pop(
index)
x = tranform_feed_entry_to_bag_of_words(entry)
self.server.nayesdog.fit(x, 0)
session_dict.close()
if preference in ["Delete"]:
session_dict["preferences"][
self.server.current_preference_folder][feed_name].pop(
index)
session_dict.close()
if preference == "Save":
entry = session_dict["preferences"][
self.server.
current_preference_folder][feed_name][index]
file_save = open(feed_name + "_saved_entries.html", "a")
file_save.write(represent_rss_entry(entry, component))
file_save.write(self.generate_entry_separator())
file_save.close()
else:
print "{} not in keys()".format(index)
def do_GET(self):
"""
Reaction to get method. If the requested element is the style, sends the css style.
If it is an image sends the image. Otherwise, it reconstructs the webpage according
to the changes and sent it to the client.
"""
self.send_response(200)
mimetype, _ = mimetypes.guess_type(self.path)
if ".css" in self.path: #== '/'+self.server.cssfile
self.send_header('Content-type', mimetype)
self.end_headers()
self.wfile.write(file_to_str(self.server.cssfile))
elif mimetype is not None and "image" in mimetype:
imfile = self.path.split("/")[-1]
imfile = os.path.join(self.server.icons_folder, imfile)
if os.path.isfile(imfile):
self.send_header('Content-type', mimetype)
self.end_headers()
self.wfile.write(file_to_str(imfile))
else:
self.update_feed_or_preference_folder()
self.update_preference_feed_menus_from_submission()
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(page_head_tpl)
self.wfile.write('<body>\n')
# Generate preferences menu
session_dict = shelve(self.server.previous_session)
preference_menu_keys = session_dict["preferences"].keys()
preference_menu = ""
for preference in preference_menu_keys:
dict_feeds = session_dict["preferences"][preference]
feeds_menu_keys = dict_feeds.keys()
menu_element = self.generate_feeds_menu(
feeds_menu_keys,
drop_button_name=preference,
drop_button_text=preference,
div_name="dropdown" + preference,
button_function="myFunction" + preference + "()",
dropdown_ID="myDropdown" + preference,
filter_function="filterFunction" + preference + "()",
input_name="myInput" + preference)
"""
if preference == self.server.current_preference_folder:
menu_element = to_span("selected_link", menu_element)
else:
menu_element = to_span("unselected_link", menu_element)
menu_element = to_div(preference+"menu",menu_element)
"""
preference_menu += menu_element
toggle_images_link = generate_link("#", "Toggle images",
"javascript:imtoggle()")
toggle_images_link = to_span("toggle_images", toggle_images_link)
preference_menu += toggle_images_link
train_link = generate_link("/Train", "Train and bring news")
train_link = to_span("train", train_link)
preference_menu += train_link
self.wfile.write(preference_menu)
# Generate feeds menu in the current preference menu
current_preference = self.server.current_preference_folder
dict_feeds = session_dict["preferences"][current_preference]
feeds_menu_keys = dict_feeds.keys()
self.wfile.write(to_header(1, current_preference))
feed_chosen = self.server.feed_chosen
self.wfile.write(
to_header(2,
self.server.correct_feed_name_to_text(feed_chosen)))
self.wfile.write(self.generate_entry_separator())
session_dict.close()
if "Train" in self.path:
self.server.update_session()
if self.server.feed_chosen in feeds_menu_keys:
dic_current_feed = dict_feeds[feed_chosen]
sorted_keys = self.server.rank_entries_by_preference(
dic_current_feed)
for idx_key, key in enumerate(sorted_keys):
entry = dic_current_feed[key]
anchor = self.get_closest_element_anchor(
sorted_keys, idx_key, feed_chosen)
id_entry = self.generate_id_entry(feed_chosen, key)
rss_entry = represent_rss_entry(entry, id_entry)
self.wfile.write(rss_entry)
opts = self.generate_save_delete_option(
id_entry, anchor) # always show save and delete
if self.server.current_preference_folder == self.server.home:
# in this case add Like/Dislike
opts = "{1} {0}".format(
opts, self.generate_like_options(id_entry, anchor))
self.wfile.write(opts)
self.wfile.write(self.generate_entry_separator())
self.wfile.write('</body>\n</html>')
return