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
