def create_notebook(self, title):
notebook = Types.Notebook()
notebook.name = title
notebook = self.noteStore.createNotebook(notebook)
if LOCAL_STORAGE:
self.storage.create_notebook(notebook)
print_line('成功创建笔记本: %s!' % title)
def create_notebook(self, title):
if self.get(title): return False
notebook = Types.Notebook()
notebook.name = title
notebook = self.noteStore.createNotebook(notebook)
self.storage.create_notebook(notebook)
return True
def delete_notebook(self, notebook):
if self.get(notebook) or not self.isSpecialToken: return False
if type(self.get(notebook)) != type(Types.Notebook()):
raise Exception('Types Error')
self.noteStore.expungeNotebook(self.token, self.get(notebook).guid)
self.storage.delete_notebook(notebook)
return True
def test_check_notebook(self):
with patch("pypdfocr.pypdfocr_filer_evernote.EvernoteClient"
) as mock_evernote_client:
p = P.PyFilerEvernote("TOKEN")
p._check_and_make_notebook("new_notebook")
# Let's assert that we tried to create a new notebook
mock_client = mock_evernote_client.return_value
assert (mock_client.get_note_store.called)
create_func = mock_client.get_note_store.return_value.createNotebook
update_func = mock_client.get_note_store.return_value.updateNotebook
assert (create_func.called)
assert (not update_func.called)
notebook = create_func.call_args[0][0]
assert (notebook.name == 'new_notebook')
# Now, let's setup a value for the notebooks, so we test the code for
# a "pre-exisiting" notebook
test_notebook = Types.Notebook()
test_notebook.name = "new_notebook"
mock_client.get_note_store.return_value.listNotebooks.return_value = [
test_notebook
]
p._check_and_make_notebook("new_notebook")
# Now check that the code to update a notebook stack is correct
test_notebook.stack = "new_stack"
update_func = mock_client.get_note_store.return_value.updateNotebook
p.set_target_folder("Boogie")
p._check_and_make_notebook("new_notebook")
# Check that the update call was called with correct arguments
assert (update_func.called)
notebook = update_func.call_args[0][0]
assert (notebook.stack == 'Boogie')
def _check_and_make_notebook(self, notebook_name):
"""
Weird.
:returns notebook: New or existing notebook object
:rtype Types.Notebook:
"""
# Get the noteStore
#note_store = self.client.get_note_store()
#notebooks = note_store.listNotebooks()
#notebooks = {n.name:n for n in notebooks}
notebooks = self._get_notebooks()
if notebook_name in notebooks:
notebook = notebooks[notebook_name]
if notebook.stack != self.target_folder:
notebook.stack = self.target_folder
self._update_notebook(notebook)
return notebook
else:
# Need to create a new notebook
notebook = Types.Notebook()
notebook.name = notebook_name
notebook.stack = self.target_folder
notebook = self._create_notebook(notebook)
#notebook = note_store.createNotebook(notebook)
return notebook
def delete_notebook(self, notebook):
if SPECIAL_DEV_TOKEN:
if type(self.myfile(notebook)) != type(Types.Notebook()): raise Exception('Types Error')
self.noteStore.expungeNotebook(self.token, self.myfile(notebook).guid)
# BUG
if LOCAL_STORAGE: self.storage.delete_notebook(notebook)
print_line('Deleted %s successfully'%notebook)
def createNotebook(self, name):
notebook = Types.Notebook()
notebook.name = name
logging.debug("New notebook : %s", notebook)
result = self.getNoteStore().createNotebook(self.authToken, notebook)
return result
def test_pull_new_notebook(self):
"""Test pull new notebook"""
notebook_name = 'name'
self.note_store.listNotebooks.return_value = [
ttypes.Notebook(name=notebook_name),
]
self.sync.pull()
notebook = self.session.query(models.Notebook).one()
self.assertEqual(notebook.name, notebook_name)
def create_note_from_highlight(authToken,
image_files,
note_content,
ocr=False,
notetitle=''):
from time import gmtime, strftime
if notetitle == '':
curr_time = strftime("%Y-%m-%d", gmtime())
notetitle = "digilight {curr_time}".format(curr_time=curr_time)
if ocr:
all_texts = []
for image_file in image_files:
json_data, text = google_ocr_img(image_file)
all_texts.append(text)
note_content = "\n---------------------\n".join(all_texts)
# json_data=open("jsons/api_result.json").read()
# data = json.loads(json_data)
# all_texts = get_all_text(data)
client = get_evernote_client(authToken)
userStore = client.get_user_store()
user = userStore.getUser()
noteStore = client.get_note_store()
notebooks = noteStore.listNotebooks()
found = False
for n in notebooks:
if n.name == 'Digilights':
parentNotebook = n
found = True
if not found:
ourNotebook = Types.Notebook()
ourNotebook.name = "Digilights"
parentNotebook = noteStore.createNotebook(ourNotebook)
try:
print "FILES TO RESOURCE:", str(image_files)
resources = create_en_resource(image_files)
except Exception as e:
return "ERROR: Couldnt make evernote resource." + str(e), note_content
try:
note = makeNote(authToken,
noteStore,
notetitle,
note_content,
parentNotebook=parentNotebook,
resources=resources)
except Exception as e:
return "ERROR: Couldnt make evernote." + str(e), note_content
msg = note.title + " created in " + parentNotebook.name + "!"
return msg, note_content
def updateNotebook(self, guid, name):
notebook = Types.Notebook()
notebook.name = name
notebook.guid = guid
logging.debug("Update notebook : %s", notebook)
self.getNoteStore().updateNotebook(self.authToken, notebook)
return True
def GeeknoteCreateNotebook(name):
notebook = Types.Notebook()
notebook.name = name.strip('"\'')
try:
notebook = GeeknoteCreateNewNotebook(notebook)
except:
vim.command('echoerr "Failed to create notebook."')
explorer.addNotebook(notebook)
def addNotebook(self, notebookname):
'''
adds a Notebook to the noteStore if needed(to store all Rednotebook entries)
'''
notebook = Types.Notebook()
notebook.name = notebookname
notebook = self.noteStore.createNotebook(notebook)
logger.info('added notebook:%s, with guid:%s' %
(notebookname, str(notebook.guid)))
return notebook.guid
def sync_to_evernotes(path):
"""将cmdmarkdown的文件更新到evernote中去"""
evernotebooks = {i.name: i for i in note_store.listNotebooks()}
for notebook_name in os.listdir(path):
if notebook_name in evernotebooks:
notebook = evernotebooks[notebook_name]
else:
notebook = Types.Notebook(name=notebook_name)
note_store.createNotebook(notebook)
sync_evernotes(notebook, os.path.join(path, notebook_name))
def set_notebook(note_store, my_notebook, notebook_id):
"""
create a notebook
"""
if notebook_id == 0:
new_notebook = Types.Notebook()
new_notebook.name = my_notebook
new_notebook.defaultNotebook = False
notebook_id = note_store.createNotebook(new_notebook).guid
return notebook_id
def set_current_notebook_name(name):
load_config()
if name not in [n.name for n in get_notebooks()]:
if not ask_yn("Notebook '%s' doesn't exist. Create it?" % name):
print("Aborted.")
sys.exit(1)
notebook = Types.Notebook()
notebook.name = name
notebook = get_note_store().createNotebook(notebook)
config['cur_notebook'] = name
save_config()
def create_notebook(self, space):
existing_notebooks = [
notebook for notebook in self.notebooks if space == notebook.name
]
if len(existing_notebooks):
self.set_already_createds_for_notebook(existing_notebooks[0].guid)
return existing_notebooks[0].guid, False
notebook = Types.Notebook()
notebook.name = space
notebook = self.note_store.createNotebook(notebook)
return notebook.guid, True
def set_notebook(self, trigger, notebook_id):
"""
create a notebook
"""
if notebook_id == 0:
new_notebook = Types.Notebook()
new_notebook.name = trigger.notebook
new_notebook.defaultNotebook = False
notebook_id = self.note_store.createNotebook(new_notebook).guid
return notebook_id
def create(self, notebook_name, stack=None):
if self.get(notebook_name, None):
raise NoteBookAlreadyExist("%s notebook already exist" %
(notebook_name))
else:
notebook = Types.Notebook()
notebook.name = notebook_name
if stack:
notebook.stack = stack
notebook = self._create_notebook(notebook)
return notebook
def create_note_book(client, bookname):
noteStore = client.get_note_store()
notebook = Types.Notebook()
notebook.name = bookname
notebook = noteStore.createNotebook(notebook)
print notebook.guid
if len(notebook.guid) > 0:
return True
else:
return False
def move_note(self, noteFullPath, _to):
if self.get(noteFullPath) is None: return False
if type(self.get(noteFullPath)) != type(Types.Note()) or type(self.get(_to)) != type(
Types.Notebook()): raise Exception('Type Error')
self.noteStore.copyNote(self.token, self.get(noteFullPath).guid, self.get(_to).guid)
if self.isSpecialToken:
self.noteStore.expungeNote(self.token, self.get(noteFullPath).guid)
else:
self.noteStore.deleteNote(self.token, self.get(noteFullPath).guid)
self.storage.move_note(noteFullPath, _to)
return True
def create_notebook(self, name):
"""Create a notebook.
:param name: The name of the notebook to create.
:return: The created notebook.
"""
notebook = ttypes.Notebook()
notebook.name = name
return self.note_store.createNotebook(notebook)
def createAllNotebooks(noteStore, notebooksList):
for notebook in notebooksList:
try:
newNotebook = Types.Notebook()
newNotebook.name = notebook.name
newNotebook = noteStore.createNotebook(newNotebook)
except Exception as e:
pass
else:
pass
finally:
pass
def create_notebook(self, noteFullPath):
if self.get(noteFullPath): return False
notebook = Types.Notebook()
notebook.name = noteFullPath
try:
notebook = self.noteStore.createNotebook(notebook)
except EDAMUserException, e:
if e.errorCode == 10 and e.parameter == 'Notebook.name':
self.storage.update(self.token, self.noteStore)
return True
else:
raise e
def test_pull_not_updated_notebook(self):
"""Test pull not updated notebook"""
notebook = factories.NotebookFactory.create(service_updated=2, )
notebook_name = 'name*'
self.note_store.listNotebooks.return_value = [
ttypes.Notebook(
name=notebook_name,
guid=notebook.guid,
serviceUpdated=1,
)
]
self.sync.pull()
self.assertNotEqual(notebook.name, notebook_name)
def createNotebook(self, name):
try:
noteStore = self._getNoteStoreClient()
notebook = Types.Notebook()
notebook.name = name
notebooks = noteStore.createNotebook(self.token, notebook)
except Exception as e:
LOG(explain_error(e))
LOG(e)
track = traceback.format_exc()
print(track)
return None
def create_notebook(self, notebook_name):
log.debug('Start to create notebook ' + notebook_name)
notebook = Types.Notebook()
if isinstance(notebook_name, unicode):
notebook.name = notebook_name.encode('utf-8')
else:
notebook.name = notebook_name
notebook.defaultNotebook = False
created_notebook = self.note_store.createNotebook(notebook)
log.debug('Create notebook succeed')
self.notebook_names[created_notebook.guid] = notebook_name
self.notebook_guids.append(created_notebook.guid)
self.notes[created_notebook.guid] = []
def createNotebook(self, notebookName):
notebookDict= self.getNotebook()
if notebookName in notebookDict.keys():
guid = notebookDict[notebookName]
else:
try:
notebook = Types.Notebook()
notebook.name = notebookName.encode('utf-8')
notebook = self.noteStore.createNotebook(notebook)
guid = notebook.guid
except Exception, e:
guid = None
print(e.message)
def move_note(self, note, _to):
if type(self.myfile(note)) != type(Types.Note()) or type(
self.myfile(_to)) != type(Types.Notebook()):
raise Exception('Type Error')
self.noteStore.copyNote(self.token,
self.myfile(note).guid,
self.myfile(_to).guid)
if SPECIAL_DEV_TOKEN:
self.noteStore.expungeNote(self.token, self.myfile(note).guid)
else:
self.noteStore.deleteNote(self.token, self.myfile(note).guid)
if LOCAL_STORAGE:
self.storage.move_note(note, _to)
print_line('Move %s to %s successfully' % (note, _to))
def _check_and_make_notebook(self, notebook_name, stack=None):
notebooks = self._get_notebooks()
if notebook_name in notebooks:
# Existing notebook, so just update the stack if needed
notebook = notebooks[notebook_name]
if stack:
notebook.stack = stack
self._update_notebook(notebook)
return notebook
else:
# Need to create a new notebook
notebook = Types.Notebook()
notebook.name = notebook_name
if stack:
notebook.stack = stack
notebook = self._create_notebook(notebook)
return notebook
def create_notebook(name=None):
"""Create a new notebook with given `name`.
Parameters
----------
name : str
Indicating the name of the notebook to be created
Returns
-------
evernote.edam.type.ttypes.Notebook
"""
assert name is not None, 'Notebook name is not specified.'
notebook = ttypes.Notebook()
notebook.name = name
return get_note_store().createNotebook(notebook)
