class Sidebar(Gtk.VBox): logger = lg.Logger() def __init__(self): Gtk.VBox.__init__(self, False, 0) self.set_size_request(200, 600) self.scrolled_window = Gtk.ScrolledWindow() self.set_homogeneous(True) # TreeStore self.store = Gtk.TreeStore(str, int) # Renderer self.renderer = Gtk.CellRendererText() # TreeView self.view = Gtk.TreeView(self.store) self.view.set_headers_visible(False) # F6F6F5 - grey sidebar self.view.modify_bg(Gtk.StateType.NORMAL, Gdk.Color.parse('#F6F6F5')[1]) self.view.modify_bg(Gtk.StateType.SELECTED, Gdk.Color.parse('#2980b9')[1]) self.view.modify_fg(Gtk.StateType.SELECTED, Gdk.Color.parse('#ffffff')[1]) self.view.set_activate_on_single_click(True) self.view.append_column(Gtk.TreeViewColumn("Notes", self.renderer, text=0)) self.trash_iter = None self.selection = self.view.get_selection() self.sidebar_options = {} self.menu = Gtk.Menu() item_new = Gtk.MenuItem('New') self.menu.append(item_new) self.sidebar_options['new'] = item_new item_delete = Gtk.MenuItem("Delete") self.menu.append(item_delete) self.sidebar_options['delete'] = item_delete item_restore = Gtk.MenuItem("Restore") self.menu.append(item_restore) self.sidebar_options['restore'] = item_restore self.menu.show_all() self.menu.attach_to_widget(self.view,None) # add self.scrolled_window.add(self.view) self.add(self.scrolled_window) @lg.logging_decorator(logger) def get_trash_iter(self): for item in self.store: if item[0] == 'Trash': self.trash_iter = item.iter @lg.logging_decorator(logger) def add_notebook(self, name, notebook_id): notebook_iter = self.store.append(None, [name, notebook_id]) if self.trash_iter != None: self.store.move_before(notebook_iter,self.trash_iter) return notebook_iter @lg.logging_decorator(logger) def add_item(self, title, note_id, notebook_iter=None): # Adds one item to the store # there is an option to pass notebook iter. # It is used when starting the database # checks the depth of the iter to avoid making more nested folders if notebook_iter is None: parent_iter = self.get_selected() if parent_iter is not None and self.store[parent_iter][0] != 'Trash': if self.store.iter_depth(parent_iter) != 0: parent_iter = self.store.iter_parent(parent_iter) self.store.append(parent_iter, [title, note_id]) return True else: if self.store.iter_depth(notebook_iter) == 0: self.store.append(notebook_iter, [title, note_id]) return True return False @lg.logging_decorator(logger) def modify_item(self, path, title): if self.store[path][0] != title: self.store[path][0] = title @lg.logging_decorator(logger) def remove_item(self): item = self.get_selected() if item is not None and self.store[item][0] != 'Trash': if len(self.store.get_path(item).to_string()) > 1: note_id = self.store[item][1] parent_iter = self.store.iter_parent(item) parent_id = self.get_id(parent_iter) if parent_id != self.get_id(self.trash_iter): self.add_item(self.store[item][0],note_id,self.trash_iter) else: parent_id = self.store[item][1] note_id = None children_amount = self.store.iter_n_children(item) counter = 0 current_child = self.store.iter_children(item) while counter < children_amount: title = self.store[current_child][0] idd = self.store[current_child][1] self.add_item(title,idd,self.trash_iter) counter += 1 current_child = self.store.iter_next(current_child) self.store.remove(item) return note_id, parent_id @lg.logging_decorator(logger) def get_id(self, path): # get db id from TreePath return self.store[path][1] @lg.logging_decorator(logger) def get_selected(self): # returns an iter to the selected row return self.view.get_selection().get_selected()[1] @lg.logging_decorator(logger) def get_path(self, iter_node): # returns TreePath representing the path to the selected node return self.store.get_path(iter_node) @lg.logging_decorator(logger) def get_parent(self, iter_node): # get parent of a selected note return self.store.iter_parent(iter_node) @lg.logging_decorator(logger) def get_iter_from_path(self, path): return self.store.get_iter(path)
import torch import data import model import loss import option from trainer.trainer_cdvd_tsp import Trainer_CDVD_TSP from logger import logger args = option.args torch.manual_seed(args.seed) chkp = logger.Logger(args) if args.task == 'VideoDeblur': print("Selected task: {}".format(args.task)) model = model.Model(args, chkp) loss = loss.Loss(args, chkp) if not args.test_only else None loader = data.Data(args) t = Trainer_CDVD_TSP(args, loader, model, loss, chkp) while not t.terminate(): t.train() t.test() else: raise NotImplementedError('Task [{:s}] is not found'.format(args.task)) chkp.done()
def __init__(self, header_text): # Should be an array of dicts self.tests = [] self.log = logger.Logger(timestamp=False) self.header_text = header_text
def __init__(self, logFilePath = None): self.logger = logger.Logger(logFilePath)
class Editor(Gtk.Grid): logger = lg.Logger() @lg.logging_decorator(logger) def __init__(self, parent): Gtk.Grid.__init__(self, row_spacing=5, column_spacing=2) ############################################################# # Scrolled window ############################################################# self.scrolled_window = Gtk.ScrolledWindow() self.scrolled_window.set_vexpand(True) self.scrolled_window.set_hexpand(True) self.parent = parent self.current_indent_level = 1 self.offset_after_tab_deletion = None ############################################################# # TextView ############################################################# self.textview = Gtk.TextView() self.textview.set_wrap_mode(3) self.textview.set_bottom_margin(25) self.textview.set_top_margin(25) self.textview.set_left_margin(25) self.textview.set_right_margin(25) self.textview.modify_font(Pango.FontDescription.from_string("11")) self.textbuffer = self.textview.get_buffer() self.serialized_format = self.textbuffer.register_serialize_tagset() self.deserialized_format = self.textbuffer.register_deserialize_tagset( ) ############################################################# # Scrolle Window to TextView ############################################################# self.scrolled_window.add(self.textview) ############################################################# #Tags ############################################################# self.tags = {} self.tags['bold'] = self.textbuffer.create_tag( "bold", weight=Pango.Weight.BOLD) self.tags['italic'] = self.textbuffer.create_tag( "italic", style=Pango.Style.ITALIC) self.tags['underline'] = self.textbuffer.create_tag( "underline", underline=Pango.Underline.SINGLE) self.tags['just_left'] = self.textbuffer.create_tag( "just_left", justification=Gtk.Justification(0)) self.tags['just_center'] = self.textbuffer.create_tag( "just_center", justification=Gtk.Justification(2)) self.tags['just_right'] = self.textbuffer.create_tag( "just_right", justification=Gtk.Justification(1)) self.tags['just_fill'] = self.textbuffer.create_tag( "just_fill", justification=Gtk.Justification(3)) self.tags['title'] = self.textbuffer.create_tag('title', font='20') self.tags['header'] = self.textbuffer.create_tag('header', font='15') ############################################################# # SIGNAL CONNECTIONS ############################################################# self.textbuffer.connect_after("insert-text", self.insert_with_tags) self.textbuffer.connect("delete-range", self.delete) self.textbuffer.connect_after("delete-range", self.delete_after) ############################################################# #Shortcuts ############################################################# self.parent.connect('key-press-event', self.activate_shortcuts) ############################################################# # FORMAT TOOLBAR ############################################################# self.format_toolbar = ft.FormatBar() self.format_toolbar.bold.connect("clicked", self.toggle_tag, 'bold') self.format_toolbar.italic.connect("clicked", self.toggle_tag, 'italic') self.format_toolbar.underline.connect("clicked", self.toggle_tag, 'underline') self.format_toolbar.just_right.connect('clicked', self.apply_just, 'just_right') self.format_toolbar.just_left.connect('clicked', self.apply_just, 'just_left') self.format_toolbar.just_center.connect('clicked', self.apply_just, 'just_center') self.format_toolbar.just_fill.connect('clicked', self.apply_just, 'just_fill') self.format_toolbar.title.connect('clicked', self.apply_tag, 'title') self.format_toolbar.header.connect('clicked', self.apply_tag, 'header') #self.format_toolabar.image.connect("clicked", self.add_image) self.format_toolbar.list.connect("clicked", self.add_list) self.format_toolbar.undo.connect('clicked', self.undo) self.format_toolbar.redo.connect('clicked', self.redo) self.format_toolbar.send_feedback.connect("clicked", self.send_feedback) ################################################################## #keep a dict so that we have the buttons act like Toggle buttons ################################################################## self.just_buttons = {} self.just_buttons['just_left'] = False self.just_buttons['just_center'] = False self.just_buttons['just_right'] = False self.just_buttons['just_fill'] = False ############################################################# #UNDO ############################################################# self.undo_stack = [] self.redo_stack = [] self.not_undoable_action = False self.undo_in_progress = False ############################################################# #Packing ############################################################# self.attach(self.scrolled_window, 0, 0, 2, 1) self.attach(self.format_toolbar, 0, 1, 2, 1) @lg.logging_decorator(logger) def get_text(self, start=None, end=None): if not start: start = self.textbuffer.get_start_iter() if not end: end = self.textbuffer.get_end_iter() return self.textbuffer.serialize(self.textbuffer, self.serialized_format, start, end) @lg.logging_decorator(logger) def get_clean_text(self): return self.textbuffer.get_text(self.textbuffer.get_start_iter(), self.textbuffer.get_end_iter(), False) @lg.logging_decorator(logger) def set_text(self, content): self.textbuffer.set_text("") if content != "": self.textbuffer.deserialize(self.textbuffer, self.deserialized_format, self.textbuffer.get_start_iter(), content.encode("iso-8859-1")) self.undo_stack = [] self.redo_stack = [] else: pass @lg.logging_decorator(logger) def toggle_tag(self, widget, tag): # # Toggles tag on selection, it does not do anything if there is no selection # adds the UndoableInsertTag/UndoableDeleteTag to the undo stack # limits = self.textbuffer.get_selection_bounds() if len(limits) != 0: start, end = limits if self.format_toolbar.buttons[tag].get_active(): self.textbuffer.apply_tag(self.tags[tag], start, end) ########## #undo part ########## if not self.undo_in_progress: redo_stack = [] if self.not_undoable_action: return undo_action = UndoableInsertTag(tag, start, end) self.undo_stack.append(undo_action) else: self.textbuffer.remove_tag(self.tags[tag], start, end) ########## #undo part ########## if not self.undo_in_progress: redo_stack = [] if self.not_undoable_action: return undo_action = UndoableDeleteTag(tag, start, end) self.undo_stack.append(undo_action) self.textview.grab_focus() @lg.logging_decorator(logger) def apply_tag(self, widget, tag): # # Applyes tag on selection, this is currently used # only for header and title. It also adds the UndoableInsertTag to the undo stack # limits = self.textbuffer.get_selection_bounds() if len(limits) != 0: start, end = limits if tag == 'header': self.textbuffer.remove_tag(self.tags['title'], start, end) elif tag == 'title': self.textbuffer.remove_tag(self.tags['header'], start, end) self.textbuffer.apply_tag(self.tags[tag], start, end) ########## #undo part ########## if not self.undo_in_progress: redo_stack = [] if self.not_undoable_action: return undo_action = UndoableInsertTag(tag, start, end) self.undo_stack.append(undo_action) self.textview.grab_focus() @lg.logging_decorator(logger) def apply_just(self, widget, tag): # gets an itter at the current offset and then gets the current line from it. # if there is only one char,then the start iter and the end iter are the same. # This was done in case that one char is just a new line. # then we iterate over the just buttons to disable the rest and apply just one of them current_position = self.textbuffer.get_iter_at_offset( self.textbuffer.props.cursor_position) current_line = current_position.get_line() current_line_offset = current_position.get_line_offset() start_iter = self.textbuffer.get_iter_at_line_offset(current_line, 0) if start_iter.get_chars_in_line() <= 1: end_iter = self.textbuffer.get_iter_at_line_offset(current_line, 0) else: end_iter = self.textbuffer.get_iter_at_line_offset(current_line, 1) for button in self.just_buttons: if button != tag: self.just_buttons[button] = False self.textbuffer.remove_tag(self.tags[button], start_iter, end_iter) else: self.just_buttons[tag] = True self.textbuffer.apply_tag(self.tags[tag], start_iter, end_iter) self.textview.grab_focus() @lg.logging_decorator(logger) def insert_with_tags(self, buf, start_iter, data, data_len): end = self.textbuffer.props.cursor_position #creating new start iter because the provided one #gets invalidated for some reason start_iter = self.textbuffer.get_iter_at_offset(end - 1) end_iter = self.textbuffer.get_iter_at_offset(end) # # we check if there is no undo in progress to avoid applying toggled tags # to text that is part of an undo if not self.undo_in_progress: for tag in self.format_toolbar.buttons: if self.format_toolbar.buttons[tag].get_active(): self.textbuffer.apply_tag(self.tags[tag], start_iter, end_iter) #NOTE : add just to the undo system if start_iter.get_line_offset() == 0: for item in self.just_buttons: if self.just_buttons[item] == True: self.textbuffer.apply_tag(self.tags[item], start_iter, end_iter) self.textbuffer.place_cursor(end_iter) ########## #undo part ########## def can_be_merged(prev, cur): # can be merged determines if we can add two insertions into one # if they are whitespace or differ by type, then we cannot merge them if not cur.mergeable or not prev.mergeable: return False elif cur.offset != (prev.offset + prev.len): return False elif cur.text in WHITESPACE and not prev.text in WHITESPACE: return False elif prev.text in WHITESPACE and not cur.text in WHITESPACE: return False return True if not self.undo_in_progress: self.redo_stack = [] # if it is not an undoable action then we return if self.not_undoable_action: return current_cursor_position = self.textbuffer.props.cursor_position start = self.textbuffer.get_iter_at_offset(current_cursor_position - data_len) undo_action = UndoableInsert(start, data, data_len) try: prev_insert = self.undo_stack.pop() except IndexError: self.undo_stack.append(undo_action) return if not isinstance(prev_insert, UndoableInsert): self.undo_stack.append(prev_insert) self.undo_stack.append(undo_action) return if can_be_merged(prev_insert, undo_action): prev_insert.len += undo_action.len prev_insert.text += undo_action.text self.undo_stack.append(prev_insert) else: self.undo_stack.append(prev_insert) self.undo_stack.append(undo_action) ######### #END UNDO ######### if self.format_toolbar.list.get_active() and not self.undo_in_progress: # if there is a new line and the list option is active, then we add tabs and dash # if the entered char is a tab and the text on the line is in the form '\t\t- ' # where the amount of tab depeneds on the current indent leve, then we delete the # tab from the end and add one at the begining new_iter = self.textbuffer.get_iter_at_offset( self.textbuffer.props.cursor_position) if data == '\n': for i in xrange(self.current_indent_level): self.textbuffer.insert(new_iter, '\t') self.textbuffer.insert(new_iter, '-') self.textbuffer.insert(new_iter, ' ') elif data == '\t': current_line = new_iter.get_line() start_iter = self.textbuffer.get_iter_at_line_offset( current_line, 0) end_iter = self.textbuffer.get_iter_at_line_offset( current_line, start_iter.get_chars_in_line() - 1) template = '\t' * self.current_indent_level + '- ' line_content = self.textbuffer.get_text( start_iter, end_iter, False) if line_content in (template, template + '\t'): #we need to remove the tab just inserted after the dash remove_start = self.textbuffer.get_iter_at_offset( self.textbuffer.props.cursor_position - 1) remove_end = self.textbuffer.get_iter_at_offset( self.textbuffer.props.cursor_position) self.textbuffer.delete(remove_start, remove_end) add_start_iter = self.textbuffer.get_iter_at_line_offset( current_line, 0) self.textbuffer.insert(add_start_iter, '\t') self.current_indent_level += 1 self.textview.grab_focus() @lg.logging_decorator(logger) def delete(self, buff, start, end): if buff.get_text(start,end,False) == '\t' and \ start.get_line_offset() <= self.current_indent_level and \ not self.not_undoable_action: if self.current_indent_level > 1: self.current_indent_level -= 1 self.offset_after_tab_deletion = start.get_offset() ########## #undo part ########## def can_be_merged(prev, cur): WHITESPACE = (' ', '\t') if not cur.mergeable or not prev.mergeable: return False elif prev.delete_key_used != cur.delete_key_used: return False elif prev.start != cur.start and prev.start != cur.end: return False elif cur.text not in WHITESPACE and prev.text in WHITESPACE: return False elif cur.text in WHITESPACE and prev.text not in WHITESPACE: return False return True if not self.undo_in_progress: self.redo_stack = [] if self.not_undoable_action: return undo_action = UndoableDelete(self.textbuffer, start, end) try: prev_delete = self.undo_stack.pop() except IndexError: self.undo_stack.append(undo_action) return if not isinstance(prev_delete, UndoableDelete): self.undo_stack.append(prev_delete) self.undo_stack.append(undo_action) return if can_be_merged(prev_delete, undo_action): if prev_delete.start == undo_action.start: prev_delete.text += undo_action.text prev_delete.end += (undo_action.end - undo_action.start) else: prev_delete = "{}{}".format(undo_action.text, prev_delete.text) prev_delete.start = undo_action.start self.undo_stack.append(prev_delete) else: self.undo_stack.append(prev_delete) self.undo_stack.append(undo_action) @lg.logging_decorator(logger) def delete_after(self, buff, start, end): if self.offset_after_tab_deletion: self.textbuffer.insert( buff.get_iter_at_offset(self.offset_after_tab_deletion), '-', 1) self.textbuffer.insert( buff.get_iter_at_offset(self.offset_after_tab_deletion + 1), ' ', 1) self.offset_after_tab_deletion = None @lg.logging_decorator(logger) def undo(self, widget): if not self.undo_stack: return self.not_undoable_action = True self.undo_in_progress = True undo_action = self.undo_stack.pop() self.redo_stack.append(undo_action) if isinstance(undo_action, UndoableInsert): start = self.textbuffer.get_iter_at_offset(undo_action.offset) end = self.textbuffer.get_iter_at_offset(undo_action.offset + undo_action.len) self.textbuffer.delete(start, end) self.textbuffer.place_cursor(start) elif isinstance(undo_action, UndoableInsertTag): start = self.textbuffer.get_iter_at_offset(undo_action.start) end = self.textbuffer.get_iter_at_offset(undo_action.end) self.textbuffer.remove_tag(self.tags[undo_action.tag], start, end) elif isinstance(undo_action, UndoableDeleteTag): start = self.textbuffer.get_iter_at_offset(undo_action.start) end = self.textbuffer.get_iter_at_offset(undo_action.end) self.textbuffer.apply_tag(self.tags[undo_action.tag], start, end) else: start = self.textbuffer.get_iter_at_offset(undo_action.start) self.textbuffer.insert(start, undo_action.text) end = self.textbuffer.get_iter_at_offset(undo_action.end) for tag in undo_action.tags: self.textbuffer.apply_tag(tag, start, end) if undo_action.delete_key_used: self.textbuffer.place_cursor(start) else: self.textbuffer.place_cursor(end) self.textview.grab_focus() self.not_undoable_action = False self.undo_in_progress = False @lg.logging_decorator(logger) def redo(self, widget): if not self.redo_stack: return self.not_undoable_action = True self.undo_in_progress = True redo_action = self.redo_stack.pop() self.undo_stack.append(redo_action) if isinstance(redo_action, UndoableInsert): start = self.textbuffer.get_iter_at_offset(redo_action.offset) self.textbuffer.insert(start, redo_action.text) new_cursor_pos = self.textbuffer.get_iter_at_offset( redo_action.offset + redo_action.len) for tag in redo_action.tags: start = self.textbuffer.get_iter_at_offset(redo_action.offset) end = self.textbuffer.get_iter_at_offset(redo_action.offset + redo_action.len) self.textbuffer.apply_tag(tag, start, end) self.textbuffer.place_cursor(new_cursor_pos) elif isinstance(redo_action, UndoableInsertTag): start = self.textbuffer.get_iter_at_offset(redo_action.start) end = self.textbuffer.get_iter_at_offset(redo_action.end) self.textbuffer.apply_tag(self.tags[redo_action.tag], start, end) elif isinstance(redo_action, UndoableDeleteTag): start = self.textbuffer.get_iter_at_offset(redo_action.start) end = self.textbuffer.get_iter_at_offset(redo_action.end) self.textbuffer.remove_tag(self.tags[redo_action.tag], start, end) else: start = self.textbuffer.get_iter_at_offset(redo_action.start) end = self.textbuffer.get_iter_at_offset(redo_action.end) self.textbuffer.delete(start, end) self.textbuffer.place_cursor(start) self.textview.grab_focus() self.not_undoable_action = False self.undo_in_progress = False @lg.logging_decorator(logger) def add_image(self, widget): dialog = Gtk.FileChooserDialog( "Pick a file", None, Gtk.FileChooserAction.OPEN, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.ACCEPT)) image_filter = Gtk.FileFilter() image_filter.set_name("Image files") image_filter.add_mime_type("image/*") dialog.add_filter(image_filter) response = dialog.run() if response == Gtk.ResponseType.ACCEPT: image_path = dialog.get_file().get_path() image = GdkPixbuf.Pixbuf.new_from_file(image_path) image_format, width, height = GdkPixbuf.Pixbuf.get_file_info( image_path) if width > 800: width = 800 if height > 640: height = 640 if width > 800 and height > 640: width = 800 height = 640 image = image.scale_simple(width, height, GdkPixbuf.InterpType.BILINEAR) current_position = self.textbuffer.props.cursor_position cursor_iter = self.textbuffer.get_iter_at_offset(current_position) self.textbuffer.insert_pixbuf(cursor_iter, image) dialog.destroy() @lg.logging_decorator(logger) def add_list(self, widget): if self.format_toolbar.list.get_active(): current_position = self.textbuffer.get_iter_at_offset( self.textbuffer.props.cursor_position) self.textbuffer.insert(current_position, '\n\t- ') else: self.current_indent_level = 1 @lg.logging_decorator(logger) def send_feedback(self, widget): try: result = subprocess.call( ["pantheon-mail", "mailto:[email protected]"]) except OSError: pass @lg.logging_decorator(logger) def activate_shortcuts(self, widget, event): keyval = event.keyval keyval_name = Gdk.keyval_name(keyval) state = event.state ctrl = (state & Gdk.ModifierType.CONTROL_MASK) if ctrl and keyval_name == 'b': if self.format_toolbar.bold.get_active(): self.format_toolbar.bold.set_active(False) else: self.format_toolbar.bold.set_active(True) elif ctrl and keyval_name == 'i': if self.format_toolbar.italic.get_active(): self.format_toolbar.italic.set_active(False) else: self.format_toolbar.italic.set_active(True) elif ctrl and keyval_name == 'u': if self.format_toolbar.underline.get_active(): self.format_toolbar.underline.set_active(False) else: self.format_toolbar.underline.set_active(True) elif ctrl and keyval_name == 't': self.apply_tag(None, 'title') elif ctrl and keyval_name == 'h': self.apply_tag(None, 'header') elif ctrl and keyval_name == 'l': self.apply_just(None, 'just_left') elif ctrl and keyval_name == 'r': self.apply_just(None, 'just_right') elif ctrl and keyval_name == 'e': self.apply_just(None, 'just_center') elif ctrl and keyval_name == 'j': self.apply_just(None, 'just_fill') elif ctrl and keyval_name == 'g': if self.format_toolbar.list.get_active(): self.format_toolbar.list.set_active(False) else: self.format_toolbar.list.set_active(True) elif ctrl and keyval_name == 'z': self.undo(None) elif ctrl and keyval_name == 'y': self.redo(None)
#!/usr/bin/env python # -*- coding: utf-8 -*- import logging import os from conf import config from logger import logger script_name = os.path.basename(__file__) faro_logger = logger.Logger(logger_name=script_name, file_name=config.LOG_FILE_NAME, logging_level=config.LOG_LEVEL) class SensitivityScorer(object): """ Class to obtain the score of confidentiality based on the entities extracted """ def _check_index_surpass_min_specified(self, summary_dict, current_idx): # check if two or more index surpass the min specified above_min = 0 for key in self.features: if self.features[key]['description'] in summary_dict: try: if summary_dict[self.features[key]['description']] >= self.features[key]["sensitivity"][ self.sensitivity_list[current_idx] ]["min"]: above_min += 1 except KeyError: message = "Could not find %s in scoring computation" % key faro_logger.debug(script_name, self._check_index_surpass_min_specified.__name__, message) if (above_min > self.sensitivity_multiple_kpis and current_idx < len(self.sensitivity_list) - 1):
print ''' Parser ''' print 'Usage: %s [options]' % sys.argv[0] print ''' Options: -d <site-donor> or --donor=<site-donor> - Site for parsing. Required. -t or --test Test mode. [Optional] -c or --clear-old Delete old data from database. Optional ''' print ex.message exit(1) if use_storage: mod_dbase = __import__('storage.' + storage_type + '.crud', globals(), locals(), ['Crud'], -1) dbase = mod_dbase.Crud(donor) storage = mod_storage.Storage(dbase) else: os.environ[ "SCRAPERWIKI_DATABASE_NAME"] = "sqlite:///db/" + donor + ".sqlite" mod_scraper = __import__('donors.' + donor + '.scraper', globals(), locals(), ['Scraper'], -1) logger = logger.Logger('log/' + donor + '.log') scraper = mod_scraper.Scraper(logger, storage) if test_mode: scraper.test() else: scraper.run(clear_old)
def generate_logger(data_dir): auth = authenticator.Authenticator("./twitter_credentials.json") api = auth.authenticate() io = fileio.CSVHandler(data_dir) return logger.Logger(api, io)
def __init__(self): self._logger = logger.Logger() self._result_queue = []
class MainWindow(Gtk.Window): logger = lg.Logger() def __init__(self): Gtk.Window.__init__(self, title="Noted") self.set_border_width(5) self.set_size_request(1100, 900) self.set_resizable(False) # Header Bar hbar = hb.Headerbar() hbar.connect("destroy", self.close_database) self.set_titlebar(hbar) # Notebook button hbar.notebook_button.connect("clicked", self.create_notebook) # Create Button hbar.create_button.connect("clicked", self.create_note) # Save button hbar.save_button.connect("clicked", self.save_note) # Delete Button hbar.delete_button.connect("clicked", self.delete_note) #shortcuts self.connect("key-press-event", self.on_key_press) # MAIN WINDOW main_window = Gtk.Grid(column_homogeneous=False, column_spacing=5) # SIDEBAR self.sidebar = sb.Sidebar() self.sidebar.view.connect("row_activated", self.show_note) self.sidebar.view.connect('button-release-event', self.show_sidebar_options) self.sidebar.sidebar_options['new'].connect('activate', self.create_note) self.sidebar.sidebar_options['delete'].connect('activate', self.delete_note) self.sidebar.sidebar_options['restore'].connect( 'activate', self.restore_note) # EDITOR self.editor = editor.Editor(self) # loads the storage file and creates the dict db self.start_database() main_window.attach(self.sidebar, 0, 0, 1, 2) main_window.attach(self.editor, 1, 0, 2, 1) self.add(main_window) @lg.logging_decorator(logger) def show_sidebar_options(self, widget, event): if event.button == 3: try: selected_iter = self.sidebar.get_selected() selected = self.sidebar.store[selected_iter][0] parent_iter = self.sidebar.get_parent(selected_iter) if parent_iter != None: parent = self.sidebar.store[parent_iter][0] else: parent = None if parent == 'Trash' or selected == 'Trash': self.sidebar.sidebar_options['new'].set_sensitive(False) self.sidebar.sidebar_options['delete'].set_sensitive(True) self.sidebar.sidebar_options['restore'].set_sensitive(True) else: self.sidebar.sidebar_options['restore'].set_sensitive( False) self.sidebar.sidebar_options['new'].set_sensitive(True) self.sidebar.sidebar_options['delete'].set_sensitive(True) self.sidebar.menu.popup(None, None, None, None, event.button, event.time) except TypeError: #there was no selection when the click occured pass @lg.logging_decorator(logger) def create_notebook(self, widget): # creates a new notebook dialog = nd.NameDialog(self) response = dialog.run() if response == Gtk.ResponseType.OK: name = dialog.entry.get_text() if name != '' and name != 'Trash': self.sidebar.add_notebook(name, self.notebook_id) self.database.create_notebook(name, self.notebook_id) self.notebook_id += 1 dialog.destroy() @lg.logging_decorator(logger) def create_note(self, widget): if self.sidebar.add_item("New Note", self.id): self.editor.set_text("") parent_id = self.sidebar.get_id(self.sidebar.get_selected()) self.database.create_note("New Note", '', self.id, parent_id) self.id += 1 @lg.logging_decorator(logger) def delete_note(self, widget): dialog = dd.DeleteDialog(self) response = dialog.run() if response == Gtk.ResponseType.OK: result = self.sidebar.remove_item() self.editor.set_text("") if result is not None: note_id, parent_id = result if note_id is not None: self.database.delete_note(note_id) else: self.database.delete_notebook(parent_id) dialog.destroy() @lg.logging_decorator(logger) def restore_note(self, widget): selected = self.sidebar.get_selected() if self.sidebar.store[selected][0] != 'Trash': idd = self.sidebar.get_id(self.sidebar.get_selected()) note = self.database.get_note(idd) notebook_id, notebook_name, result = self.database.restore_note( idd) self.sidebar.remove_item() if result: parent_iter = self.sidebar.add_notebook( notebook_name, notebook_id) self.sidebar.add_item(note.name, idd, parent_iter) self.editor.set_text("") else: #means we have to add to an existing notebook #this part should be moved to the sidebar module given that is processing done by it children = self.sidebar.store.iter_n_children(None) current = 0 current_child = self.sidebar.store.iter_children(None) while current < children: item = self.sidebar.store[current_child] if item[0] == notebook_name and item[1] == notebook_id: self.sidebar.add_item(note.name, idd, item.iter) current_child = self.sidebar.store.iter_next(item.iter) current += 1 self.editor.set_text("") @lg.logging_decorator(logger) def show_note(self, treeview, path, col): if len(path) > 1: parent_iter = self.sidebar.get_parent( treeview.get_selection().get_selected()[1]) parent_id = self.sidebar.get_id(parent_iter) note_id = self.sidebar.get_id(path) content = self.database.get_note(note_id).content self.editor.set_text(content) else: self.editor.set_text("") if treeview.row_expanded(path) is False: treeview.expand_row(path, True) else: treeview.collapse_row(path) @lg.logging_decorator(logger) def save_note(self, event): path = self.sidebar.get_selected() # check if something was selected and that it was not a notebook if path is not None and len( self.sidebar.get_path(path).to_string()) > 1: parent = self.sidebar.get_parent(path) if self.sidebar.store[parent][0] != 'Trash': clean_text = self.editor.get_clean_text() if clean_text != "": title = self.get_title(clean_text) else: title = "New Note" content = self.editor.get_text() parent_iter = self.sidebar.get_parent(path) parent_id = self.sidebar.get_id(parent_iter) note_id = self.sidebar.get_id(path) self.database.modify_note(title, content, note_id) self.sidebar.modify_item(path, title) @lg.logging_decorator(logger) def start_database(self): path = "{}/Noted".format(GLib.get_user_data_dir()) if not os.path.exists(path): subprocess.call(['mkdir', path]) db = shelve.open("{}/database.db".format(path)) self.database = Database() self.database.start_database() add_trash = True if not db: self.id = 1 self.notebook_id = 1 else: self.id = db['note_id'] self.notebook_id = db['notebook_id'] notebooks = self.database.get_notebooks() #we do two iterations of the notebooks to get the trash first and then the rest. # is there a better way ? for notebook in notebooks: if notebook.name == 'Trash': add_trash = False notebook_iter = self.sidebar.add_notebook( 'Trash', notebook.idd) notes = self.database.get_notes_from_notebook(notebook.idd) for note in notes: self.sidebar.add_item(note.name, note.idd, notebook_iter) if add_trash: self.database.create_notebook('Trash', self.notebook_id) notebook_iter = self.sidebar.add_notebook('Trash', self.notebook_id) self.notebook_id += 1 self.sidebar.get_trash_iter() for notebook in notebooks: if notebook.name != 'Trash': notebook_iter = self.sidebar.add_notebook( notebook.name, notebook.idd) notes = self.database.get_notes_from_notebook(notebook.idd) for note in notes: self.sidebar.add_item(note.name, note.idd, notebook_iter) db.close() @lg.logging_decorator(logger) def close_database(self, event): path = GLib.get_user_data_dir() db = shelve.open("{}/Noted/database.db".format(path)) db['note_id'] = self.id db['notebook_id'] = self.notebook_id db.close() self.database.close_database() self.hide() Gtk.main_quit() @lg.logging_decorator(logger) def get_title(self, content): content = content.lstrip() title_index = content.find("\n") if title_index < 20 and title_index != -1: title = content[:title_index] elif len(content) > 20: title = content[:20] else: title = content return title @lg.logging_decorator(logger) def on_button_clicked(self, widget, tag): self.editor.toggle_tag(tag, None) @lg.logging_decorator(logger) def on_key_press(self, widget, event): keyval = event.keyval keyval_name = Gdk.keyval_name(keyval) state = event.state ctrl = (state & Gdk.ModifierType.CONTROL_MASK) if ctrl and keyval_name == 's': self.save_note(None) elif ctrl and keyval_name == 'n': self.create_note(None) elif ctrl and keyval_name == 'k': self.create_notebook(None) elif ctrl and keyval_name == 'q': self.close_database(None)
class Database(object): logger = lg.Logger() @lg.logging_decorator(logger) def start_database(self): path = GLib.get_user_data_dir() db_path = "{}/Noted/sqlitedatabase.db".format(path) if not os.path.exists(db_path): self.engine = create_engine('sqlite:///{}'.format(db_path), echo=False) Base.metadata.create_all(self.engine) else: self.engine = create_engine('sqlite:///{}'.format(db_path), echo=False) Base.metadata.bind = self.engine DBSession = sessionmaker(bind=self.engine) self.session = DBSession() @lg.logging_decorator(logger) def close_database(self): self.session.close() @lg.logging_decorator(logger) def create_note(self, name, content, idd, notebook_id): try: note = Note(name=unicode(name, 'iso-8859-1'), content=unicode(content, 'iso-8859-1'), idd=idd, notebook_id=notebook_id) except TypeError: note = Note(name=name, content=content, idd=idd, notebook_id=notebook_id) self.session.add(note) self.session.commit() @lg.logging_decorator(logger) def create_notebook(self, name, idd): notebook = Notebook(name=name, idd=idd) self.session.add(notebook) self.session.commit() @lg.logging_decorator(logger) def delete_notebook(self, idd): notes = self.session.query(Note).filter_by(notebook_id=idd).all() notebook = self.session.query(Notebook).filter_by(idd=idd).one() if notebook.name == 'Trash': for note in notes: self.session.delete(note) else: trash_notebook = self.session.query(Notebook).filter_by( name='Trash').one() for note in notes: note.notebook_id = trash_notebook.idd note.deleted_notebook_name = notebook.name note.deleted_notebook_id = notebook.idd self.session.commit() self.session.delete(notebook) self.session.commit() @lg.logging_decorator(logger) def delete_note(self, idd): note = self.session.query(Note).filter_by(idd=idd).one() notebook = self.session.query(Notebook).filter_by( idd=note.notebook_id).one() trash_notebook = self.session.query(Notebook).filter_by( name='Trash').one() if notebook.name == 'Trash': self.session.delete(note) else: note.notebook_id = trash_notebook.idd note.deleted_notebook_name = notebook.name note.deleted_notebook_id = notebook.idd self.session.commit() @lg.logging_decorator(logger) def restore_note(self, idd): note = self.session.query(Note).filter_by(idd=idd).one() notebook_name = note.deleted_notebook_name notebook = self.session.query(Notebook).filter_by( name=note.deleted_notebook_name, idd=note.deleted_notebook_id).first() if notebook: note.deleted_notebook_name = None note.deleted_notebook_id = None note.notebook_id = notebook.idd result = False else: self.create_notebook(note.deleted_notebook_name, note.deleted_notebook_id) note.notebook_id = note.deleted_notebook_id note.deleted_notebook_name = None note.deleted_notebook_id = None result = True self.session.commit() return note.notebook_id, notebook_name, result @lg.logging_decorator(logger) def modify_note(self, name, content, idd): note = self.session.query(Note).filter_by(idd=idd).one() note.name = unicode(name, 'iso-8859-1') note.content = unicode(content, 'iso-8859-1') self.session.commit() @lg.logging_decorator(logger) def get_notebooks(self): notebooks = self.session.query(Notebook).all() return notebooks @lg.logging_decorator(logger) def get_notes_from_notebook(self, notebook_id): notes = self.session.query(Note).filter_by( notebook_id=notebook_id).all() return notes @lg.logging_decorator(logger) def get_note(self, idd): result = self.session.query(Note).filter_by(idd=idd).one() return result