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 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 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 __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 _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 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 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 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 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)
# Create UserStore instance user_store = client.get_user_store() # Create NoteStore instance note_store = client.get_note_store() # Retrieve User object user = user_store.getUser() print "Username: %s" % user.username print "Name: %s" % user.name raw_input("Type return to continue...") # Search notes for To-Do / Followup nFilter = NoteStoreTypes.NoteFilter() nFilter.words = "To-Do / Followup" resultSpec = NoteStoreTypes.NotesMetadataResultSpec() resultSpec.includeTitle = True searchResults = note_store.findNotesMetadata(nFilter, 0, 10, resultSpec) if len(searchResults.notes): for note in searchResults.notes: print note.guid print note.title my_note = note_store.getNote(note.guid, True, True, False, False) print my_note.content print '' xml = ET.fromstring(my_note.content) print parseString(my_note.content).toprettyxml() for child in xml.iter('en-todo'): print child.tag, child.attrib, child.tail
#note.content = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">' #note.content += '<en-note>Hello, world!</en-note>' #note = noteStore.createNote(note) #noteStore = client.get_note_store() #notebook = Types.Notebook() #notebook.name = "My Notebook" #notebook = noteStore.createNotebook(notebook) #print notebook.guid client = EvernoteClient(token=dev_token) note_store = client.get_note_store() note_filter = NoteStore.NoteFilter() note_filter.words = 'intitle:"test"' notes_metadata_result_spec = NoteStore.NotesMetadataResultSpec() notes_metadata_list = note_store.findNotesMetadata(note_filter, 0, 1, notes_metadata_result_spec) note_guid = notes_metadata_list.notes[0].guid note = note_store.getNote(note_guid, True, False, False, False) print note auth_token = 'your-token' client = EvernoteClient(token=dev_token) note_store = client.get_note_store() updated_filter = NoteFilter(order=NoteSortOrder.UPDATED) offset = 0 max_notes = 10
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)