def __init__(self, note_class): self.model_class = note_class self.interface = note_class.interface self.note_store = self.interface.get_note_store() self.note_filter = NoteStore.NoteFilter() self.guids = set() self.spec = NoteStore.NotesMetadataResultSpec() # These are the spec instance properties you can set: # includeUpdateSequenceNum # includeDeleted # includeContentLength # includeTitle # includeNotebookGuid # includeTagGuids # includeLargestResourceSize # includeAttributes # includeLargestResourceMime # includeCreated # includeUpdated self.spec.includeTitle = True self.spec.includeCreated = True self.spec.includeUpdated = True self.spec.includeNotebookGuid = True self.spec.includeTagGuids = True self.bounds = {"limit": 50, "offset": 0}
def pull(args): dest_dir = get_abs_dir(args.directory) skip_cover = args.yes finished = 0 for f in args.files: try: flag = os.path.basename(f) file = load_file(flag) if not file: box = get_box(args.box) file_filter = NoteTypes.NoteFilter() if box: file_filter.notebookGuid = box.guid file_filter.title = flag files = get_box_store().findNotes(dev_token, file_filter, 0, 100).notes file = load_file(files[-1].guid) if not file: raise ouput_file = os.path.join(dest_dir, file['title']) if os.path.exists(ouput_file): if not skip_cover: if not get_yn_input('文件 %s 已存在,是否覆盖' % ouput_file): continue with open(ouput_file, 'w') as fp: fp.write(file['content']) finished += 1 sys.stdout.write('已拉取:%s个文件\r' % finished) sys.stdout.flush() except Exception, e: print('文件:%s拉取失败,跳过..' % f)
def get_filtered_notes(filter): results = list() nFilter = NoteStoreTypes.NoteFilter() # reminderOrder, reminderTime, reminderDoneTime nFilter.words = filter rSpec = NoteStoreTypes.NotesMetadataResultSpec() rSpec.includeTitle = True rSpec.includeAttributes = True rSpec.includeTagGuids = True notesMetadataList = noteStore.findNotesMetadata(nFilter, 0, 50, rSpec) for note in notesMetadataList.notes: tags = list() try: for tagguid in note.tagGuids: tag = noteStore.getTag(tagguid) tags.append(tag.name) except: pass results.append({ 'title': note.title, 'guid': note.guid, 'donetime': note.attributes.reminderDoneTime, 'duetime': note.attributes.reminderTime, 'reminder': note.attributes.reminderOrder, 'tags': tags }) return results
def find_notes_metadata(self, notebook=None): note_filter = NoteStoreTypes.NoteFilter(order=CommonTypes.NoteSortOrder.TITLE, ascending=False) if notebook is not None: note_filter.notebookGuid = notebook.guid spec = NoteStoreTypes.NotesMetadataResultSpec(includeTitle=True) return self.note_store.findNotesMetadata(self.token, note_filter, 0, LimitConstants.EDAM_USER_NOTES_MAX, spec)
def getNoteGuidByTagGuid(self, title, tagguid): f = Ttypes.NoteFilter() f.tagGuids = [tagguid] notes = self.note_store.findNotes(self.auth_token, f, 0, 999).notes for note in notes: if note.title == title: return note.guid
def find_note_counts(self, word): note_filter = NoteStoreTypes.NoteFilter() note_filter.words = word note_filter.ascending = False ret = self.note_store.findNoteCounts(self.token, note_filter, False) return ret
def listnotes(): client = EvernoteClient(token=settings.TOKEN) notestore = client.get_note_store() note_filter = ttypes.NoteFilter() # TODO: read notebookGuid from options note_filter.notebookGuid = '6ccaa7d7-cbdb-4190-8c28-121e603f0b8c' note_result_spc = ttypes.NotesMetadataResultSpec( True, True, True, True, True, ) notecount = notestore.findNoteCounts(note_filter, True) print '===========' print notecount.notebookCounts print notecount.tagCounts print notecount.trashCount total_count = sum(notecount.notebookCounts.values(), 0) print total_count note_list = notestore.findNotesMetadata( note_filter, 0, total_count, )
def find_note_ids(self, place, category='', conditions=[]): ''' :return List of guids of matching notes ''' # Create a search filter for notes with same place, conditions, and category note_filter = NoteStore.NoteFilter() if type(place) in [unicode, str] and type(category) in [unicode, str] and type(conditions) == list: placename = 'placeName:"{}"'.format(place) title = 'inTitle:{}'.format(category) tags = '' if len(conditions) > 0: tags = ' tag:"{}"'.format(conditions[0]) if len(conditions) > 1: for condition in conditions[1:]: tags += ' tag:"{}"'.format(condition) else: # No conditions specified pass else: raise TypeError, "place and category must be string, and conditions must be list of strings" note_filter.words = placename + ' ' + title + tags resultspec = NoteStore.NotesMetadataResultSpec() resultspec.includeTitle = True resultspec.includeContent = True notes_metadata_list = self.noteStore.findNotesMetadata(self.authToken, note_filter, 0, EDAM_USER_NOTES_MAX, resultspec) matching_note_guids = [note.guid for note in notes_metadata_list.notes] return matching_note_guids
def storeMetadata(note_store): ''' Store tagged metadata in data file ''' filter = NSTypes.NoteFilter() resultSpec = NSTypes.NotesMetadataResultSpec() for notebook in note_data['notebooks']: filter.notebookGuid = notebook['guid'] filter.tagGuids = makeValueList(note_data, 'tags', 'guid') resultSpec.includeTitle = True resultSpec.includeUpdateSequenceNum = True resultSpec.includeNotebookGuid = True try: metalist = note_store.findNotesMetadata(filter, 0, 250, resultSpec) meta_notes = metalist.notes if not meta_notes: raise Exception('Found no tagged note') except EDAMNotFoundException as e: raise Exception('Found wrong {}'.format(e.identifier)) except Exception as e: raise Exception(e) # guids = makeValueList(note_data, 'notes', 'guid') meta_notes_create = [] # Update for mn in meta_notes: if mn.guid in guids: updateNoteData(mn) else: meta_notes_create.append(mn) # Create for mn in meta_notes_create: createNoteData(mn)
def in_notebooks(title, notebook_id): filter = NoteTypes.NoteFilter() filter.notebookGuid = notebook_id filter.name = "intitle:%s" % title results = get_note_store().findNotes(dev_token, filter, 0, 100).notes for note in results: if note.title == title: return note.guid return None
def _get_note_metadata(self): notefilter = NotesStore.NoteFilter() notefilter.notebookGuid = self.notebook.guid resultspec = NotesStore.NotesMetadataResultSpec() resultspec.includeTitle = True resultspec.includeCreated = True resultspec.includeUpdated = True notelist = self.noteStore.findNotesMetadata(notefilter, 0, 10, resultspec) return notelist.notes
def getNotes(self, words): note_filter = NoteStore.NoteFilter() note_filter.words = words notes_metadata_result_spec = NoteStore.NotesMetadataResultSpec() notes = self.noteStore.findNotesMetadata( note_filter, 0, 1, notes_metadata_result_spec ) return notes
def list_notes(notebook_guid, user_store, note_store): note_filter = NoteTypes.NoteFilter() note_filter.notebookGuid = notebook_guid notes = note_store.findNotes(settings.EVERNOTE_DEVELOPER_TOKEN, note_filter, 0, 100).notes notes_lst = [] for note in notes: this_note = {'NoteTitle': note.title, 'NoteId': note.guid} notes_lst.append(this_note) return notes_lst
def list_box(box): file_filter = NoteTypes.NoteFilter() file_filter.notebookGuid = box.guid files = get_box_store().findNotes(dev_token, file_filter, 0, 100).notes if not files: print '仓库没有任何文本' else: print('| 文本id | 文本名称 | 创建时间') for f in reversed(files): print "%s %s %s" % (f.guid, f.title, datetime_format( f.created))
def retrieve_titles(self): note_filter = NoteStore.NoteFilter() note_filter.words = 'intitle:*' resultspec = NoteStore.NotesMetadataResultSpec() resultspec.includeTitle = "True" results = self.noteStore.findNotesMetadata(self.authToken, note_filter, 0, EDAM_USER_NOTES_MAX, resultspec) titles = [] for note in results.notes: titles.append(note.title) print note.title unique_places = list(set(titles)) return unique_places
def GetAllNotesWithFilter(EvernoteObject, filterText): nFilter = NoteStoreTypes.NoteFilter() nFilter.words = filterText # "reminderOrder:*" # filter.notebookGuid = "SomeNotebookGuidHere" # filter.tagGuids = ["tagGuid1", "tagGuid2"] rSpec = NoteStoreTypes.NotesMetadataResultSpec() rSpec.includeTitle = True rSpec.includeAttributes = True rSpec.includeNotebookGuid = True notesMetadataList = EN.notestore.findNotesMetadata(nFilter, 0, 50, rSpec) return notesMetadataList.notes
def listUpdateStateOfNotes(notebook_guid): notebook_filter = StoreTypes.NoteFilter(notebookGuid=notebook_guid) spec = StoreTypes.NotesMetadataResultSpec( includeContentLength=True, includeUpdated=True, includeDeleted=True, includeUpdateSequenceNum=True, includeNotebookGuid=True) temp_list = note_store.findNotesMetadata(notebook_filter,0, constants.EDAM_USER_NOTES_MAX, spec) note_list = temp_list.notes while len(note_list) < temp_list.totalNotes: temp_list = note_store.findNotesMetadata(notebook_filter, len(note_list), constants.EDAM_USER_NOTES_MAX, spec) note_list.append(temp_list.notes) return note_list
def retrieve_placenames(self): if offline.real_mode is False: return offline.places else: note_filter = NoteStore.NoteFilter() note_filter.words = 'placename:*' resultspec = NoteStore.NotesMetadataResultSpec() resultspec.includeAttributes = "True" results = self.noteStore.findNotesMetadata(self.authToken, note_filter, 0, EDAM_USER_NOTES_MAX, resultspec) placenames = [] for note in results.notes: placenames.append(note.attributes.placeName) unique_places = list(set(placenames)) return unique_places
def change_tag_evernote(args, evernote_cred): client = EvernoteClient(token=evernote_cred["developer_token"], sandbox=evernote_cred["is_sandbox"]) note_store = client.get_note_store() notebook_name = evernote_cred["notebook_name"] notebooks = note_store.listNotebooks() target_notebook = None for notebook in notebooks: if notebook_name == notebook.name: target_notebook = notebook break note_filter = NSTypes.NoteFilter() note_filter.notebookGuid = target_notebook.guid notes_per_page = 50 note_list = note_store.findNotes(note_filter, 0, 1) note_num = note_list.totalNotes max_page_num = math.ceil(note_num / notes_per_page) note_num_digits = len(str(note_num)) message_current_max = "({{:0{digits}d}}/{{:0{digits}d}})".format( digits=note_num_digits) for page_num in range(0, max_page_num): note_list = note_store.findNotes(note_filter, notes_per_page * page_num, notes_per_page * (page_num + 1)) for i, note in enumerate(note_list.notes): logger.info((message_current_max + ": {}").format( notes_per_page * page_num + i + 1, note_num, note.title)) current_tag_names = note_store.getNoteTagNames(note.guid) new_tag_names = set() for current_tag_name in current_tag_names: try: program_date = dateutil.parser.parse(current_tag_name) new_tag_names.add("{:%Y}".format(program_date)) new_tag_names.add("{:%Y.%m}".format(program_date)) except: new_tag_names.add(current_tag_name) logger.info("change tags: {}->{}".format(current_tag_names, new_tag_names)) note.tagGuids.clear() note.content = None note.resources = None note.tagNames = new_tag_names note_store.updateNote(note)
def remove_items(self, items, note_guid=None): note_filter = NoteStore.NoteFilter() resultspec = NoteStore.NotesMetadataResultSpec() results = self.noteStore.findNotesMetadata(self.authToken, note_filter, 0, EDAM_USER_NOTES_MAX, resultspec) # find all notes with item, and remove the item if note_guid: sleep(0.5) note = self.noteStore.getNote(self.authToken, note_guid, True, False, False, False) updated_note = ttypes.Note() updated_content = note.content for item in items: updated_content = re.sub(enml_regex['todo_tag'] + re.escape(item), '', updated_content) updated_note.content = updated_content updated_note.title = note.title updated_note.guid = note.guid self.update_note(updated_note)
def log(args): file = args.file abs_path = os.path.abspath(os.path.normpath(file)) if not os.path.exists(abs_path): print('文件不存在!') return file_name = os.path.basename(abs_path) file_filter = NoteTypes.NoteFilter() file_filter.title = file_name files = get_box_store().findNotes(dev_token, file_filter, 0, 100).notes if not files: print('仓库中不存在该文件的记录') return print('| 文本id | 文本名称 | 仓库\t | 创建时间') for f in files: print '%s %s %s %s' % (f.guid, f.title, get_box_by_id( f.notebookGuid).name, datetime_format(f.created))
def fetchNotesMetadata(self): logging.info("Getting metadata from notebook: %s", self.notebook_name) flt = ns_ttypes.NoteFilter() flt.notebookGuid = self.ev_notebook.guid rs = ns_ttypes.NotesMetadataResultSpec() rs.includeTitle = True rs.includeTagGuids = True nml = self.ev_note_store.findNotesMetadata(self.token, flt, 0, 10000, rs) for n in nml.notes: #n is "NoteMetadata" type self.ev_notes_metadata.append([n.guid, n.title]) if n.tagGuids: for t in n.tagGuids: self.ev_tags[t] = None else: logging.info("No Tag found for: %s ", n.title) return
def cmd_notes(args, offset=0, count=10): """notes [+notebook] [[:tag1 [:tag2] ...] [--offset=X] [--count=Y] - list notes in the specified notebook, or the current one if not specified. """ tags = [] for arg in args: if arg.startswith('+'): set_current_notebook_name(arg[1:]) if arg.startswith(':'): tags.append(arg[1:]) nb_guid = get_current_notebook().guid nf = NoteTypes.NoteFilter(notebookGuid=nb_guid) nb_tags = get_note_store().listTagsByNotebook(nb_guid) or [] if tags: nf.tagGuids = [t.guid for t in nb_tags if t.name in tags] resultspec = NoteTypes.NotesMetadataResultSpec() for field in ['includeTitle', 'includeUpdated', 'includeTagGuids']: setattr(resultspec, field, True) notesml = get_note_store().findNotesMetadata(nf, int(offset), int(count), resultspec) debug(lambda: "Notes in notebook '%s': " % get_current_notebook_name()) for note in notesml.notes: notetags = note.tagGuids or [] tagdisplay = ["[%s]" % t.name for t in nb_tags if t.guid in notetags] updatedisplay = time.strftime("%m/%d", time.localtime(note.updated / 1000)) print(" %s %s %s %s" % (note.guid, updatedisplay, tagdisplay, note.title)) remaining = notesml.totalNotes - notesml.startIndex - len(notesml.notes) if remaining > 0: print("...and %d more." % remaining)
def list_notes_in_notebooks(notebook_id): filter = NoteTypes.NoteFilter() filter.notebookGuid = notebook_id notes = get_note_store().findNotes(dev_token, filter, 0, 100).notes return notes
def createOrUpdateNotebooksWeeks(EvernoteObject, startdate, enddate, stackName, dateOverdue=None): weeks = GetFirstDaysOfWeeksBetween(startdate, enddate) notebooks = EvernoteObject.notestore.listNotebooks() # search notebooks in stack nbooksWv = [n for n in notebooks if n.stack == stackName] # iterate all weeks for weekday in weeks: weeknumber = weekday.isocalendar()[1] weekString = GetWeekString(weekday) # notebook exists in this week? existingNotebookInThisWeek = GetNotebookSameWeekIfExists( weekday, nbooksWv) if existingNotebookInThisWeek == None: # create new notebook notebook = EnTypes.Notebook() notebook.name = weekString notebook.stack = stackName notebook = EvernoteObject.notestore.createNotebook(notebook) msg = "created new notebook '" + notebook.name + "'" else: if dateOverdue <> None and weekday.date() < dateOverdue.date(): # Notebook is obsolete noteFilter = NoteStoreTypes.NoteFilter( notebookGuid=existingNotebookInThisWeek.guid) spec = NoteStoreTypes.NotesMetadataResultSpec() notelist = EvernoteObject.notestore.findNotesMetadata( noteFilter, 0, 10, spec) #if notelist.totalNotes > 0: # it contains notes oldName = existingNotebookInThisWeek.name existingNotebookInThisWeek.name = weekString + ": overdue!" notebook = EvernoteObject.notestore.updateNotebook( existingNotebookInThisWeek) msg = "overdue notebook '{o}' contains {cnt:d} Notes, rename to '{new}'".format( o=oldName, cnt=notelist.totalNotes, new=existingNotebookInThisWeek.name) # else: # # it contains no notes: delete notebook # EvernoteObject.notestore.deleteNotebook(existingNotebookInThisWeek) else: # Notebook belongs to current or future week if weekString == existingNotebookInThisWeek.name: # new name the same as old, so don't update anything msg = "existing notebook '" + existingNotebookInThisWeek.name + "' name is correct, no update required" else: # Update existing notebook oldName = existingNotebookInThisWeek.name existingNotebookInThisWeek.name = weekString notebook = EvernoteObject.notestore.updateNotebook( existingNotebookInThisWeek) msg = "updated existing notebook '" + oldName + "' to '" + existingNotebookInThisWeek.name + "'" print " {msg}".format(msg=msg)
def list_notes(client, notebook): filter = NoteStoreTypes.NoteFilter() filter.notebookGuid = notebook.guid noteStore = client.get_note_store() noteList = noteStore.findNotes(filter, 0, 1000) return noteList.notes
def sync_fotopedia_id(item_id): #get html story page raw_story = requests.get("http://www.fotopedia.com/reporter/stories/" + item_id) #pass html story to beautiful soup for html processing bs_story = bs(raw_story.content) #grab all titles and captions editable_spans = bs_story.findAll("span", {'class': "editable-value"}) titles_and_captions = [] for text in editable_spans: titles_and_captions.append(text.text) #grab all pic urls from page re_pattern = "\'background: url\(\"(.*)\"\)" pic_html = bs_story.findAll("div", {"class": "full-image"}) pic_urls = [] for pic in pic_html: pic_urls.append(re.findall(re_pattern, pic.renderContents())[0]) #prep evernote user_store = get_userstore() note_store = get_notestore() notebooks = note_store.listNotebooks(session['identifier']) #check if Fotopedia notebook exists for notebook in notebooks: if notebook.name == "Fotopedia": fotopediaNotebookGuid = notebook.guid break #if not create it try: fotopediaNotebookGuid except NameError: notebook = Types.Notebook() notebook.name = "Fotopedia" notebook = note_store.createNotebook(session['identifier'], notebook) fotopediaNotebookGuid = notebook.guid #add all pictures as notes with title of story: title of pic with captions as body text #iterate through all pics and titles for iter in range(len(pic_urls)): if titles_and_captions[0] and titles_and_captions[2 * iter]: note_title = titles_and_captions[0] + " - " + titles_and_captions[ 2 * iter] else: note_title = titles_and_captions[2 * iter] note_description = titles_and_captions[2 * iter - 1] pic_url = pic_urls[iter] #check to see if note exists already notebook_filter = NoteStoreTypes.NoteFilter() notebook_filter.guid = fotopediaNotebookGuid result_spec = NotesMetadataResultSpec(includeTitle=True) noteList = note_store.findNotesMetadata(session['identifier'], notebook_filter, 0, 40000, result_spec) for note in noteList.notes: if note.title == note_title: continue #get image if pic_url == '': continue image = requests.get(pic_url, stream=True).content md5 = hashlib.md5() md5.update(image) pic_hash = md5.digest() data = Types.Data() data.size = len(image) data.bodyHash = pic_hash data.body = image resource = Types.Resource() resource.mime = 'image/jpeg' resource.data = data hash_hex = binascii.hexlify(pic_hash) note = Types.Note() note.notebookGuid = fotopediaNotebookGuid #create note for our Giphy notebook note.title = note_title note.content = '<?xml version="1.0" encoding="UTF-8"?>' note.content += '<!DOCTYPE en-note SYSTEM ' \ '"http://xml.evernote.com/pub/enml2.dtd">' note.content += '<en-note>' + note_description + '<br/><br/>' note.content += '<en-media type="image/png" hash="' + hash_hex + '"/>' note.content += '</en-note>' note.resources = [ resource ] # Now, add the new Resource to the note's list of resources note = note_store.createNote(session['identifier'], note) # create the note return True
noteStoreHttpClient = THttpClient.THttpClient(noteStoreUri) noteStoreProtocol = TBinaryProtocol.TBinaryProtocol(noteStoreHttpClient) noteStore = NoteStore.Client(noteStoreProtocol) notebooks = noteStore.listNotebooks(authToken) print "Found ", len(notebooks), " notebooks:" ofile = codecs.open('ttest.html', 'w', 'utf-8') for notebook in notebooks: print " * ", notebook.name if notebook.defaultNotebook: defaultNotebook = notebook # else : # continue filter = NoteStoreTypes.NoteFilter() filter.notebookGuid = notebook.guid filter.order = 1 filter.words = "todo:*" filter.ascending = False filter.timeZone = "Asia/Shanghai" noteList = noteStore.findNotes(authToken, filter, 0, 100) print "total notes number :" + str(noteList.totalNotes) print "startIndex" + str(noteList.startIndex) print len(noteList.notes) for note in noteList.notes: #print note.guid #print note.title print chardet.detect(note.title) ofile.write(note.title + '\n') noteContent = noteStore.getNoteContent(authToken, note.guid)
def store_evernote(recipes, args, site_config, evernote_cred, is_note_exist_check=True): client = EvernoteClient(token=evernote_cred["developer_token"], sandbox=evernote_cred["is_sandbox"]) note_store = None try: note_store = client.get_note_store() except: logger.error(sys.exc_info()[0]) if note_store is None: logger.error("note store in Evernote is None") return notebook_name = evernote_cred["notebook_name"] notebooks = note_store.listNotebooks() target_notebook = None for notebook in notebooks: if notebook_name == notebook.name: target_notebook = notebook break if target_notebook is None: logger.info("create notebook: {}".format(notebook_name)) target_notebook = Types.Notebook() target_notebook.name = notebook_name target_notebook = note_store.createNotebook(target_notebook) # for processed_list_filename, recipe in recipes(args, site_config): for recipe in recipes(): trans = recipe_crawler.translators.EvernoteTranslator( recipe, site_config) note_title = trans.title is_note_exist = False if is_note_exist_check: note_filter = NSTypes.NoteFilter() note_filter.notebookGuid = target_notebook.guid note_filter.words = note_title resultSpec = NSTypes.NotesMetadataResultSpec() resultSpec.includeTitle = True metalist = note_store.findNotesMetadata(note_filter, 0, 10, resultSpec) for meta_ in metalist.notes: if note_title == meta_.title: logger.debug("skip: {} exists.".format(note_title)) is_note_exist = True break if not is_note_exist: logger.info("create note: {}".format(note_title)) resources, body = trans.body_resources attributes = trans.attributes note = Types.Note(title=note_title, content=body, resources=resources.values(), attributes=attributes, notebookGuid=target_notebook.guid) note.tagNames = trans.tag_names note_store.createNote(note) time.sleep(1) yield recipe
def proc_insert(args): messages = dict() # key: date, value: list() Message store_filename = args.work_dir / args.store_file if store_filename.exists(): with store_filename.open("r") as fp: messages = yaml.load(fp, Loader=yaml.Loader) today = datetime.date.today() if not today in messages: messages[today] = list() messages[today].append(Message(" ".join(args.message))) with store_filename.open("w") as fp: yaml.dump(messages, stream=fp, allow_unicode=True, default_flow_style=False) def get_evernote_credential(credential_json_filename): import json if not credential_json_filename.exists(): logger.debug("credential file not found: {}".format( credential_json_filename)) return None j = None with credential_json_filename.open("r") as fp: j = json.load(fp) if not "evernote" in j: logger.debug( "\"evernote\" not found in credential file: {}".format( credential_json_filename)) return None cred = j["evernote"] if "enable" in cred and cred["enable"] == False: logger.debug( "\"evernote.enable\" is disable in credential file: {}".format( credential_json_filename)) return None if all(key in cred for key in ("sandbox", "developer_token", "notebook_name")): return { "is_sandbox": cred["sandbox"], "developer_token": cred["developer_token"], "notebook_name": cred["notebook_name"], } else: logger.debug( '"sandbox" or "developer_token" or "notebook_name" are not exists in "evernote" section in credential file: {}' .format(credential_json_filename)) evernote_cred = get_evernote_credential(args.credential_json_filename) if evernote_cred is None: logger.info("evernote storage is disabled.") else: logger.info("evernote storage is enabled.") from evernote.api.client import EvernoteClient import evernote.edam.type.ttypes as Types import evernote.edam.notestore.ttypes as NSTypes client = EvernoteClient(token=evernote_cred["developer_token"], sandbox=evernote_cred["is_sandbox"]) note_store = client.get_note_store() notebook_name = evernote_cred["notebook_name"] notebooks = note_store.listNotebooks() target_notebook = None for notebook in notebooks: if notebook_name == notebook.name: target_notebook = notebook break if target_notebook is None: logger.info("create notebook: {}".format(notebook_name)) target_notebook = Types.Notebook() target_notebook.name = notebook_name target_notebook = note_store.createNotebook(target_notebook) target_note = None note_title = "memo {:%Y-%m}".format(today) filter = NSTypes.NoteFilter() filter.notebookGuid = target_notebook.guid resultSpec = NSTypes.NotesMetadataResultSpec() resultSpec.includeTitle = True metalist = note_store.findNotesMetadata(filter, 0, 10, resultSpec) for meta_ in metalist.notes: if note_title == meta_.title: target_note = note_store.getNote(meta_.guid, True, False, False, False) break if target_note is None: logger.info("create note: {}".format(note_title)) note = Types.Note() note.title = note_title note.content = convert_to_evernote_format(messages) note.notebookGuid = target_notebook.guid note_store.createNote(note) else: logger.info("update note: {}".format(note_title)) target_note.content = convert_to_evernote_format(messages) note_store.updateNote(target_note)